zova-cli-set-front 1.1.199 → 1.2.0

package/dist/index.js

@@ -1,3 +1,4707 @@
-export * from './lib/beans.js';
-export * from './lib/commands.js';
-//# sourceMappingURL=index.js.map
+import { BeanCliBase, getCommandsMeta } from '@cabloy/cli';
+import babelPlugin from '@cabloy/vite-plugin-babel';
+import vueJsxPlugin from '@vitejs/plugin-vue-jsx';
+import path from 'node:path';
+import { rimraf } from 'rimraf';
+import { rolldown } from 'rolldown';
+import { dts } from 'rolldown-plugin-dts';
+import { build } from 'vite';
+import { createRequire } from 'node:module';
+import { camelToKebab, replaceTemplate, toUpperCaseFirstChar, toLowerCaseFirstChar, skipPrefix, stringToCapitalize } from '@cabloy/word-utils';
+import fse from 'fs-extra';
+import { build as build$1 } from 'tsdown';
+import { createConfigUtils } from 'zova-vite';
+import { getOnionScenesMeta, getOnionMetasMeta } from '@cabloy/module-info';
+import fs from 'node:fs';
+import compressing from 'compressing';
+import os from 'node:os';
+import urllib from 'urllib';
+import { extend } from '@cabloy/extend';
+import { catchError, matchSelector, getPropertyObject, evaluateSimple, StringPrefixRegexp } from '@cabloy/utils';
+import ts from 'typescript';
+import 'node:url';
+import { globbySync, globby } from 'globby';
+import gogocode from 'gogocode';
+import { optimize } from 'svgo';
+
+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;
+}
+
+class CliBinBuildModule extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    const projectPath = argv.projectPath;
+    await this._vite(projectPath);
+  }
+  async _vite(projectPath) {
+    const {
+      argv
+    } = this.context;
+    await rimraf(path.join(projectPath, 'dist'));
+    await this._buildSrc(projectPath);
+    if (argv.dts) {
+      await this._buildDts(projectPath);
+    }
+  }
+  async _buildDts(projectPath) {
+    const {
+      argv
+    } = this.context;
+    const sourceMap = argv.sourcemap;
+    const inputOptions = {
+      input: 'src/index.ts',
+      plugins: [dts({
+        tsconfig: 'tsconfig.build.json',
+        emitDtsOnly: true
+      })],
+      external: id => {
+        return !id.startsWith('.') && !path.isAbsolute(id);
+      }
+    };
+    const outputOption = {
+      dir: path.join(projectPath, 'dist'),
+      format: 'esm',
+      sourcemap: sourceMap
+    };
+    let bundle;
+    try {
+      bundle = await rolldown(inputOptions);
+      await bundle.write(outputOption);
+    } finally {
+      if (bundle) {
+        // closes the bundle
+        await bundle.close();
+      }
+    }
+  }
+  async _buildSrc(_projectPath) {
+    const {
+      argv
+    } = this.context;
+    const sourceMap = argv.sourcemap;
+    const minify = argv.minify;
+    const babelPluginZovaComponent = getAbsolutePathOfModule('babel-plugin-zova-component', '');
+    const babelPluginZovaBehavior = getAbsolutePathOfModule('babel-plugin-zova-behavior', '');
+    const babelPluginZovaBeanModule = getAbsolutePathOfModule('babel-plugin-zova-bean-module', '');
+    const babelPluginZovaBeanUse = getAbsolutePathOfModule('babel-plugin-zova-bean-use', '');
+    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 = [babelPlugin({
+      filter: /\.ts$/,
+      babelConfig: {
+        babelrc: false,
+        configFile: false,
+        plugins: [[babelPluginZovaBeanModule, {
+          brandName: 'zova'
+        }], [babelPluginZovaBeanUse], [babelPluginTransformTypescriptMetadata], [babelPluginProposalDecorators, {
+          version: 'legacy'
+        }], [babelPluginTransformClassProperties, {
+          loose: true
+        }], [babelPluginTransformTypescript]]
+      }
+    }), vueJsxPlugin({
+      include: /\.[jt]sx$/,
+      babelPlugins: [[babelPluginZovaComponent], [babelPluginZovaBehavior], [babelPluginZovaBeanModule, {
+        brandName: 'zova'
+      }], [babelPluginZovaBeanUse], [babelPluginTransformTypescriptMetadata], [babelPluginProposalDecorators, {
+        version: 'legacy'
+      }], [babelPluginTransformClassProperties, {
+        loose: true
+      }]]
+    })];
+    const viteConfig = {
+      plugins,
+      build: {
+        lib: {
+          entry: 'src/index.ts',
+          formats: ['es'],
+          fileName: 'index'
+        },
+        rolldownOptions: {
+          external: id => {
+            if (id.includes('/assets/')) return true;
+            return !id.startsWith('.') && !path.isAbsolute(id);
+          }
+        },
+        sourcemap: sourceMap,
+        // keep_classnames not take effect for 'oxc'
+        minify: minify ? 'terser' : false,
+        terserOptions: {
+          keep_classnames: true
+        }
+      }
+    };
+    await build(viteConfig);
+  }
+}
+
+const __template_package = `{
+  "name": "{{Name}}",
+  "version": "{{Version}}",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": [
+        "./index.d.mts"
+      ],
+      "import": "./index.mjs"
+    },
+    "./package.json": "./package.json"
+  }
+}
+`;
+class CliBinBuildRest extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    const projectPath = argv.projectPath;
+    //
+    const flavor = argv.flavor || 'admin';
+    const bundleName = `zova-rest-${camelToKebab(flavor)}`;
+    const bundleNameCopy = `${camelToKebab(flavor)}`;
+    //
+    const srcDir = path.join(projectPath, '.zova-rest');
+    const outDir = path.join(projectPath, 'dist', `rest-${flavor}`);
+    await rimraf(srcDir);
+    await fse.ensureDir(srcDir);
+    await rimraf(outDir);
+    // context
+    const context = {
+      projectPath,
+      flavor,
+      bundleName,
+      bundleNameCopy,
+      srcDir,
+      outDir
+    };
+    //
+    await this._prepareResources(context);
+    await this._build(context);
+    //
+    await rimraf(srcDir);
+  }
+  async _prepareResources(context) {
+    // package.json
+    await this._prepareResourcesPackage(context);
+    // index.ts
+    await this._prepareResourcesIndex(context);
+  }
+  async _build({
+    projectPath,
+    flavor,
+    bundleNameCopy,
+    srcDir,
+    outDir
+  }) {
+    const entry = path.join(srcDir, 'index.ts');
+    // build
+    await build$1({
+      entry: [entry],
+      format: ['esm'],
+      outDir,
+      tsconfig: 'tsconfig.rest.json',
+      dts: {
+        resolve: true,
+        resolver: 'tsc',
+        tsgo: true,
+        eager: true,
+        tsconfig: 'tsconfig.rest.json'
+      }
+    });
+    // package.json
+    await fse.copyFile(path.join(srcDir, 'package.json'), path.join(outDir, 'package.json'));
+    // release
+    const outReleasesDir = path.join(projectPath, 'dist-releases', `rest-${flavor}-${process.env.APP_VERSION}`);
+    await fse.copy(outDir, outReleasesDir);
+    // copy
+    _copyToTarget(outDir, process.env.BUILD_REST_COPY_DIST, bundleNameCopy);
+  }
+  async _prepareResourcesPackage({
+    projectPath,
+    flavor,
+    bundleName,
+    srcDir
+  }) {
+    const mode = 'production';
+    const appMode = 'ssr';
+    const configMeta = {
+      flavor,
+      mode,
+      appMode
+    };
+    const configOptions = {
+      appDir: projectPath,
+      runtimeDir: '.zova'
+    };
+    const configUtils = createConfigUtils(configMeta, configOptions);
+    // env
+    const env = configUtils.loadEnvs();
+    // package.json
+    const pkgContent = replaceTemplate(__template_package, {
+      Name: bundleName,
+      Version: env.APP_VERSION
+    });
+    await fse.writeFile(path.join(srcDir, 'package.json'), pkgContent);
+  }
+  async _prepareResourcesIndex({
+    srcDir
+  }) {
+    let indexContent = '';
+    indexContent += await this._prepareResourcesIndex_rest(srcDir);
+    indexContent += await this._prepareResourcesIndex_icons(srcDir);
+    indexContent += await this._prepareResourcesIndex_pages(srcDir);
+    await fse.writeFile(path.join(srcDir, 'index.ts'), indexContent);
+  }
+  async _prepareResourcesIndex_rest(srcDir) {
+    let content = '';
+    for (const module of this.modulesMeta.modulesArray) {
+      const restIndexFile = path.join(module.root, 'rest/index.ts');
+      if (!fse.existsSync(restIndexFile)) continue;
+      const restIndexFileRelative = path.relative(srcDir, restIndexFile);
+      content += `export * from '${restIndexFileRelative}';\n`;
+    }
+    return content;
+  }
+  async _prepareResourcesIndex_icons(_srcDir) {
+    let content = '';
+    for (const module of this.modulesMeta.modulesArray) {
+      const restIconsFile = path.join(module.root, 'rest/icons.txt');
+      if (!fse.existsSync(restIconsFile)) continue;
+      const contentIcons = (await fse.readFile(restIconsFile)).toString();
+      content += `${contentIcons}\n`;
+    }
+    if (content) {
+      content = `export interface IIconRecord {
+${content}
+}
+export function $iconName<K extends keyof IIconRecord>(name: K): any {
+  return name;
+}
+`;
+    }
+    return content;
+  }
+  async _prepareResourcesIndex_pages(_srcDir) {
+    let contentImport = '';
+    let contentRecord = '';
+    for (const module of this.modulesMeta.modulesArray) {
+      const restPagesRecordFile = path.join(module.root, 'rest/pagesRecord.txt');
+      if (!fse.existsSync(restPagesRecordFile)) continue;
+      const restPagesImportFile = path.join(module.root, 'rest/pagesImport.txt');
+      const contentPagesImport = (await fse.readFile(restPagesImportFile)).toString();
+      const contentPagesRecord = (await fse.readFile(restPagesRecordFile)).toString();
+      contentImport += `${contentPagesImport}\n`;
+      contentRecord += `${contentPagesRecord}\n`;
+    }
+    let content = '';
+    if (contentRecord) {
+      content = `${contentImport}
+export interface TypePagePathSchema<PARAMS = unknown, QUERY = unknown> {
+  params?: PARAMS;
+  query?: QUERY;
+}
+export interface IPagePathRecord {
+${contentRecord}
+'/': TypePagePathSchema<undefined,undefined>;
+presetLogin: TypePagePathSchema<undefined,undefined>;
+presetErrorExpired: TypePagePathSchema<undefined,undefined>;
+presetResource: TypePagePathSchema<undefined,undefined>;
+}
+`;
+    }
+    return content;
+  }
+}
+function _copyToTarget(outDir, target, bundleNameCopy) {
+  if (!target) return;
+  const dirs = target.split(',');
+  for (const dir of dirs) {
+    const outReleasesDirCopy = path.join(dir, bundleNameCopy);
+    fse.removeSync(outReleasesDirCopy);
+    fse.copySync(outDir, outReleasesDirCopy, {
+      preserveTimestamps: true
+    });
+  }
+}
+
+const __ThisSetName__ = 'front';
+
+let __snippetsPathPrefix;
+class CliCreateBean extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // 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
+    let beanName = argv.beanName;
+    let beanDir;
+    if (beanName.includes('/')) {
+      // service in component/page
+      const pos = beanName.lastIndexOf('/');
+      const subDir = beanName.substring(0, pos);
+      beanDir = path.join(targetDir, `src/${subDir}`);
+      beanName = argv.beanName = beanName.substring(pos + 1);
+      argv.fileName = `${sceneName}.${beanName}`;
+    } else {
+      beanDir = path.join(targetDir, onionSceneMeta.sceneIsolate ? `src/${sceneName}` : 'src/bean');
+      argv.fileName = onionSceneMeta.sceneIsolate ? beanName : `${sceneName}.${beanName}`;
+    }
+    argv.beanNameCapitalize = this.helper.firstCharToUpperCase(beanName);
+    // moduleResourceName
+    argv.moduleResourceName = this.helper.combineModuleNameAndResource(argv.moduleInfo.relativeName, argv.beanName);
+    // file
+    const beanFile = path.join(beanDir, `${argv.fileName}.ts`);
+    if (fs.existsSync(beanFile)) {
+      throw new Error(`${sceneName} bean exists: ${beanName}`);
+    }
+    // dir
+    await this.helper.ensureDir(beanDir);
+    // boilerplate name
+    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 boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: beanDir,
+      setName: __ThisSetName__,
+      snippetsPath: snippetsName,
+      boilerplatePath: boilerplateName
+    });
+    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] = this._combineBoilerplatesOrSnippetsPath(type, 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}`] = this._combineBoilerplatesOrSnippetsPath(type, onionMetaMeta.module.root, scenePath);
+      }
+    }
+    return result;
+  }
+  _combineBoilerplatesOrSnippetsPath(type, moduleRoot, scenePath) {
+    // boilerplate
+    if (type === 'boilerplate') {
+      return path.join(moduleRoot, 'cli', scenePath);
+    }
+    // snippets
+    if (__snippetsPathPrefix) {
+      return path.join(moduleRoot, __snippetsPathPrefix, scenePath);
+    }
+    let snippetsPath = path.join(moduleRoot, 'dist-cli', scenePath);
+    if (!fse.existsSync(snippetsPath)) {
+      snippetsPath = path.join(moduleRoot, 'cli', scenePath);
+      __snippetsPathPrefix = 'cli';
+    } else {
+      __snippetsPathPrefix = 'dist-cli';
+    }
+    return snippetsPath;
+  }
+}
+
+class CliCreateComponentBase extends BeanCliBase {
+  constructor(options, componentMode) {
+    super(options);
+    this.componentMode = void 0;
+    this.componentMode = componentMode;
+  }
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // 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);
+    // componentName
+    const componentName = argv.componentName;
+    // nameMeta
+    argv.nameMeta = this.helper.parseNameMeta(componentName);
+    // directory
+    let componentDir = path.join(targetDir, 'src/component');
+    componentDir = path.join(componentDir, componentName);
+    if (fs.existsSync(componentDir)) {
+      throw new Error(`component exists: ${componentName}`);
+    }
+    await this.helper.ensureDir(componentDir);
+    // // render snippets
+    // await this.template.renderBoilerplateAndSnippets({
+    //   targetDir,
+    //   setName: __ThisSetName__,
+    //   snippetsPath: `create/${this.componentMode}/snippets`,
+    //   boilerplatePath: null,
+    // });
+    // boilerplate
+    let boilerplate = 'boilerplate';
+    if (argv.boilerplate) {
+      boilerplate = `${boilerplate}${toUpperCaseFirstChar(argv.boilerplate)}`;
+    }
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: componentDir,
+      setName: __ThisSetName__,
+      snippetsPath: null,
+      boilerplatePath: `create/${this.componentMode}/${boilerplate}`
+    });
+    // tools.metadata
+    if (!argv.nometadata) {
+      await this.helper.invokeCli([':tools:metadata', moduleName], {
+        cwd: argv.projectPath
+      });
+    }
+  }
+}
+
+class CliCreateComponent extends CliCreateComponentBase {
+  constructor(options) {
+    super(options, 'component');
+  }
+}
+
+class CliCreateMock extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // 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);
+    // mockName
+    const mockName = argv.mockName;
+    // nameMeta
+    argv.nameMeta = this.helper.parseNameMeta(mockName, ['mock']);
+    // directory
+    const mockDir = path.join(targetDir, 'mock');
+    const mockFile = path.join(mockDir, `${mockName}.fake.ts`);
+    if (fs.existsSync(mockFile)) {
+      throw new Error(`mock exists: ${mockFile}`);
+    }
+    await this.helper.ensureDir(mockDir);
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: mockDir,
+      setName: __ThisSetName__,
+      snippetsPath: null,
+      boilerplatePath: 'create/mock/boilerplate'
+    });
+  }
+}
+
+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 CliCreatePageBase extends BeanCliBase {
+  constructor(options, pageMode) {
+    super(options);
+    this.pageMode = void 0;
+    this.pageMode = pageMode;
+  }
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // 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);
+    // pageName
+    const pageName = argv.pageName;
+    // nameMeta
+    argv.nameMeta = this.helper.parseNameMeta(pageName);
+    // directory
+    let pageDir = path.join(targetDir, 'src/page');
+    pageDir = path.join(pageDir, pageName);
+    if (fs.existsSync(pageDir)) {
+      throw new Error(`page exists: ${pageName}`);
+    }
+    await this.helper.ensureDir(pageDir);
+    // render snippets
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir,
+      setName: __ThisSetName__,
+      snippetsPath: `create/${this.pageMode}/snippets`,
+      boilerplatePath: null
+    });
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: pageDir,
+      setName: __ThisSetName__,
+      snippetsPath: null,
+      boilerplatePath: `create/${this.pageMode}/boilerplate`
+    });
+    // tools.metadata
+    if (!argv.nometadata) {
+      await this.helper.invokeCli([':tools:metadata', moduleName], {
+        cwd: argv.projectPath
+      });
+    }
+    // log url
+    await this.logUrl(argv);
+  }
+  async logUrl(argv) {
+    const env = await this.loadEnvs();
+    const host = !env.DEV_SERVER_HOSTNAME || env.DEV_SERVER_HOSTNAME === 'true' ? 'localhost' : env.DEV_SERVER_HOSTNAME;
+    const port = env.DEV_SERVER_PORT;
+    const url = `http://${host}:${port}/${argv.moduleInfo.pid}/${argv.moduleInfo.name}/${argv.pageName}`;
+    const message = `Page URL: ${url}`;
+    await this.console.log(message);
+  }
+  async loadEnvs() {
+    const configMeta = {
+      flavor: 'admin',
+      mode: 'development',
+      appMode: 'spa'
+    };
+    const configOptions = {
+      appDir: process.cwd(),
+      runtimeDir: '.zova',
+      zovaManualChunk: {
+        debug: false,
+        vendors: []
+      }
+    };
+    // config utils
+    const configUtils = createConfigUtils(configMeta, configOptions);
+    // env
+    const env = configUtils.loadEnvs();
+    return env;
+  }
+}
+
+class CliCreatePage extends CliCreatePageBase {
+  constructor(options) {
+    super(options, 'page');
+  }
+}
+
+// import { __ThisSetName__ } from '../this.ts';
+
+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}`);
+    }
+    // template
+    const template = argv.template;
+    const packageName = `zova-ui-${template}`;
+    // download boilerplate
+    const templateDir = await this.downloadBoilerplate(packageName);
+    fse.copySync(templateDir, targetDir);
+    // remove LICENSE
+    fse.removeSync(path.join(targetDir, 'LICENSE'));
+    // 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 build
+      - npm run preview
+    `);
+  }
+  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);
+  }
+}
+
+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 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 === 'front') {
+      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();
+    // target dir
+    const targetDir = path.join(argv.projectPath, 'src/front/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();
+    // 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();
+    // 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();
+    // 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 CliInitIcon extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // 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 iconDir = path.join(targetDir, 'icons');
+    if (fse.existsSync(iconDir)) {
+      throw new Error(`icon exists: ${moduleName}`);
+    }
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir,
+      setName: __ThisSetName__,
+      snippetsPath: null,
+      boilerplatePath: 'init/icon/boilerplate'
+    });
+    // set zovaModule.capabilities.icon: 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.zovaModule) pkg.zovaModule = {};
+    if (!pkg.zovaModule.capabilities) pkg.zovaModule.capabilities = {};
+    if (pkg.zovaModule.capabilities.icon) return;
+    pkg.zovaModule.capabilities.icon = true;
+    await this.helper.saveJSONFile(pkgFile, pkg);
+  }
+}
+
+class CliInitLegacy extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // target dir
+    const legacyDir = path.join(argv.projectPath, 'src/legacy');
+    if (fse.existsSync(legacyDir)) {
+      throw new Error(`legacy exists: ${legacyDir}`);
+    }
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: legacyDir,
+      setName: __ThisSetName__,
+      snippetsPath: null,
+      boilerplatePath: 'init/legacy/boilerplate'
+    });
+  }
+}
+
+class CliInitLib extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // 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();
+    // 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();
+    // 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 CliInitMainSys extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // 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/mainSys.ts');
+    if (fse.existsSync(mainFile)) {
+      throw new Error(`mainSys exists: ${moduleName}`);
+    }
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: path.join(targetDir, 'src'),
+      setName: __ThisSetName__,
+      snippetsPath: null,
+      boilerplatePath: 'init/mainSys/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();
+    // 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 zovaModule.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.zovaModule) pkg.zovaModule = {};
+    if (!pkg.zovaModule.capabilities) pkg.zovaModule.capabilities = {};
+    let changed;
+    // monkey
+    if (!pkg.zovaModule.capabilities.monkey) {
+      pkg.zovaModule.capabilities.monkey = true;
+      changed = true;
+    }
+    // dependencies
+    if (!pkg.zovaModule.dependencies) pkg.zovaModule.dependencies = {};
+    if (!pkg.zovaModule.dependencies['a-zova']) {
+      pkg.zovaModule.dependencies['a-zova'] = '5.0.0';
+      changed = true;
+    }
+    // save
+    if (changed) {
+      await this.helper.saveJSONFile(pkgFile, pkg);
+    }
+  }
+}
+
+class CliInitMonkeySys extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // 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/monkeySys.ts');
+    if (fse.existsSync(monkeyFile)) {
+      throw new Error(`monkeySys exists: ${moduleName}`);
+    }
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: path.join(targetDir, 'src'),
+      setName: __ThisSetName__,
+      snippetsPath: null,
+      boilerplatePath: 'init/monkeySys/boilerplate'
+    });
+    // set zovaModule.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.zovaModule) pkg.zovaModule = {};
+    if (!pkg.zovaModule.capabilities) pkg.zovaModule.capabilities = {};
+    let changed;
+    // monkey
+    if (!pkg.zovaModule.capabilities.monkey) {
+      pkg.zovaModule.capabilities.monkey = true;
+      changed = true;
+    }
+    // dependencies
+    if (!pkg.zovaModule.dependencies) pkg.zovaModule.dependencies = {};
+    if (!pkg.zovaModule.dependencies['a-zova']) {
+      pkg.zovaModule.dependencies['a-zova'] = '5.0.0';
+      changed = true;
+    }
+    // save
+    if (changed) {
+      await this.helper.saveJSONFile(pkgFile, pkg);
+    }
+  }
+}
+
+class CliInitSysMonkey extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // target dir
+    const targetDir = path.join(argv.projectPath, 'src/front/config');
+    const monkeyFile = path.join(targetDir, 'monkeySys.ts');
+    if (fse.existsSync(monkeyFile)) {
+      throw new Error('sys monkey exists');
+    }
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir,
+      setName: __ThisSetName__,
+      snippetsPath: null,
+      boilerplatePath: 'init/sysMonkey/boilerplate'
+    });
+  }
+}
+
+class CliInitTypes extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // 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 CliOpenapiConfig extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    const moduleNames = argv._;
+    if (moduleNames.length === 0) {
+      moduleNames.push('home-api');
+    }
+    // module config
+    for (const moduleName of moduleNames) {
+      await this._generateModuleConfig(moduleName);
+    }
+    // project config
+    const configFile = path.join(argv.projectPath, 'openapi.config.ts');
+    if (fse.existsSync(configFile)) return;
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: argv.projectPath,
+      setName: __ThisSetName__,
+      snippetsPath: null,
+      boilerplatePath: 'openapi/config/boilerplate/project'
+    });
+  }
+  async _generateModuleConfig(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, 'cli/openapi.config.ts');
+    if (fse.existsSync(configFile)) return;
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: path.join(targetDir, 'cli'),
+      setName: __ThisSetName__,
+      snippetsPath: null,
+      boilerplatePath: 'openapi/config/boilerplate/module'
+    });
+  }
+}
+
+class CliOpenapiGenerate extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // config file
+    const configFile = path.join(argv.projectPath, 'openapi.config.ts');
+    if (!fse.existsSync(configFile)) {
+      throw new Error('Please generate config first!');
+    }
+    const configInstance = await this.helper.importDynamic(configFile);
+    const config = await configInstance.default();
+    // modules: not vendor/node_modules
+    let moduleNames = argv._;
+    if (moduleNames.length === 0) {
+      moduleNames = this.modulesMeta.modulesArray.filter(item => {
+        if (item.info.node_modules || item.info.vendor) return false;
+        const configFile = path.join(item.root, 'cli/openapi.config.ts');
+        return fse.existsSync(configFile);
+      }).map(item => item.info.relativeName);
+    }
+    if (moduleNames.length === 0) return;
+    // openapi-typescript
+    const openapiTypescript = await import('@cabloy/openapi-typescript');
+    // loop
+    const total = moduleNames.length;
+    const __caches = {};
+    for (let index = 0; index < total; index++) {
+      const moduleName = moduleNames[index];
+      // log
+      await this.console.log({
+        total,
+        progress: index,
+        text: moduleName
+      });
+      // generate res
+      const moduleInfo = this.helper.parseModuleInfo(moduleName);
+      const module = this.helper.findModule(moduleName);
+      await this._generateOpenapi(total, openapiTypescript, config, moduleInfo, module, __caches);
+    }
+  }
+  async _generateOpenapi(total, openapiTypescript, config, moduleInfo, module, __caches) {
+    const {
+      argv
+    } = this.context;
+    // config file
+    const configFile = path.join(module.root, 'cli/openapi.config.ts');
+    if (!fse.existsSync(configFile)) {
+      throw new Error(`Please generate config of ${moduleInfo.relativeName} first!`);
+    }
+    const configInstance = await this.helper.importDynamic(configFile);
+    const moduleConfigCli = await configInstance.default();
+    const moduleConfig = extend(true, {
+      apiMeta: false,
+      apiSchema: true
+    }, config.default, moduleConfigCli, config.modules[moduleInfo.relativeName]);
+    const cache = await this._outputFiles(openapiTypescript, moduleConfig, moduleInfo, module, __caches);
+    // generate
+    await this._generateApis(openapiTypescript, cache.ast, moduleConfig, moduleInfo, module);
+    // tools.metadata
+    if (!argv.nometadata || total > 1) {
+      await this.helper.invokeCli([':tools:metadata', moduleInfo.relativeName], {
+        cwd: argv.projectPath
+      });
+    }
+  }
+  async _outputFiles(openapiTypescript, moduleConfig, _moduleInfo, module, __caches) {
+    if (!moduleConfig.source) throw new Error('source not found');
+    // cache
+    let cache = __caches[moduleConfig.source];
+    if (!cache) {
+      const [ast, error] = await catchError(() => {
+        return openapiTypescript.default(moduleConfig.source, _patchOpenapiTSOptions(moduleConfig.options));
+      });
+      if (error) {
+        error.message = `${error.message}: ${moduleConfig.source}`;
+        throw error;
+      }
+      const contents = openapiTypescript.astToString(ast);
+      cache = __caches[moduleConfig.source] = {
+        ast: ast,
+        contents
+      };
+    }
+    // rimraf
+    await rimraf(path.join(module.root, 'src/api'));
+    // rimraf
+    await rimraf(path.join(module.root, 'src/apiMeta'));
+    // rimraf
+    await rimraf(path.join(module.root, 'src/apiSchema'));
+    // output: openapi/types.ts
+    const outputFile = path.join(module.root, 'src/api/openapi/types.ts');
+    await fse.outputFile(outputFile, cache.contents);
+    await this.helper.formatFile({
+      fileName: outputFile
+    });
+    // output: openapi/schemas.ts
+    const schemasFile = path.join(module.root, 'src/api/openapi/schemas.ts');
+    const contentSchemas = this._generateSchemas(cache.ast);
+    await fse.outputFile(schemasFile, contentSchemas || 'export {}');
+    await this.helper.formatFile({
+      fileName: schemasFile
+    });
+    // output: openapi/baseURL.ts
+    const baseURLFile = path.join(module.root, 'src/api/openapi/baseURL.ts');
+    await fse.outputFile(baseURLFile, `import type { ZovaSys } from 'zova';
+
+export const OpenApiBaseURL = (sys: ZovaSys) => {
+  return sys.util.getOpenApiBaseURL('OPENAPI_BASE_URL_${module.name.replace('-', '_').toUpperCase()}');
+};
+`);
+    await this.helper.formatFile({
+      fileName: baseURLFile
+    });
+    // output: openapi/index.ts
+    const indexFile = path.join(module.root, 'src/api/openapi/index.ts');
+    await fse.outputFile(indexFile, "export * from './baseURL.js';\nexport * from './schemas.js';\nexport * from './types.js';");
+    await this.helper.formatFile({
+      fileName: indexFile
+    });
+    return cache;
+  }
+  _generateSchemas(ast) {
+    const nodeComponents = ast.find(node => ts.isInterfaceDeclaration(node) && node.name.text === 'components');
+    if (!nodeComponents) return '';
+    const nodeTypeInfoComponents = _parseNodeType(nodeComponents);
+    if (!nodeTypeInfoComponents.schemas) return '';
+    const nodeTypeInfoSchemas = _parseNodeType(nodeTypeInfoComponents.schemas.nodeType);
+    const typeSchemas = [];
+    for (const key in nodeTypeInfoSchemas) {
+      const schemaName = `ApiSchema${key.replaceAll('.', '-').split('-').map(item => toUpperCaseFirstChar(item)).join('')}`;
+      typeSchemas.push(`export type ${schemaName} = components["schemas"]["${key}"];`);
+      typeSchemas.push(`export type ${schemaName}Partial = Partial<${schemaName}>;`);
+    }
+    let contentSchemas = typeSchemas.join('\n');
+    if (contentSchemas.includes('components["schemas"]')) {
+      contentSchemas = `import type { components } from './types.js';\n${contentSchemas}`;
+    }
+    contentSchemas = `// eslint-disable\n${contentSchemas}`;
+    return contentSchemas;
+  }
+  async _generateApis(openapiTypescript, ast, moduleConfig, _moduleInfo, module) {
+    const nodeApis = this._getNodeApis(ast, moduleConfig);
+    if (!nodeApis) return;
+    for (const apiName in nodeApis) {
+      const apiNameLower = toLowerCaseFirstChar(apiName);
+      const nodeApi = nodeApis[apiName];
+      const {
+        apiContent,
+        apiMetaContent,
+        apiSchemaContent
+      } = this._generateApi(openapiTypescript, ast, apiName, nodeApi);
+      // api
+      const apiFile = path.join(module.root, `src/api/${apiNameLower}.ts`);
+      await fse.outputFile(apiFile, apiContent);
+      await this.helper.formatFile({
+        fileName: apiFile
+      });
+      // apiMeta
+      if (moduleConfig.apiMeta) {
+        const apiMetaFile = path.join(module.root, `src/apiMeta/${apiNameLower}.ts`);
+        await fse.outputFile(apiMetaFile, apiMetaContent);
+        await this.helper.formatFile({
+          fileName: apiMetaFile
+        });
+      }
+      // apiSchema
+      if (moduleConfig.apiSchema) {
+        const apiSchemaFile = path.join(module.root, `src/apiSchema/${apiNameLower}.ts`);
+        await fse.outputFile(apiSchemaFile, apiSchemaContent);
+        await this.helper.formatFile({
+          fileName: apiSchemaFile
+        });
+      }
+    }
+  }
+  _generateAction(openapiTypescript, ast, nodeActionInfo) {
+    // pathInfo
+    const pathInfo = _getRequestPathInfo(ast, nodeActionInfo);
+    // contentTypes
+    const contentTypes = [];
+    contentTypes.push(`\n/** ${nodeActionInfo.operationId} */`);
+    // name: ApiAction
+    const nameApiAction = `Api${nodeActionInfo.api}${nodeActionInfo.action}`;
+    // name: path
+    const nameRequestPath = `Api${nameApiAction}Path`;
+    contentTypes.push(`export const ${nameRequestPath} = '${pathInfo.path}';`);
+    contentTypes.push(`export type ${nameRequestPath} = '${pathInfo.path}' `);
+    // name: method
+    const nameRequestMethod = `Api${nameApiAction}Method`;
+    contentTypes.push(`export type ${nameRequestMethod} = '${pathInfo.method}';`);
+    // name: params/query/headers
+    const parametersInfo = {};
+    const nodeTypeInfoParameters = _parseNodeType(nodeActionInfo.nodeTypeInfo.parameters.nodeType);
+    // authToken
+    let contentAuthToken = '';
+    if (nodeActionInfo.nodeTypeInfo.authToken) {
+      contentAuthToken = ', true';
+    }
+    for (const key of ['path', 'query', 'header']) {
+      if (_isNodeNever(nodeTypeInfoParameters[key].nodeType)) continue;
+      const key2 = key === 'path' ? 'params' : key === 'header' ? 'headers' : key;
+      const key2Upper = toUpperCaseFirstChar(key2);
+      const info = {
+        name: `Api${nameApiAction}Request${key2Upper}`,
+        question: nodeTypeInfoParameters[key].question
+      };
+      parametersInfo[key2] = info;
+      contentTypes.push(`export type ${info.name} = paths[${nameRequestPath}][${nameRequestMethod}]['parameters']['${key}'];`);
+    }
+    // name: request body
+    let nameRequestBody = '';
+    let nameRequestBodyQuestion = true;
+    let isUpload = false;
+    if (!_isNodeNever(nodeActionInfo.nodeTypeInfo.requestBody.nodeType)) {
+      nameRequestBody = `Api${nameApiAction}RequestBody`;
+      nameRequestBodyQuestion = nodeActionInfo.nodeTypeInfo.requestBody.question;
+      const nodeRequestBodyInfo = _parseNodeType(nodeActionInfo.nodeTypeInfo.requestBody.nodeType);
+      const nodeRequestBodyContentInfo = _parseNodeType(nodeRequestBodyInfo.content.nodeType);
+      const nodeRequestBodyApplicationJson = nodeRequestBodyContentInfo['application/json'] ?? nodeRequestBodyContentInfo['multipart/form-data'];
+      isUpload = !!nodeRequestBodyContentInfo['multipart/form-data'];
+      const typeRequestBody = openapiTypescript.astToString(nodeRequestBodyApplicationJson.nodeType);
+      contentTypes.push(`export type ${nameRequestBody} = ${typeRequestBody};`);
+    }
+    // name: response body
+    const nameResponseBody = `Api${nameApiAction}ResponseBody`;
+    contentTypes.push(`export type ${nameResponseBody} = paths[${nameRequestPath}][${nameRequestMethod}]['responses']['200']['content']['application/json']['data'];`);
+    // content: options
+    const contentOptions = [];
+    let contentOptionsQuestion = true;
+    for (const key of ['params', 'query', 'headers']) {
+      const info = parametersInfo[key];
+      if (!info) continue;
+      if (!info.question) contentOptionsQuestion = false;
+      contentOptions.push(`${key}${_q(info.question)}: ${info.name};`);
+    }
+    const contentOptions2 = contentOptions.length > 0 ? `options${_q(contentOptionsQuestion)}: {\n${contentOptions.join('\n')}\n} & IApiActionOptions,` : `options${_q(contentOptionsQuestion)}: IApiActionOptions,`;
+    // content: request body
+    let contentRequestBody = '';
+    if (!['get', 'delete'].includes(pathInfo.method)) {
+      if (!nameRequestBody) {
+        contentRequestBody = `body${_q(contentOptionsQuestion)}: undefined,`;
+      } else {
+        if (nameRequestBodyQuestion) {
+          contentRequestBody = `body${_q(contentOptionsQuestion)}: ${nameRequestBody} | undefined,`;
+        } else {
+          contentRequestBody = `body: ${nameRequestBody},`;
+        }
+      }
+    }
+    // content: path translate
+    const contentPathTranslate = parametersInfo.params ? `this.$pathTranslate(${nameRequestPath}, options${_q(contentOptionsQuestion)}.params),` : `${nameRequestPath},`;
+    // content: comment
+    const contentComments = pathInfo.comments && pathInfo.comments.length > 0 ? `/*${pathInfo.comments.join()}*/\n` : '';
+    // content: body
+    const contentBodyParams = isUpload ? 'this.$formData(body)' : 'body';
+    // content: signature
+    const contentSignature = `${contentComments}${nodeActionInfo.action}(
+      ${contentRequestBody}
+      ${contentOptions2}
+    ) {
+      return this.$fetch.${pathInfo.method}<any, ${nameResponseBody}>(
+        ${contentPathTranslate} ${contentRequestBody ? `${contentBodyParams},` : ''}
+        this.$configPrepare(OpenApiBaseURL(this.sys), options${contentAuthToken}),
+      );
+    }\n`;
+    return [contentTypes.join('\n'), contentSignature, nodeActionInfo.action, nameRequestPath, pathInfo.method];
+  }
+  _generateApi(openapiTypescript, ast, apiName, nodeApi) {
+    const apiNameLower = toLowerCaseFirstChar(apiName);
+    const contentTypes = [];
+    const contentSignatures = [];
+    const contentActions = [];
+    const contentApiPaths = [];
+    const contentApiMethods = [];
+    for (const actionName in nodeApi) {
+      const nodeActionInfo = nodeApi[actionName];
+      const contentAction = this._generateAction(openapiTypescript, ast, nodeActionInfo);
+      const [_contentType, _contentSignature, _action, _apiPath, _apiMethod] = contentAction;
+      contentTypes.push(_contentType);
+      contentSignatures.push(_contentSignature);
+      contentActions.push(_action);
+      contentApiPaths.push(_apiPath);
+      contentApiMethods.push(_apiMethod);
+    }
+    //
+    const contentTypes2 = contentTypes.join('\n');
+    const importsType = [];
+    if (contentSignatures.length > 0) importsType.push('OpenApiBaseURL');
+    if (contentTypes2.includes('components["schemas"]')) importsType.push('type components');
+    if (contentTypes2.includes('paths[')) importsType.push('type paths');
+    const contentImportsType = importsType.length > 0 ? `import { ${importsType.join(', ')} } from './openapi/index.js';` : '';
+    // apiContent
+    const apiContent = `import { Api, BeanApiBase, IApiActionOptions } from 'zova-module-a-api';
+${contentImportsType}
+
+${contentTypes2}
+
+@Api()
+export class Api${apiName} extends BeanApiBase {
+  ${contentSignatures.join('\n')}
+}
+`;
+    // apiMetaContent/apiSchemaContent
+    const importsApiPath = [];
+    const contentMetaSignatures = [];
+    const contentSchemaSignatures = [];
+    for (let i = 0; i < contentActions.length; i++) {
+      importsApiPath.push(contentApiPaths[i]);
+      contentMetaSignatures.push(`get ${contentActions[i]}() {
+    return [${contentApiPaths[i]}, '${contentApiMethods[i]}'];
+  }
+`);
+      contentSchemaSignatures.push(`${contentActions[i]}(options?: IApiSchemaOptions) {
+    return this.$sdk.createApiSchemas(${contentApiPaths[i]}, '${contentApiMethods[i]}', options);
+  }
+`);
+    }
+    const contentImportsApiPath = importsApiPath.length > 0 ? `import { ${importsApiPath.join(', ')} } from '../api/${apiNameLower}.js';` : '';
+    const apiMetaContent = `import { BeanBase } from 'zova';
+import { ApiMeta } from 'zova-module-a-api';
+${contentImportsApiPath}
+
+@ApiMeta()
+export class ApiMeta${apiName} extends BeanBase {
+  ${contentMetaSignatures.join('\n')}
+}
+`;
+    const apiSchemaContent = `import { BeanBase } from 'zova';
+import { ApiSchema, IApiSchemaOptions } from 'zova-module-a-api';
+${contentImportsApiPath}
+
+@ApiSchema()
+export class ApiSchema${apiName} extends BeanBase {
+  ${contentSchemaSignatures.join('\n')}
+}
+`;
+    return {
+      apiContent,
+      apiMetaContent,
+      apiSchemaContent
+    };
+  }
+  _getNodeApis(ast, moduleConfig) {
+    const nodeOperations = ast.find(node => ts.isInterfaceDeclaration(node) && node.name.text === 'operations');
+    if (!nodeOperations) return;
+    const apis = {};
+    for (let index = 0; index < nodeOperations.members.length; index++) {
+      const node = nodeOperations.members[index];
+      if (!ts.isPropertySignature(node)) continue;
+      const operationId = node.name.text;
+      if (!_checkOperationIdEnabled(moduleConfig, operationId)) continue;
+      let [api, action] = operationId.toString().split('_');
+      if (!action) {
+        action = api;
+        api = 'default';
+      }
+      if (!apis[api]) {
+        apis[api] = {};
+      }
+      apis[api][action] = {
+        api,
+        apiLower: toLowerCaseFirstChar(api),
+        action,
+        operationId,
+        node,
+        nodeTypeInfo: _parseNodeType(node.type)
+      };
+    }
+    return apis;
+  }
+}
+function _getRequestPathInfo(ast, nodeActionInfo) {
+  const nodePaths = ast.find(node => ts.isInterfaceDeclaration(node) && node.name.text === 'paths');
+  if (!nodePaths) throw new Error('paths not found');
+  let path;
+  let method;
+  let comments;
+  const nodePath = nodePaths.members.find(node => {
+    if (!ts.isPropertySignature(node)) return false;
+    if (!node.type || !ts.isTypeLiteralNode(node.type)) return false;
+    path = node.name.text;
+    const nodeMethod = node.type.members.find(item => {
+      if (!ts.isPropertySignature(item)) return false;
+      if (!item.type || !ts.isIndexedAccessTypeNode(item.type)) return false;
+      const operationId = item.type.indexType.literal.text;
+      if (operationId !== nodeActionInfo.operationId) return false;
+      method = item.name.text;
+      // comment
+      const nodeComments = item.emitNode?.leadingComments;
+      if (nodeComments) {
+        comments = nodeComments.map(nodeComment => nodeComment.text);
+      }
+      return true;
+    });
+    return !!nodeMethod;
+  });
+  if (!nodePath) throw new Error('path not found');
+  return {
+    path,
+    method,
+    comments,
+    nodePath
+  };
+}
+function _parseNodeType(nodeType) {
+  if (!nodeType || !nodeType.members) return;
+  const nodeTypeInfo = {};
+  nodeType.members.forEach(node => {
+    if (!ts.isPropertySignature(node)) return;
+    const name = node.name.text;
+    const value = node.type;
+    nodeTypeInfo[name] = {
+      question: !!node.questionToken,
+      nodeType: value
+    };
+  });
+  return nodeTypeInfo;
+}
+function _isNodeNever(node) {
+  return node.kind === ts.SyntaxKind.NeverKeyword;
+}
+function _q(question) {
+  return question ? '?' : '';
+}
+function _checkOperationIdEnabled(moduleConfig, selector) {
+  if (!selector) return false;
+  if (!moduleConfig.operations?.match && !moduleConfig.operations?.ignore) return true;
+  return moduleConfig.operations?.match && matchSelector(moduleConfig.operations?.match, selector) || moduleConfig.operations?.ignore && !matchSelector(moduleConfig.operations?.ignore, selector);
+}
+
+/**
+ * https://github.com/openapi-ts/openapi-typescript/issues/1214
+ * https://openapi-ts.dev/node#example-blob-types
+ */
+const BLOB = ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Blob')); // `Blob`
+const DATE = ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Date')); // `Date`
+// const NULL = ts.factory.createLiteralTypeNode(ts.factory.createNull()); // `null`
+const UNDEFINED = ts.factory.createKeywordTypeNode(ts.SyntaxKind.UndefinedKeyword);
+function _patchOpenapiTSOptions(options) {
+  const transformCustom = options?.transform;
+  const postTransformCustom = options?.postTransform;
+  return Object.assign({
+    defaultNonNullable: false
+  }, options, {
+    transform(schemaObject, options) {
+      if (transformCustom) {
+        const res = transformCustom(schemaObject, options);
+        if (res !== undefined) return res;
+      }
+      // multipart
+      if (schemaObject.format === 'binary') {
+        if (options.path?.includes('multipart~1form-data') || options.path?.includes('application~1octet-stream')) {
+          return {
+            // schema: schemaObject.nullable
+            //   ? ts.factory.createUnionTypeNode([BLOB, NULL])
+            //   : BLOB,
+            schema: BLOB,
+            questionToken: schemaObject.nullable
+          };
+        }
+      } else if (schemaObject.format === 'date') {
+        return {
+          schema: DATE,
+          questionToken: schemaObject.nullable
+        };
+      }
+      // default
+      return undefined;
+    },
+    postTransform(type, options) {
+      if (postTransformCustom) {
+        const res = postTransformCustom(type, options);
+        if (res !== undefined) return res;
+      }
+      // path param
+      const paramMatched = options.path?.match(/parameters\/path\/([^/]+)$/);
+      if (paramMatched) {
+        const paramName = paramMatched[1];
+        if (options.path?.includes(`{${paramName}?}`)) {
+          return ts.factory.createUnionTypeNode([type, UNDEFINED]);
+        }
+      }
+    }
+  });
+}
+
+class CliRefactorAnotherRender extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // 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);
+    // componentName
+    const componentName = argv.componentName;
+    // nameMeta
+    argv.nameMeta = this.helper.parseNameMeta(componentName, ['component', 'page']);
+    argv.renderNameCapitalize = this.helper.firstCharToUpperCase(argv.renderName);
+    argv.renderClassName = `Render${argv.nameMeta.directory === 'page' ? 'Page' : ''}${argv.renderNameCapitalize}`;
+    // directory
+    const componentDir = path.join(targetDir, 'src', argv.nameMeta.original);
+    if (!fs.existsSync(componentDir)) {
+      throw new Error(`component not exists: ${componentDir}`);
+    }
+    const renderFile = path.join(componentDir, `render.${argv.renderName}.tsx`);
+    if (fs.existsSync(renderFile)) {
+      throw new Error(`render exists: ${renderFile}`);
+    }
+    // render file must exists
+    const renderFileFirst = path.join(componentDir, 'render.tsx');
+    if (!fs.existsSync(renderFileFirst)) {
+      await this.helper.invokeCli([':refactor:firstRender', argv.componentName, `--module=${moduleName}`], {
+        cwd: argv.projectPath
+      });
+    }
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: componentDir,
+      setName: __ThisSetName__,
+      snippetsPath: 'refactor/anotherRender/snippets',
+      boilerplatePath: 'refactor/anotherRender/boilerplate'
+    });
+    // tools.metadata
+    if (!argv.nometadata) {
+      await this.helper.invokeCli([':tools:metadata', moduleName], {
+        cwd: argv.projectPath
+      });
+    }
+  }
+}
+
+class CliRefactorAnotherStyle extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // 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);
+    // componentName
+    const componentName = argv.componentName;
+    // nameMeta
+    argv.nameMeta = this.helper.parseNameMeta(componentName, ['component', 'page']);
+    argv.styleNameCapitalize = this.helper.firstCharToUpperCase(argv.styleName);
+    argv.styleClassName = `Style${argv.nameMeta.directory === 'page' ? 'Page' : ''}${argv.styleNameCapitalize}`;
+    argv.controllerClassName = `Controller${argv.nameMeta.directory === 'page' ? 'Page' : ''}${argv.nameMeta.shortCapitalize}`;
+    // directory
+    const componentDir = path.join(targetDir, 'src', argv.nameMeta.original);
+    if (!fs.existsSync(componentDir)) {
+      throw new Error(`component not exists: ${componentDir}`);
+    }
+    const styleFile = path.join(componentDir, `style.${argv.styleName}.ts`);
+    if (fs.existsSync(styleFile)) {
+      throw new Error(`style exists: ${styleFile}`);
+    }
+    // style file must exists
+    const styleFileFirst = path.join(componentDir, 'style.ts');
+    if (!fs.existsSync(styleFileFirst)) {
+      await this.helper.invokeCli([':refactor:firstStyle', argv.componentName, `--module=${moduleName}`], {
+        cwd: argv.projectPath
+      });
+    }
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: componentDir,
+      setName: __ThisSetName__,
+      snippetsPath: 'refactor/anotherStyle/snippets',
+      boilerplatePath: 'refactor/anotherStyle/boilerplate'
+    });
+    // tools.metadata
+    if (!argv.nometadata) {
+      await this.helper.invokeCli([':tools:metadata', moduleName], {
+        cwd: argv.projectPath
+      });
+    }
+  }
+}
+
+function getControllerFileName(module, type, beanName) {
+  const controllerFile = path.join(module.root, `src/${type}/${beanName}/controller.ts`);
+  if (fs.existsSync(controllerFile)) {
+    return 'controller.ts';
+  }
+  return 'controller.tsx';
+}
+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`);
+}
+
+class CliRefactorComponentEmits extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // 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);
+    // componentName
+    const componentName = argv.componentName;
+    // nameMeta
+    argv.nameMeta = this.helper.parseNameMeta(componentName, ['component']);
+    argv.controllerClassName = `Controller${argv.nameMeta.shortCapitalize}`;
+    argv.controllerFileName = getControllerFileName(_module, 'component', argv.nameMeta.short);
+    // directory
+    const componentDir = path.join(targetDir, 'src/component', argv.nameMeta.short);
+    if (!fs.existsSync(componentDir)) {
+      throw new Error(`component not exists: ${componentDir}`);
+    }
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: componentDir,
+      setName: __ThisSetName__,
+      snippetsPath: 'refactor/componentEmits/snippets',
+      boilerplatePath: null
+    });
+    // tools.metadata
+    if (!argv.nometadata) {
+      await this.helper.invokeCli([':tools:metadata', moduleName], {
+        cwd: argv.projectPath
+      });
+    }
+  }
+}
+
+class CliRefactorComponentGeneric extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // 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);
+    // componentName
+    const componentName = argv.componentName;
+    // nameMeta
+    argv.nameMeta = this.helper.parseNameMeta(componentName, ['component']);
+    argv.controllerClassName = `Controller${argv.nameMeta.shortCapitalize}`;
+    argv.controllerFileName = getControllerFileName(_module, 'component', argv.nameMeta.short);
+    // directory
+    const componentDir = path.join(targetDir, 'src/component', argv.nameMeta.short);
+    if (!fs.existsSync(componentDir)) {
+      throw new Error(`component not exists: ${componentDir}`);
+    }
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: componentDir,
+      setName: __ThisSetName__,
+      snippetsPath: 'refactor/componentGeneric/snippets',
+      boilerplatePath: null
+    });
+    // tools.metadata
+    if (!argv.nometadata) {
+      await this.helper.invokeCli([':tools:metadata', moduleName], {
+        cwd: argv.projectPath
+      });
+    }
+  }
+}
+
+class CliRefactorComponentModel extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // 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);
+    // componentName
+    const componentName = argv.componentName;
+    // nameMeta
+    argv.nameMeta = this.helper.parseNameMeta(componentName, ['component']);
+    argv.controllerClassName = `Controller${argv.nameMeta.shortCapitalize}`;
+    argv.controllerFileName = getControllerFileName(_module, 'component', argv.nameMeta.short);
+    // directory
+    const componentDir = path.join(targetDir, 'src/component', argv.nameMeta.short);
+    if (!fs.existsSync(componentDir)) {
+      throw new Error(`component not exists: ${componentDir}`);
+    }
+    // props
+    for (const cmd of ['componentProps']) {
+      try {
+        await this.helper.invokeCli([`:refactor:${cmd}`, componentName, `--module=${moduleName}`], {
+          cwd: argv.projectPath
+        });
+      } catch (_) {}
+    }
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: componentDir,
+      setName: __ThisSetName__,
+      snippetsPath: 'refactor/componentModel/snippets',
+      boilerplatePath: null
+    });
+    // tools.metadata
+    if (!argv.nometadata) {
+      await this.helper.invokeCli([':tools:metadata', moduleName], {
+        cwd: argv.projectPath
+      });
+    }
+  }
+}
+
+class CliRefactorComponentProps extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // 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);
+    // componentName
+    const componentName = argv.componentName;
+    // nameMeta
+    argv.nameMeta = this.helper.parseNameMeta(componentName, ['component']);
+    argv.controllerClassName = `Controller${argv.nameMeta.shortCapitalize}`;
+    argv.controllerFileName = getControllerFileName(_module, 'component', argv.nameMeta.short);
+    // directory
+    const componentDir = path.join(targetDir, 'src/component', argv.nameMeta.short);
+    if (!fs.existsSync(componentDir)) {
+      throw new Error(`component not exists: ${componentDir}`);
+    }
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: componentDir,
+      setName: __ThisSetName__,
+      snippetsPath: 'refactor/componentProps/snippets',
+      boilerplatePath: null
+    });
+    // tools.metadata
+    if (!argv.nometadata) {
+      await this.helper.invokeCli([':tools:metadata', moduleName], {
+        cwd: argv.projectPath
+      });
+    }
+  }
+}
+
+class CliRefactorComponentSlots extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // 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);
+    // componentName
+    const componentName = argv.componentName;
+    // nameMeta
+    argv.nameMeta = this.helper.parseNameMeta(componentName, ['component']);
+    argv.controllerClassName = `Controller${argv.nameMeta.shortCapitalize}`;
+    argv.controllerFileName = getControllerFileName(_module, 'component', argv.nameMeta.short);
+    // directory
+    const componentDir = path.join(targetDir, 'src/component', argv.nameMeta.short);
+    if (!fs.existsSync(componentDir)) {
+      throw new Error(`component not exists: ${componentDir}`);
+    }
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: componentDir,
+      setName: __ThisSetName__,
+      snippetsPath: 'refactor/componentSlots/snippets',
+      boilerplatePath: null
+    });
+    // tools.metadata
+    if (!argv.nometadata) {
+      await this.helper.invokeCli([':tools:metadata', moduleName], {
+        cwd: argv.projectPath
+      });
+    }
+  }
+}
+
+class CliRefactorFirstRender extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // 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);
+    // componentName
+    const componentName = argv.componentName;
+    // nameMeta
+    argv.nameMeta = this.helper.parseNameMeta(componentName, ['component', 'page']);
+    argv.renderName = 'render';
+    argv.renderNameCapitalize = this.helper.firstCharToUpperCase(argv.renderName);
+    argv.renderClassName = `Render${argv.nameMeta.directory === 'page' ? 'Page' : ''}${argv.nameMeta.shortCapitalize}`;
+    // directory
+    const componentDir = path.join(targetDir, 'src', argv.nameMeta.original);
+    if (!fs.existsSync(componentDir)) {
+      throw new Error(`component not exists: ${componentDir}`);
+    }
+    const renderFile = path.join(componentDir, `${argv.renderName}.tsx`);
+    if (fs.existsSync(renderFile)) {
+      throw new Error(`render exists: ${renderFile}`);
+    }
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: componentDir,
+      setName: __ThisSetName__,
+      snippetsPath: null,
+      boilerplatePath: 'refactor/firstRender/boilerplate'
+    });
+    // controller render
+    let controllerFile = path.join(componentDir, 'controller.tsx');
+    if (!fs.existsSync(controllerFile)) {
+      controllerFile = path.join(componentDir, 'controller.ts');
+    }
+    let controllerContent = (await fse.readFile(controllerFile)).toString();
+    controllerContent = controllerContent.replace('protected render() {', 'protected _render() {');
+    await fse.writeFile(controllerFile, controllerContent);
+    // tools.metadata
+    if (!argv.nometadata) {
+      await this.helper.invokeCli([':tools:metadata', moduleName], {
+        cwd: argv.projectPath
+      });
+    }
+  }
+}
+
+class CliRefactorFirstStyle extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // 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);
+    // componentName
+    const componentName = argv.componentName;
+    // nameMeta
+    argv.nameMeta = this.helper.parseNameMeta(componentName, ['component', 'page']);
+    argv.styleName = 'style';
+    argv.styleNameCapitalize = this.helper.firstCharToUpperCase(argv.styleName);
+    argv.styleClassName = `Style${argv.nameMeta.directory === 'page' ? 'Page' : ''}${argv.nameMeta.shortCapitalize}`;
+    argv.controllerClassName = `Controller${argv.nameMeta.directory === 'page' ? 'Page' : ''}${argv.nameMeta.shortCapitalize}`;
+    // directory
+    const componentDir = path.join(targetDir, 'src', argv.nameMeta.original);
+    if (!fs.existsSync(componentDir)) {
+      throw new Error(`component not exists: ${componentDir}`);
+    }
+    const styleFile = path.join(componentDir, `${argv.styleName}.ts`);
+    if (fs.existsSync(styleFile)) {
+      throw new Error(`style exists: ${styleFile}`);
+    }
+    // render file must exists
+    const renderFile = path.join(componentDir, 'render.tsx');
+    if (!fs.existsSync(renderFile)) {
+      await this.helper.invokeCli([':refactor:firstRender', argv.componentName, `--module=${moduleName}`], {
+        cwd: argv.projectPath
+      });
+    }
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: componentDir,
+      setName: __ThisSetName__,
+      snippetsPath: null,
+      boilerplatePath: 'refactor/firstStyle/boilerplate'
+    });
+    // tools.metadata
+    if (!argv.nometadata) {
+      await this.helper.invokeCli([':tools:metadata', moduleName], {
+        cwd: argv.projectPath
+      });
+    }
+  }
+}
+
+class CliRefactorPageParams extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // 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);
+    // pageName
+    const pageName = argv.pageName;
+    // nameMeta
+    argv.nameMeta = this.helper.parseNameMeta(pageName, ['page']);
+    argv.controllerClassName = `ControllerPage${argv.nameMeta.shortCapitalize}`;
+    argv.controllerFileName = getControllerFileName(_module, 'page', argv.nameMeta.short);
+    // directory
+    const pageDir = path.join(targetDir, 'src/page', argv.nameMeta.short);
+    if (!fs.existsSync(pageDir)) {
+      throw new Error(`page not exists: ${pageDir}`);
+    }
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: pageDir,
+      setName: __ThisSetName__,
+      snippetsPath: 'refactor/pageParams/snippets',
+      boilerplatePath: null
+    });
+    // tools.metadata
+    if (!argv.nometadata) {
+      await this.helper.invokeCli([':tools:metadata', moduleName], {
+        cwd: argv.projectPath
+      });
+    }
+  }
+}
+
+class CliRefactorPageQuery extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // 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);
+    // pageName
+    const pageName = argv.pageName;
+    // nameMeta
+    argv.nameMeta = this.helper.parseNameMeta(pageName, ['page']);
+    argv.controllerClassName = `ControllerPage${argv.nameMeta.shortCapitalize}`;
+    argv.controllerFileName = getControllerFileName(_module, 'page', argv.nameMeta.short);
+    // directory
+    const pageDir = path.join(targetDir, 'src/page', argv.nameMeta.short);
+    if (!fs.existsSync(pageDir)) {
+      throw new Error(`page not exists: ${pageDir}`);
+    }
+    // render boilerplate
+    await this.template.renderBoilerplateAndSnippets({
+      targetDir: pageDir,
+      setName: __ThisSetName__,
+      snippetsPath: 'refactor/pageQuery/snippets',
+      boilerplatePath: null
+    });
+    // tools.metadata
+    if (!argv.nometadata) {
+      await this.helper.invokeCli([':tools:metadata', moduleName], {
+        cwd: argv.projectPath
+      });
+    }
+  }
+}
+
+class CliRefactorRenameComponent extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    // 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);
+    // componentName
+    const componentName = argv.componentName;
+    // nameMeta
+    argv.nameMeta = this.helper.parseNameMeta(componentName, ['component', 'page']);
+    argv.componentNameNewCapitalize = this.helper.firstCharToUpperCase(argv.componentNameNew);
+    // directory
+    const componentDir = path.join(targetDir, 'src', argv.nameMeta.original);
+    if (!fse.existsSync(componentDir)) {
+      throw new Error(`component not exists: ${componentDir}`);
+    }
+    // rename
+    await this._renameRoute(targetDir);
+    await this._renameFiles(componentDir);
+    await this._renameDir(componentDir, targetDir);
+    // tools.metadata
+    if (!argv.nometadata) {
+      await this.helper.invokeCli([':tools:metadata', moduleName], {
+        cwd: argv.projectPath
+      });
+    }
+  }
+  async _renameDir(componentDir, targetDir) {
+    const {
+      argv
+    } = this.context;
+    // delete old vue
+    const componentVueOld = path.join(targetDir, 'src/.metadata', argv.nameMeta.directory === 'page' ? 'page' : 'component', `${argv.nameMeta.short}.ts`);
+    await fse.remove(componentVueOld);
+    // delete rest
+    const restDir = path.join(targetDir, 'rest');
+    await fse.remove(restDir);
+    // rename
+    const componentDirNew = path.join(targetDir, 'src', argv.nameMeta.directory === 'page' ? 'page' : 'component', argv.componentNameNew);
+    await fse.rename(componentDir, componentDirNew);
+  }
+  async _renameRoute(targetDir) {
+    const {
+      argv
+    } = this.context;
+    if (argv.nameMeta.directory !== 'page') return;
+    const routesFile = path.join(targetDir, 'src/routes.ts');
+    let content = (await fse.readFile(routesFile)).toString();
+    //
+    content = content.replace(`import { ZPage${argv.nameMeta.shortCapitalize} } from './.metadata/page/${argv.nameMeta.short}.js';`, `import { ZPage${argv.componentNameNewCapitalize} } from './.metadata/page/${argv.componentNameNew}.js';`);
+    //
+    const ast = gogocode(content);
+    const astNode = ast.find('export const routes: IModuleRoute[] = [$_$]');
+    const astMatches = astNode.match[0];
+    const astMatch = astMatches.find(item => {
+      return item.node.properties.some(prop => {
+        return prop.key.name === 'component' && prop.value.name === `ZPage${argv.nameMeta.shortCapitalize}`;
+      });
+    });
+    if (!astMatch) {
+      throw new Error(`page route not found: ${argv.nameMeta.shortCapitalize}`);
+    }
+    const astPropComponent = astMatch?.node?.properties.find(prop => {
+      return prop.key.name === 'component';
+    });
+    astPropComponent.value.name = `ZPage${argv.componentNameNewCapitalize}`;
+    const astPropPath = astMatch?.node?.properties.find(prop => {
+      return prop.key.name === 'path';
+    });
+    if (astPropPath && astPropPath.value.value) {
+      astPropPath.value.value = astPropPath.value.value.replace(argv.nameMeta.short, argv.componentNameNew);
+    }
+    content = ast.root().generate();
+    await fse.writeFile(routesFile, content);
+    // format
+    await this.helper.formatFile({
+      fileName: routesFile,
+      logPrefix: 'format: '
+    });
+  }
+  async _renameFiles(componentDir) {
+    const {
+      argv
+    } = this.context;
+    //
+    const typeMiddleFix = argv.nameMeta.directory === 'page' ? 'Page' : '';
+    //
+    const replaces = [];
+    replaces.push([`Controller${typeMiddleFix}${argv.nameMeta.shortCapitalize}`, `Controller${typeMiddleFix}${argv.componentNameNewCapitalize}`]);
+    replaces.push([`Render${typeMiddleFix}${argv.nameMeta.shortCapitalize}`, `Render${typeMiddleFix}${argv.componentNameNewCapitalize}`]);
+    replaces.push([`Style${typeMiddleFix}${argv.nameMeta.shortCapitalize}`, `Style${typeMiddleFix}${argv.componentNameNewCapitalize}`]);
+    //
+    const files = globbySync('*', {
+      cwd: componentDir,
+      onlyFiles: true
+    });
+    for (const file of files) {
+      const fileName = path.join(componentDir, file);
+      let content = (await fse.readFile(fileName)).toString();
+      for (const replace of replaces) {
+        content = content.replaceAll(replace[0], replace[1]);
+      }
+      await fse.writeFile(fileName, content);
+    }
+  }
+}
+
+class CliToolsDeps extends BeanCliBase {
+  async execute() {
+    const {
+      argv
+    } = this.context;
+    // super
+    await super.execute();
+    const projectPath = argv.projectPath;
+    // const force = argv.force;
+    // 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);
+  }
+}
+
+async function generateBeanGenerals(globFiles, 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 { ${className} } from '${fileNameJSRelative}';`);
+    }
+    contentRecords.push(`'${beanFullName}': ${className};`);
+  }
+  if (contentRecords.length === 0) return '';
+  // combine
+  const content = `/** ${sceneName}: begin */
+${contentImports.join('\n')}
+import 'zova';
+declare module 'zova' {
+  export interface ${sceneMeta.beanGeneral ? 'IBeanRecordGeneral' : 'IBeanRecordLocal'} {
+    ${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.js';
+import { config } from '../config/config.js';
+/** 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.js';
+import { constants } from '../config/constants.js';
+/** constant: end */
+`;
+  return content;
+}
+async function generateLocale1(modulePath, moduleName) {
+  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}.js';`);
+    contentLocales.push(`  '${localeName}': ${className},`);
+  }
+  // combine
+  const content = `import type { TypeLocaleBase } from 'zova';
+import { useApp, useComputed } from 'zova';
+${contentImports.join('\n')}
+
+export const locales = {
+${contentLocales.join('\n')}
+};
+
+export function $useLocale<K extends keyof (typeof locales)[TypeLocaleBase]>(key: K, ...args: any[]) {
+  const app = useApp();
+  const str = \`${moduleName}::\${key}\`;
+  return useComputed(() => {
+    return app.meta.text(str, ...args);
+  });
+}
+`;
+  return content;
+}
+async function generateLocale2(contentLocales) {
+  if (!contentLocales) return '';
+  // combine
+  const content = `/** locale: begin */
+import { locales } from './locales.js';
+/** 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.js';
+import { errors } from '../config/errors.js';
+/** error: end */
+`;
+  return content;
+}
+
+async function generateIcons(moduleName, modulePath) {
+  const iconsSrc = path.join(modulePath, 'icons');
+  // groups
+  const groups = await _resolveGroups(iconsSrc);
+  for (const group of groups) {
+    group.iconNames = await _generateIconsGroup(modulePath, iconsSrc, moduleName, group.name);
+  }
+  if (groups.length === 0) return '';
+  // src/resource/icons.ts
+  const resourceIcons = await _generateFileResourceIcons(groups, moduleName);
+  const contentResourceIcons = `export interface IIconRecord {
+  ${resourceIcons.join('\n    ').trim()}
+}
+`;
+  // src/config/icons.ts
+  const configIcons = await _generateFileConfigIcons(groups);
+  // combine
+  const content = `/** icons: begin */
+${configIcons}
+import 'zova-module-a-icon';
+declare module 'zova-module-a-icon' {
+${contentResourceIcons}
+}
+/** icons: end */
+`;
+  // restComponent
+  await generateRestIcon(moduleName, modulePath, resourceIcons);
+  // ok
+  return content;
+}
+async function generateRestIcon(_moduleName, modulePath, resourceIcons) {
+  // icons
+  const contentResourceIcons = resourceIcons.join('\n');
+  const fileIcons = path.join(modulePath, 'rest/icons.txt');
+  await fse.outputFile(fileIcons, contentResourceIcons);
+}
+async function _generateFileConfigIcons(groups) {
+  const groupsFrontImport = [];
+  const groupsFrontExport = [];
+  for (const group of groups) {
+    groupsFrontImport.push(`import icon_${group.name} from './icons/groups/${group.name}.svg';`);
+    groupsFrontExport.push(`${group.name}: icon_${group.name},`);
+  }
+  const jsContent = `${groupsFrontImport.join('\n')}\n\nexport const icons = {\n  ${groupsFrontExport.join('\n  ')}\n};\n`;
+  return jsContent;
+}
+async function _generateFileResourceIcons(groups, moduleName) {
+  const groupsFrontExport = [];
+  for (const group of groups) {
+    for (const iconName of group.iconNames) {
+      const recordId = _getRecordId(moduleName, group.name, iconName);
+      groupsFrontExport.push(`'${recordId}': true;`);
+    }
+  }
+  return groupsFrontExport;
+}
+async function _resolveGroups(iconsSrc) {
+  const groupPaths = await globby('*', {
+    cwd: iconsSrc,
+    onlyDirectories: true
+  });
+  groupPaths.sort();
+  return groupPaths.map(item => {
+    return {
+      name: item,
+      iconNames: []
+    };
+  });
+}
+async function _generateIconsGroup(modulePath, iconsSrc, moduleName, groupName) {
+  // icons
+  const files = await globby(`${groupName}/*.svg`, {
+    cwd: iconsSrc
+  });
+  files.sort();
+  const iconNames = files.map(item => path.basename(item, '.svg'));
+  // symbols
+  const symbols = [];
+  for (let index = 0; index < files.length; index++) {
+    const file = path.join(iconsSrc, files[index]);
+    const iconName = iconNames[index];
+    const symbol = await _combineSymbol(file, moduleName, groupName, iconName);
+    symbols.push(symbol);
+  }
+  // xml
+  const xml = `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+${symbols.join('\n')}
+</svg>`;
+  // write
+  const pathDest = path.join(modulePath, 'src/.metadata/icons', 'groups');
+  await fse.ensureDir(pathDest);
+  const fileDest = path.join(pathDest, `${groupName}.svg`);
+  await fse.writeFile(fileDest, xml);
+  // ok
+  return iconNames;
+}
+async function _combineSymbol(file, moduleName, groupName, iconName) {
+  // load
+  let content = (await fse.readFile(file)).toString();
+  // optimize
+  const {
+    data
+  } = await optimize(content, {});
+  content = data || content;
+  content = content.replace(/<svg(.*?)>/, (_, $1) => {
+    const $2 = $1.replace(/ width=".*?"/, '').replace(/ height=".*?"/, '');
+    return `<symbol id="${_getSymbolId(moduleName, groupName, iconName)}"${$2}>`;
+  }).replace('</svg>', '</symbol>');
+  return content;
+}
+function _getSymbolId(moduleName, groupName, iconName) {
+  return `zova-svg-icon-${moduleName}-${groupName}-${iconName}`;
+}
+function _getRecordId(moduleName, groupName, iconName) {
+  if (moduleName === 'home-icon') moduleName = '';
+  if (groupName === 'default') groupName = '';
+  return `${moduleName}:${groupName}:${iconName}`;
+}
+
+// import SVGCompiler from 'svg-baker';
+// const svgSymbol = await new SVGCompiler().addSymbol({
+//   id: _getSymbolId(moduleName, groupName, iconName),
+//   content,
+//   path: file,
+// });
+// content = svgSymbol.render();
+
+async function generateMetadataCustom(cli, globFiles, sceneName, sceneMeta, moduleName, modulePath) {
+  const sceneNameCapitalize = toUpperCaseFirstChar(sceneName);
+  if (globFiles.length === 0) return '';
+  // custom
+  let jsFile = path.join(sceneMeta.module.root, 'dist-cli', sceneMeta.metadataCustom.replace('.ts', '.js'));
+  if (!fse.existsSync(jsFile)) {
+    jsFile = path.join(sceneMeta.module.root, 'cli', 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) {
+  return generateMonkey_common(modulePath, 'monkey');
+}
+async function generateMonkeySys(modulePath) {
+  return generateMonkey_common(modulePath, 'monkeySys');
+}
+async function generateMain(modulePath) {
+  return generateMain_common(modulePath, 'main');
+}
+async function generateMainSys(modulePath) {
+  return generateMain_common(modulePath, 'mainSys');
+}
+async function generateMonkey_common(modulePath, commandName) {
+  const monkeyFile = path.join(modulePath, `src/${commandName}.ts`);
+  if (!fse.existsSync(monkeyFile)) return '';
+  // combine
+  const content = `/** ${commandName}: begin */
+export * from '../${commandName}.js';
+/** ${commandName}: end */
+`;
+  return content;
+}
+async function generateMain_common(modulePath, commandName) {
+  const monkeyFile = path.join(modulePath, `src/${commandName}.ts`);
+  if (!fse.existsSync(monkeyFile)) return '';
+  // combine
+  const content = `/** ${commandName}: begin */
+export * from '../${commandName}.js';
+/** ${commandName}: end */
+`;
+  return content;
+}
+
+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 globAllTsFiles(moduleName, modulePath) {
+  const result = [];
+  const files = await globby('src/**/*.ts(x)?', {
+    cwd: modulePath
+  });
+  if (files.length === 0) return result;
+  files.sort();
+  const pathMetadata = path.join(modulePath, 'src/.metadata');
+  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);
+    const isIgnore = checkIgnoreOfParts(parts);
+    const fileNameJS = fileName.replace('.ts', '.js').replace('.tsx', '.jsx');
+    const fileNameJSRelative = path.relative(pathMetadata, filePath).replace(/\\/g, '/').replace('.ts', '.js').replace('.tsx', '.jsx');
+    const fileContent = fse.readFileSync(filePath).toString();
+    const isVirtual = fileContent.includes('@Virtual()');
+    const isPreload = fileContent.includes('@Preload()');
+    const matches = fileContent.replace('@ProxyDisable()', '').match(/\s@([^\s<]+)\S*?\([\s\S]*?\)\sexport class ([^ \n<]+)/);
+    if (!matches) continue;
+    const className = matches[2];
+    const sceneNameCapitalize = isVirtual ? matches[1] === 'Virtual' ? 'Bean' : matches[1] : matches[1];
+    const sceneName = toLowerCaseFirstChar(sceneNameCapitalize);
+    const beanName = parseBeanName(className, sceneName);
+    const beanNameFull = `${moduleName}:${beanName}`;
+    const beanNameCapitalize = toUpperCaseFirstChar(beanName);
+    const beanFullName = `${moduleName}.${sceneName}.${beanName}`;
+    result.push({
+      sceneName,
+      sceneNameCapitalize,
+      file: filePath,
+      fileContent,
+      fileName,
+      fileNameJS,
+      fileNameJSRelative,
+      className,
+      beanName,
+      beanNameFull,
+      beanNameCapitalize,
+      beanFullName,
+      isIgnore,
+      isVirtual,
+      isPreload
+    });
+  }
+  return result;
+}
+function parseBeanName(className, scene) {
+  return skipPrefix(className, scene, true);
+}
+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 {[\\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
+  };
+}
+function beanFullNameFromOnionName(onionName, sceneName) {
+  return onionName.replace(':', `.${sceneName}.`);
+}
+
+async function generateOnions(globFiles, sceneName, sceneMeta, moduleName, _modulePath) {
+  const scopeModuleName = getScopeModuleName(moduleName);
+  const sceneNameCapitalize = toUpperCaseFirstChar(sceneName);
+  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,
+      className,
+      beanNameFull,
+      isIgnore,
+      isVirtual
+    } = globFile;
+    // const beanFullName = `${moduleName}.${sceneName}.${beanName}`;
+    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 { ${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 (!['__nothing__'].includes(sceneName) && !isVirtual) {
+      contentScopes.push(`
+        export interface ${className} {
+          /** @internal */
+          get scope(): ${scopeModuleName};
+        }`);
+      // cannot set these types, because controller/render/style extends each other
+      if (!['controller', 'render', 'style'].includes(sceneName)) {
+        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 { ${sceneMeta.optionsGlobalInterfaceName} } from '${sceneMeta.optionsGlobalInterfaceFrom || 'zova'}';` : `import '${sceneMeta.optionsGlobalInterfaceFrom || 'zova'}';`}
+declare module '${sceneMeta.optionsGlobalInterfaceFrom || 'zova'}' {
+  ${contentRecordsGlobal.length > 0 ? exportRecordsMiddlewareGlobal : ''}
+  ${contentRecordsLocal.length > 0 ? exportRecordsMiddlewareLocal : ''}
+}
+declare module 'zova-module-${moduleName}' {
+  ${contentScopes.join('\n')} 
+}
+/** ${sceneName}: end */
+`;
+  return content;
+}
+
+async function generateOptionsPackage(cli, globFiles, onionScenesMeta, _moduleName, modulePath) {
+  let changed = false;
+  const cacheNodeMap = {};
+  const pkgFile = path.join(modulePath, 'package.json');
+  const pkg = await cli.helper.loadJSONFile(pkgFile);
+  const nodeOnionsConfig = getPropertyObject(pkg, 'zovaModule.onionsConfig');
+  function getCacheNodeScene(sceneName) {
+    if (!cacheNodeMap[sceneName]) {
+      cacheNodeMap[sceneName] = nodeOnionsConfig[sceneName] = {};
+    }
+    return cacheNodeMap[sceneName];
+  }
+  for (const {
+    sceneName,
+    sceneNameCapitalize,
+    beanName,
+    beanNameFull,
+    fileContent
+  } of globFiles) {
+    const sceneMeta = onionScenesMeta[sceneName];
+    if (!sceneMeta) throw new Error(`sceneMeta not exists: ${sceneName}`);
+    if (!sceneMeta.optionsPackage) continue;
+    changed = true;
+    const matches = fileContent.match(new RegExp(`@${sceneNameCapitalize}[\\S]*?\\(([\\s\\S]*?)\\)\\s*?export class`));
+    if (!matches) throw new Error(`${sceneName} options parser error: ${beanNameFull}`);
+    const onionOptionsStr = matches[1];
+    const onionOptions = onionOptionsStr ? evaluateSimple(matches[1]) : {};
+    const nodeScene = getCacheNodeScene(sceneName);
+    nodeScene[beanName] = {};
+    for (const key of ['enable', 'meta', 'dependencies', 'dependents', 'type']) {
+      if (onionOptions[key] !== undefined) nodeScene[beanName][key] = onionOptions[key];
+    }
+    for (const key of ['match', 'ignore']) {
+      if (onionOptions[key] !== undefined) {
+        let value = onionOptions[key];
+        if (Array.isArray(value)) {
+          value = value.map(item => __prepareMatchRule(item));
+        } else {
+          value = __prepareMatchRule(value);
+        }
+        nodeScene[beanName][key] = value;
+      }
+    }
+  }
+  if (changed) {
+    await cli.helper.saveJSONFile(pkgFile, pkg);
+  }
+  // ok
+  return '';
+}
+function __prepareMatchRule(rule) {
+  if (rule instanceof RegExp) {
+    return StringPrefixRegexp + rule.toString();
+  }
+  return String(rule);
+}
+
+async function generateScope(moduleName, relativeNameCapitalize, scopeResources, options) {
+  const contentImports = [];
+  const contentRecords = [];
+  // basic
+  contentImports.push('BeanScopeBase');
+  // util
+  contentImports.push('type BeanScopeUtil');
+  contentRecords.push('util: BeanScopeUtil;');
+  //
+  if (options.config) {
+    contentImports.push('TypeModuleConfig');
+    contentRecords.push('config: TypeModuleConfig<typeof config>;');
+  }
+  if (options.errors) {
+    contentImports.push('TypeModuleErrors');
+    contentRecords.push('error: TypeModuleErrors<typeof errors>;');
+  }
+  if (options.locales) {
+    contentImports.push('TypeModuleLocales');
+    contentImports.push('TypeLocaleBase');
+    contentRecords.push('locale: TypeModuleLocales<(typeof locales)[TypeLocaleBase]>;');
+  }
+  if (options.constants) {
+    contentImports.push('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 'zova';
+import { Scope } from '${moduleName === 'a-bean' ? '../lib/scope.js' : 'zova-module-a-bean'}';
+
+@Scope()
+export class ScopeModule${relativeNameCapitalize} extends BeanScopeBase {}
+
+export interface ScopeModule${relativeNameCapitalize} {
+  ${contentRecords.join('\n')}
+}
+
+import 'zova';
+declare module 'zova' {
+  export interface IBeanScopeRecord {
+    '${moduleName}': 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(globFiles, sceneName, _sceneMeta, _moduleName, _modulePath) {
+  const sceneNameCapitalize = toUpperCaseFirstChar(sceneName);
+  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 { ${className} } from '${fileNameJSRelative}';`);
+    contentRecords.push(`'${beanName}': ${className};`);
+  }
+  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(globFiles, metaName, _metaMeta, _sceneName, _sceneMeta, _moduleName, _modulePath) {
+  if (globFiles.length === 0) return '';
+  // combine
+  const content = `/** meta ${metaName}: begin */
+import { Meta${toUpperCaseFirstChar(metaName)} } from '../bean/meta.${metaName}.js';
+/** 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 = '';
+    // all files
+    const globFiles = await globAllTsFiles(moduleName, modulePath);
+    const beansPreload = globFiles.filter(item => item.isPreload).map(item => item.beanFullName);
+    // onions
+    const scopeResources = {};
+    for (const sceneName in onionScenesMeta) {
+      const sceneMeta = onionScenesMeta[sceneName];
+      const globFilesScene = globFiles.filter(item => item.sceneName === sceneName);
+      // general
+      content += await generateOnions(globFilesScene, sceneName, sceneMeta, moduleName);
+      // scope resources
+      if (sceneMeta.scopeResource) {
+        const contentScopeResource = await generateScopeResources(globFilesScene, sceneName);
+        if (contentScopeResource) {
+          content += contentScopeResource;
+          scopeResources[sceneName] = `IModule${toUpperCaseFirstChar(sceneName)}`;
+        }
+      }
+      // bean generals
+      content += await generateBeanGenerals(globFilesScene, sceneName, sceneMeta, moduleName);
+      // metas
+      if (sceneName === 'meta') {
+        const onionMetasMeta = getOnionMetasMeta(this.modulesMeta.modules);
+        for (const metaName in onionMetasMeta) {
+          const metaMeta = onionMetasMeta[metaName];
+          const globFilesMeta = globFiles.filter(item => item.sceneName === 'meta' && item.beanName === metaName);
+          if (metaMeta.scopeResource) {
+            const contentScopeResourceMeta = await generateScopeResourcesMeta(globFilesMeta, metaName);
+            if (contentScopeResourceMeta) {
+              content += contentScopeResourceMeta;
+              scopeResources[metaName] = `Meta${toUpperCaseFirstChar(metaName)}`;
+            }
+          }
+        }
+      }
+      // metadata custom
+      if (sceneMeta.metadataCustom) {
+        content += await generateMetadataCustom(this, globFilesScene, sceneName, sceneMeta, moduleName, modulePath);
+      }
+    }
+    // onions: optionsPackage
+    content += await generateOptionsPackage(this, globFiles, onionScenesMeta, moduleName, modulePath);
+    // icons
+    content += await generateIcons(moduleName, modulePath);
+    // config
+    const contentConfig = await generateConfig(modulePath);
+    content += contentConfig;
+    // constant
+    const contentConstants = await generateConstant(modulePath);
+    content += contentConstants;
+    // locale
+    const contentLocales1 = await generateLocale1(modulePath, moduleName);
+    const contentLocales2 = await generateLocale2(contentLocales1);
+    content += contentLocales2;
+    // error
+    const contentErrors = await generateError(modulePath);
+    content += contentErrors;
+    // monkey/monkeySys
+    content += await generateMonkey(modulePath);
+    content += await generateMonkeySys(modulePath);
+    // main/mainSys
+    content += await generateMain(modulePath);
+    content += await generateMainSys(modulePath);
+    // scope
+    content += await generateScope(moduleName, relativeNameCapitalize, scopeResources, {
+      config: contentConfig,
+      errors: contentErrors,
+      locales: contentLocales2,
+      constants: contentConstants
+    });
+    // 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: ' });
+    // locales
+    await this._generateLocales(modulePath, contentLocales1);
+    // generate this
+    await this._generateThis(moduleName, relativeNameCapitalize, modulePath);
+    // index
+    await this._generateIndex(modulePath);
+    // package
+    await this._generatePackage(modulePath, beansPreload);
+  }
+  async _generateLocales(modulePath, contentLocales) {
+    if (!contentLocales) return;
+    const localesDest = path.join(modulePath, 'src/.metadata/locales.ts');
+    // save
+    await fse.writeFile(localesDest, contentLocales);
+  }
+  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.js';
+`;
+    // 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.js';";
+    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.js';";
+    const jsLibFile = path.join(modulePath, 'src/lib/index.ts');
+    if (fse.existsSync(jsLibFile) && !jsContent.includes(jsLib)) {
+      jsContent = `${jsLib}\n${jsContent}`;
+    }
+    // jsLocales
+    const jsLocales = "export * from './.metadata/locales.js';";
+    const jsLocalesFile = path.join(modulePath, 'src/.metadata/locales.ts');
+    if (fse.existsSync(jsLocalesFile) && !jsContent.includes(jsLocales)) {
+      jsContent = `${jsLocales}\n${jsContent}`;
+    }
+    // jsMetadata
+    const jsMetadata = "export * from './.metadata/index.js';";
+    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, beansPreload) {
+    let pkgFile;
+    let pkg;
+    let changed;
+    async function _loadPkg() {
+      if (!pkg) {
+        pkgFile = path.join(modulePath, 'package.json');
+        pkg = await loadJSONFile(pkgFile);
+      }
+      return pkg;
+    }
+    // beansPreload
+    if (beansPreload.length > 0) {
+      pkg = await _loadPkg();
+      if (!pkg.zovaModule) pkg.zovaModule = {};
+      if (!pkg.zovaModule.beansPreload || pkg.zovaModule.beansPreload.join(',') !== beansPreload.join(',')) {
+        changed = true;
+        pkg.zovaModule.beansPreload = beansPreload;
+      }
+    }
+    // cli/rest
+    for (const name of ['cli', 'icons', 'rest']) {
+      const cli = path.join(modulePath, name);
+      if (fse.existsSync(cli)) {
+        pkg = await _loadPkg();
+        const index = pkg.files.indexOf(name);
+        if (index === -1) {
+          changed = true;
+          pkg.files.push(name);
+        }
+        if (name === 'cli') {
+          if (pkg.scripts?.['tsc:publish'].includes('tsconfig.cli.json')) {
+            const index = pkg.files.indexOf('dist-cli');
+            if (index === -1) {
+              changed = true;
+              pkg.files.push('dist-cli');
+            }
+          }
+        }
+      }
+    }
+    // save
+    if (changed) {
+      await saveJSONFile(pkgFile, pkg);
+      await this.helper.formatFile({
+        fileName: pkgFile
+      });
+    }
+  }
+}
+
+const beans = {
+  'default.list': CliDefaultList,
+  'bin.buildModule': CliBinBuildModule,
+  'bin.buildRest': CliBinBuildRest,
+  'create.project': CliCreateProject,
+  'create.suite': CliCreateSuite,
+  'create.module': CliCreateModule,
+  'create.page': CliCreatePage,
+  'create.component': CliCreateComponent,
+  'create.mock': CliCreateMock,
+  'create.bean': CliCreateBean,
+  'init.icon': CliInitIcon,
+  'init.config': CliInitConfig,
+  'init.constant': CliInitConstant,
+  'init.locale': CliInitLocale,
+  'init.error': CliInitError,
+  'init.legacy': CliInitLegacy,
+  'init.appMonkey': CliInitAppMonkey,
+  'init.sysMonkey': CliInitSysMonkey,
+  'init.monkey': CliInitMonkey,
+  'init.monkeySys': CliInitMonkeySys,
+  'init.main': CliInitMain,
+  'init.mainSys': CliInitMainSys,
+  'init.asset': CliInitAsset,
+  'init.lib': CliInitLib,
+  'init.types': CliInitTypes,
+  'refactor.pageQuery': CliRefactorPageQuery,
+  'refactor.pageParams': CliRefactorPageParams,
+  'refactor.componentGeneric': CliRefactorComponentGeneric,
+  'refactor.firstRender': CliRefactorFirstRender,
+  'refactor.firstStyle': CliRefactorFirstStyle,
+  'refactor.anotherRender': CliRefactorAnotherRender,
+  'refactor.anotherStyle': CliRefactorAnotherStyle,
+  'refactor.componentProps': CliRefactorComponentProps,
+  'refactor.componentEmits': CliRefactorComponentEmits,
+  'refactor.componentSlots': CliRefactorComponentSlots,
+  'refactor.componentModel': CliRefactorComponentModel,
+  'refactor.renameComponent': CliRefactorRenameComponent,
+  'tools.metadata': CliToolsMetadata,
+  'tools.deps': CliToolsDeps,
+  'openapi.config': CliOpenapiConfig,
+  'openapi.generate': CliOpenapiGenerate
+};
+
+var binBuildModule = {
+  bean: 'bin.buildModule',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Tools: Bin',
+    usage: 'zova :bin:buildModule [--minify] [--sourcemap] [--dts]'
+  },
+  options: {
+    minify: {
+      description: 'minify',
+      type: 'boolean'
+    },
+    sourcemap: {
+      description: 'sourcemap',
+      type: 'boolean'
+    },
+    dts: {
+      description: 'dts',
+      type: 'boolean'
+    }
+  }
+};
+
+var binBuildRest = {
+  bean: 'bin.buildRest',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Tools: Bin',
+    usage: 'zova :bin:buildRest [--flavor=]'
+  },
+  options: {
+    flavor: {
+      description: 'flavor',
+      type: 'string'
+    }
+  }
+};
+
+var createBean = {
+  bean: 'create.bean',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Create Bean',
+    usage: 'zova :create:bean sceneName beanName [--module=]'
+  },
+  options: {
+    module: {
+      description: 'module name',
+      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 createComponent = {
+  bean: 'create.component',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Create Component',
+    usage: 'zova :create:component componentName [--module=] [--boilerplate=]'
+  },
+  options: {
+    module: {
+      description: 'module name',
+      type: 'string'
+    },
+    boilerplate: {
+      description: 'boilerplate',
+      type: 'string'
+    }
+  },
+  groups: {
+    default: {
+      questions: {
+        componentName: {
+          type: 'input',
+          message: 'componentName',
+          initial: {
+            expression: 'context.argv._[0]'
+          },
+          required: true
+        },
+        module: {
+          type: 'input',
+          message: 'module name',
+          required: true
+        }
+      }
+    }
+  }
+};
+
+var createMock = {
+  bean: 'create.mock',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Create Mock',
+    usage: 'zova :create:mock mockName [--module=]'
+  },
+  options: {
+    module: {
+      description: 'module name',
+      type: 'string'
+    }
+  },
+  groups: {
+    default: {
+      questions: {
+        mockName: {
+          type: 'input',
+          message: 'mockName',
+          initial: {
+            expression: 'context.argv._[0]'
+          },
+          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: 'zova :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 createPage = {
+  bean: 'create.page',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Create Page TSX Component',
+    usage: 'zova :create:page pageName [--module=]'
+  },
+  options: {
+    module: {
+      description: 'module name',
+      type: 'string'
+    }
+  },
+  groups: {
+    default: {
+      questions: {
+        pageName: {
+          type: 'input',
+          message: 'pageName',
+          initial: {
+            expression: 'context.argv._[0]'
+          },
+          required: true
+        },
+        module: {
+          type: 'input',
+          message: 'module name',
+          required: true
+        }
+      }
+    }
+  }
+};
+
+var createProject = {
+  bean: 'create.project',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Create Project',
+    usage: 'zova :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: 'quasar',
+            message: 'zova + quasar'
+          }, {
+            name: 'vuetify',
+            message: 'zova + vuetify'
+          }, {
+            name: 'empty',
+            message: 'zova only'
+          }]
+        }
+      }
+    },
+    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: 'zova :create:suite suiteName'
+  },
+  options: {},
+  groups: {
+    suiteInfo: {
+      questions: {
+        name: {
+          type: 'input',
+          message: 'suite name',
+          initial: {
+            expression: 'context.argv._[0]'
+          },
+          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: 'zova :init:appMonkey'
+  }
+  // options: null,
+  // groups: null,
+};
+
+var initAsset = {
+  bean: 'init.asset',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Init: Asset Resources',
+    usage: 'zova :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: 'zova :init:config module'
+  }
+  // options: null,
+  // groups: null,
+};
+
+var initConstant = {
+  bean: 'init.constant',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Init: Constant',
+    usage: 'zova :init:constant module'
+  }
+  // options: null,
+  // groups: null,
+};
+
+var initError = {
+  bean: 'init.error',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Init: Error',
+    usage: 'zova :init:error module'
+  }
+  // options: null,
+  // groups: null,
+};
+
+var initIcon = {
+  bean: 'init.icon',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Init: Icon',
+    usage: 'zova :init:icon module'
+  }
+  // options: null,
+  // groups: null,
+};
+
+var initLegacy = {
+  bean: 'init.legacy',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Init: Legacy',
+    usage: 'zova :init:legacy'
+  }
+  // options: null,
+  // groups: null,
+};
+
+var initLib = {
+  bean: 'init.lib',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Init: Lib',
+    usage: 'zova :init:lib module'
+  }
+  // options: null,
+  // groups: null,
+};
+
+var initLocale = {
+  bean: 'init.locale',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Init: Locale',
+    usage: 'zova :init:locale module'
+  }
+  // options: null,
+  // groups: null,
+};
+
+var initMain = {
+  bean: 'init.main',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Init: Main',
+    usage: 'zova :init:main module'
+  }
+  // options: null,
+  // groups: null,
+};
+
+var initMainSys = {
+  bean: 'init.mainSys',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Init: Main Sys',
+    usage: 'zova :init:mainSys module'
+  }
+  // options: null,
+  // groups: null,
+};
+
+var initMonkey = {
+  bean: 'init.monkey',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Init: Monkey',
+    usage: 'zova :init:monkey module'
+  }
+  // options: null,
+  // groups: null,
+};
+
+var initMonkeySys = {
+  bean: 'init.monkeySys',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Init: Monkey Sys',
+    usage: 'zova :init:monkeySys module'
+  }
+  // options: null,
+  // groups: null,
+};
+
+var initSysMonkey = {
+  bean: 'init.sysMonkey',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Init: Sys Monkey',
+    usage: 'zova :init:sysMonkey'
+  }
+  // options: null,
+  // groups: null,
+};
+
+var initTypes = {
+  bean: 'init.types',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Init: Types',
+    usage: 'zova :init:types module'
+  }
+  // options: null,
+  // groups: null,
+};
+
+var openapiConfig = {
+  bean: 'openapi.config',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Openapi: Config',
+    usage: 'zova :openapi:config module1 [module2]'
+  }
+  // options: null,
+  // groups: null,
+};
+
+var openapiGenerate = {
+  bean: 'openapi.generate',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Openapi: Generate',
+    usage: 'zova :openapi:generate module1 [module2]'
+  }
+  // options: null,
+  // groups: null,
+};
+
+var refactorAnotherRender = {
+  bean: 'refactor.anotherRender',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Refactor: Another Render',
+    usage: 'zova :refactor:anotherRender componentName renderName [--module=]'
+  },
+  options: {
+    module: {
+      description: 'module name',
+      type: 'string'
+    }
+  },
+  groups: {
+    default: {
+      questions: {
+        componentName: {
+          type: 'input',
+          message: 'componentName',
+          initial: {
+            expression: 'context.argv._[0]'
+          },
+          required: true
+        },
+        renderName: {
+          type: 'input',
+          message: 'renderName',
+          initial: {
+            expression: 'context.argv._[1]'
+          },
+          required: true
+        },
+        module: {
+          type: 'input',
+          message: 'module name',
+          required: true
+        }
+      }
+    }
+  }
+};
+
+var refactorAnotherStyle = {
+  bean: 'refactor.anotherStyle',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Refactor: Another Style',
+    usage: 'zova :refactor:anotherStyle componentName styleName [--module=]'
+  },
+  options: {
+    module: {
+      description: 'module name',
+      type: 'string'
+    }
+  },
+  groups: {
+    default: {
+      questions: {
+        componentName: {
+          type: 'input',
+          message: 'componentName',
+          initial: {
+            expression: 'context.argv._[0]'
+          },
+          required: true
+        },
+        styleName: {
+          type: 'input',
+          message: 'styleName',
+          initial: {
+            expression: 'context.argv._[1]'
+          },
+          required: true
+        },
+        module: {
+          type: 'input',
+          message: 'module name',
+          required: true
+        }
+      }
+    }
+  }
+};
+
+var refactorComponentGeneric = {
+  bean: 'refactor.componentGeneric',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Refactor: ComponentGeneric',
+    usage: 'zova :refactor:componentGeneric componentName [--module=]'
+  },
+  options: {
+    module: {
+      description: 'module name',
+      type: 'string'
+    }
+  },
+  groups: {
+    default: {
+      questions: {
+        componentName: {
+          type: 'input',
+          message: 'componentName',
+          initial: {
+            expression: 'context.argv._[0]'
+          },
+          required: true
+        },
+        module: {
+          type: 'input',
+          message: 'module name',
+          required: true
+        }
+      }
+    }
+  }
+};
+
+var refactorComponentModel = {
+  bean: 'refactor.componentModel',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Refactor: ComponentModel',
+    usage: 'zova :refactor:componentModel componentName modelName [--module=]'
+  },
+  options: {
+    module: {
+      description: 'module name',
+      type: 'string'
+    }
+  },
+  groups: {
+    default: {
+      questions: {
+        componentName: {
+          type: 'input',
+          message: 'componentName',
+          initial: {
+            expression: 'context.argv._[0]'
+          },
+          required: true
+        },
+        modelName: {
+          type: 'input',
+          message: 'modelName',
+          initial: {
+            expression: 'context.argv._[1]'
+          },
+          required: true
+        },
+        module: {
+          type: 'input',
+          message: 'module name',
+          required: true
+        }
+      }
+    }
+  }
+};
+
+var refactorComponentProps = {
+  bean: 'refactor.componentProps',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Refactor: ComponentProps',
+    usage: 'zova :refactor:componentProps componentName [--module=]'
+  },
+  options: {
+    module: {
+      description: 'module name',
+      type: 'string'
+    }
+  },
+  groups: {
+    default: {
+      questions: {
+        componentName: {
+          type: 'input',
+          message: 'componentName',
+          initial: {
+            expression: 'context.argv._[0]'
+          },
+          required: true
+        },
+        module: {
+          type: 'input',
+          message: 'module name',
+          required: true
+        }
+      }
+    }
+  }
+};
+
+var refactorFirstRender = {
+  bean: 'refactor.firstRender',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Refactor: First Render',
+    usage: 'zova :refactor:firstRender componentName [--module=]'
+  },
+  options: {
+    module: {
+      description: 'module name',
+      type: 'string'
+    }
+  },
+  groups: {
+    default: {
+      questions: {
+        componentName: {
+          type: 'input',
+          message: 'componentName',
+          initial: {
+            expression: 'context.argv._[0]'
+          },
+          required: true
+        },
+        module: {
+          type: 'input',
+          message: 'module name',
+          required: true
+        }
+      }
+    }
+  }
+};
+
+var refactorFirstStyle = {
+  bean: 'refactor.firstStyle',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Refactor: First Style',
+    usage: 'zova :refactor:firstStyle componentName [--module=]'
+  },
+  options: {
+    module: {
+      description: 'module name',
+      type: 'string'
+    }
+  },
+  groups: {
+    default: {
+      questions: {
+        componentName: {
+          type: 'input',
+          message: 'componentName',
+          initial: {
+            expression: 'context.argv._[0]'
+          },
+          required: true
+        },
+        module: {
+          type: 'input',
+          message: 'module name',
+          required: true
+        }
+      }
+    }
+  }
+};
+
+var refactorPageParams = {
+  bean: 'refactor.pageParams',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Refactor: PageParams',
+    usage: 'zova :refactor:pageParams pageName [--module=]'
+  },
+  options: {
+    module: {
+      description: 'module name',
+      type: 'string'
+    }
+  },
+  groups: {
+    default: {
+      questions: {
+        pageName: {
+          type: 'input',
+          message: 'pageName',
+          initial: {
+            expression: 'context.argv._[0]'
+          },
+          required: true
+        },
+        module: {
+          type: 'input',
+          message: 'module name',
+          required: true
+        }
+      }
+    }
+  }
+};
+
+var refactorPageQuery = {
+  bean: 'refactor.pageQuery',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Refactor: PageQuery',
+    usage: 'zova :refactor:pageQuery pageName [--module=]'
+  },
+  options: {
+    module: {
+      description: 'module name',
+      type: 'string'
+    }
+  },
+  groups: {
+    default: {
+      questions: {
+        pageName: {
+          type: 'input',
+          message: 'pageName',
+          initial: {
+            expression: 'context.argv._[0]'
+          },
+          required: true
+        },
+        module: {
+          type: 'input',
+          message: 'module name',
+          required: true
+        }
+      }
+    }
+  }
+};
+
+var refactorRenameComponent = {
+  bean: 'refactor.renameComponent',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Refactor: Rename Component',
+    usage: 'zova :refactor:renameComponent componentName componentNameNew [--module=]'
+  },
+  options: {
+    module: {
+      description: 'module name',
+      type: 'string'
+    }
+  },
+  groups: {
+    default: {
+      questions: {
+        componentName: {
+          type: 'input',
+          message: 'componentName',
+          initial: {
+            expression: 'context.argv._[0]'
+          },
+          required: true
+        },
+        componentNameNew: {
+          type: 'input',
+          message: 'componentNameNew',
+          initial: {
+            expression: 'context.argv._[1]'
+          },
+          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: 'zova :tools:deps [--force]'
+  },
+  options: {
+    force: {
+      description: 'force',
+      type: 'boolean'
+    }
+  }
+};
+
+var toolsMetadata = {
+  bean: 'tools.metadata',
+  info: {
+    version: '5.0.0',
+    title: 'Cli: Tools: Metadata',
+    usage: 'zova :tools:metadata module1 [module2] [--force]'
+  },
+  options: {
+    force: {
+      description: 'force',
+      type: 'boolean'
+    }
+  }
+};
+
+const commands = {
+  default: {
+    list: defaultList
+  },
+  bin: {
+    buildModule: binBuildModule,
+    buildRest: binBuildRest
+  },
+  create: {
+    project: createProject,
+    suite: createSuite,
+    module: createModule,
+    page: createPage,
+    component: createComponent,
+    mock: createMock,
+    bean: createBean
+  },
+  init: {
+    icon: initIcon,
+    config: initConfig,
+    constant: initConstant,
+    locale: initLocale,
+    error: initError,
+    legacy: initLegacy,
+    appMonkey: initAppMonkey,
+    sysMonkey: initSysMonkey,
+    monkey: initMonkey,
+    monkeySys: initMonkeySys,
+    main: initMain,
+    mainSys: initMainSys,
+    asset: initAsset,
+    lib: initLib,
+    types: initTypes
+  },
+  refactor: {
+    pageQuery: refactorPageQuery,
+    pageParams: refactorPageParams,
+    componentGeneric: refactorComponentGeneric,
+    firstRender: refactorFirstRender,
+    firstStyle: refactorFirstStyle,
+    anotherRender: refactorAnotherRender,
+    anotherStyle: refactorAnotherStyle,
+    componentProps: refactorComponentProps,
+    // componentEmits: refactorComponentEmits,
+    // componentSlots: refactorComponentSlots,
+    componentModel: refactorComponentModel,
+    renameComponent: refactorRenameComponent
+  },
+  tools: {
+    // icon: toolsIcon,
+    metadata: toolsMetadata,
+    deps: toolsDeps
+  },
+  openapi: {
+    config: openapiConfig,
+    generate: openapiGenerate
+  }
+};
+
+export { beans, commands, getAbsolutePathOfModule };