@vectorx/xhs-cloud-cli 0.1.0

package/README.md

@@ -0,0 +1,34 @@
+# xhs cloud 命令行工具
+xhs-cloud-cli 主要用于如下场景：
+ - agent 调试、发布
+ - cloud 云函数的调试、部署
+
+使用方式：
+ - xhs-cloud-cli agent dev 
+
+ - xhs-cloud-cli cloud dev
+
+## 安装 CloudBase CLI
+
+src/
+├── commands/
+│   └── agent/
+│       └── dev.ts       # agent dev 命令实现
+├── core/
+│   └── server/
+│       ├── server.node.ts  # Koa 服务器实现
+│       └── function-loader.ts  # 函数加载器实现
+
+### npm
+
+```shell
+npm install -g @cloudbase/cli
+```
+
+## 命令
+> xhs-cloud-cli
+
+## 命令
+- deploy
+- dev
+

package/bin/rcb.js

@@ -0,0 +1,264 @@
+#!/usr/bin/env node
+const yargsParser = require("yargs-parser");
+const chalk = require("chalk");
+const { program } = require("commander");
+const logSymbols = require("log-symbols");
+const didYouMean = require("didyoumean");
+const updateNotifier = require("update-notifier");
+const { Confirm } = require("enquirer");
+const execa = require("execa");
+const semver = require("semver");
+const { registerCommands, ALL_COMMANDS } = require("../lib");
+
+const pkg = require("../package.json");
+
+async function main() {
+  let processArgv = process.argv;
+  const isBeta = pkg.version.indexOf("-") > -1;
+  process.CLI_VERSION = pkg.version;
+
+  const currentMajorVersion = +semver.major(process.version);
+
+  // 定义最小版本和推荐版本
+  const NODE_MIN_VERSION = 18;
+
+  // 检查当前版本是否满足最小版本要求
+  if (NODE_MIN_VERSION > currentMajorVersion) {
+    console.error(
+      chalk.bold.red(
+        `当前 Node.js 版本为 v${currentMajorVersion}。请升级到至少 v${NODE_MIN_VERSION} 版本。`
+      )
+    );
+    process.exit(1);
+  }
+
+  // 输出版本信息
+  console.log(chalk.gray(`RedCloudBase CLI ${pkg.version}`));
+  console.log(`[API Config] Env: ${process.env.AGENT_BUILD_ENV || 'production'}`);
+
+  const yargsParsedResult = yargsParser(process.argv.slice(2));
+
+  await registerCommands();
+
+  // 设置 options 选项
+  program.storeOptionsAsProperties(false);
+  program.option("-r, --region <region>", "指定环境地域");
+
+  const isCommandEmpty = yargsParsedResult._.length === 0;
+
+  // 处理无效命令
+  program.action(() => {
+    const args = program.args;
+    if (!Array.isArray(args) || !args.length) {
+      return;
+    }
+    const cmd = args.join(" ");
+    console.log(chalk.bold.red("Error: ") + `${cmd} 不是有效的命令`);
+    didYouMean.threshold = 0.5;
+    didYouMean.caseSensitive = false;
+    const suggest = didYouMean(cmd, ALL_COMMANDS);
+    if (suggest) {
+      console.log(chalk.bold(`\n您是不是想使用命令：rcb ${suggest}\n`));
+    }
+    console.log(`💡使用 ${chalk.bold("rcb -h")} 查看所有命令`);
+  });
+
+  // 没有使用命令
+  if (isCommandEmpty) {
+    program.outputHelp();
+    // 需要隐藏的选项
+    const hideArgs = ["-h", "--help"];
+    hideArgs.forEach((arg) => {
+      const index = processArgv.indexOf(arg);
+      if (index > -1) {
+        processArgv.splice(index, 1);
+      }
+    });
+    const { output } = require("../lib/output");
+    output.helpInfo();
+  }
+
+  try {
+    program.parse(processArgv);
+  } catch (e) {
+    const errMsg = `${logSymbols.error} ${
+      e.message || "参数异常，请检查您是否使用了正确的命令！"
+    }`;
+    console.log(errMsg);
+  }
+
+  /**
+   * 处理异常
+   */
+  async function errorHandler(err) {
+    process.emit("processExit");
+
+    // 3 空格，兼容中文字符编码长度问题
+    if (err && err.message) {
+      let errMsg = logSymbols.error + " " + err.message;
+      errMsg += err.requestId ? `\n${err.requestId}` : "";
+      console.log(errMsg);
+
+      // 多地域错误提示
+      if (errMsg.includes("Environment") && errMsg.includes("not found")) {
+        // 检查是否已经指定了 -r 或 --region 参数，如未指定则尝试获取地域信息
+        const regionSpecified =
+          processArgv.indexOf("-r") !== -1 ||
+          processArgv.indexOf("--region") !== -1;
+        const region = yargsParsedResult.r || yargsParsedResult.region;
+        const multiRegionErrMsg = `\n此环境可能不属于当前账号，或为非${
+          regionSupportedMap[region] || "上海"
+        }地域环境，如需切换地域请追加参数（例：-r gz），请检查环境归属，参考多地域使用方法：https://docs.cloudbase.net/cli-v1/region.html`;
+        if (!regionSpecified) {
+          // 从 -e 参数、--envId 参数和配置文件中获取环境 id
+          const envId =
+            yargsParsedResult.e || yargsParsedResult.envId || config.envId;
+
+          // 调用 API 接口尝试查询环境信息
+          const predictRegion = await tryTellEnvRegion(envId);
+
+          if (regionSupported.includes(predictRegion)) {
+            // 让用户选择是否切换地域
+            const prompt = new Confirm({
+              type: "confirm",
+              name: "confirm",
+              message: `该环境可能属于 ${regionSupportedMap[predictRegion]} 地域，是否切换地域并重新执行命令？`,
+              initial: "Y",
+            });
+            const confirm = await prompt.run();
+            if (confirm) {
+              // 检查原始命令是否已经追加了 -r 参数，如果有则替换，如果没有则追加
+              const regionArgIndex = processArgv.indexOf("-r");
+              if (regionArgIndex !== -1) {
+                processArgv[regionArgIndex + 1] = predictRegion;
+              } else {
+                processArgv.push("-r", predictRegion);
+              }
+              // 重新执行命令
+              const newArgvStr = processArgv.slice(2).join(" ");
+              console.log(
+                `\n${chalk.yellow.bold(
+                  "正在重新执行命令："
+                )} tcb ${newArgvStr}\n`
+              );
+              await execa("tcb", processArgv.slice(2), {
+                stdio: "inherit",
+              });
+              process.emit("tcbExit");
+              process.exit(0);
+            } else {
+              console.log(chalk.yellow.bold(multiRegionErrMsg));
+            }
+          }
+        } else {
+          console.log(chalk.yellow.bold(multiRegionErrMsg));
+        }
+      }
+    }
+
+    // 输出详细的错误信息
+    if (processArgv.includes("--verbose")) {
+      console.log(err);
+    }
+
+    process.emit("processError");
+    setTimeout(() => {
+      process.exit(1);
+    }, 1000);
+  }
+
+  const isTokenExpired = (credential, gap = 120) =>
+    credential.accessTokenExpired &&
+    Number(credential.accessTokenExpired) < Date.now() + gap * 1000;
+
+  async function tryTellEnvRegion(envId) {
+    // 依次调用不同地域的 API 接口查询环境信息
+    const fetchedRegion = await Promise.all(
+      regionSupported.map(async (region) => {
+        const { EnvList = [] } = await fetchEnvInfoWithRegion(envId, region);
+        if (
+          EnvList.length !== 0 &&
+          EnvList.find((item) => item.EnvId === envId)
+        ) {
+          return res.EnvList[0].Region;
+        }
+        return "";
+      })
+    );
+
+    let predictRegion = "";
+    fetchedRegion.forEach((region) => {
+      if (region) {
+        predictRegion = region;
+      }
+    });
+    return predictRegion;
+  }
+
+  // 在指定地域调用 API 接口查询环境信息
+  async function fetchEnvInfoWithRegion(envId, region) {
+    let commonCredential = {};
+    const commonOpts = {
+      service: "tcb",
+      version: "2019-09-24",
+      proxy: getProxy(),
+      timeout: 15000,
+      getCredential: async () => {
+        if (commonCredential.secretId && !isTokenExpired(commonCredential)) {
+          return commonCredential;
+        }
+        const credential = await getCredentialWithoutCheck();
+        if (!credential) {
+          throw new Error("无有效身份信息，请使用 cloudbase login 登录");
+        }
+        commonCredential = credential;
+        return {
+          ...credential,
+          tokenExpired: Number(credential.accessTokenExpired),
+        };
+      },
+    };
+    const apiName = "DescribeEnvs";
+    const tcbApi = new CloudApiService({
+      ...commonOpts,
+      region,
+    });
+    const res = await tcbApi.request(apiName, {
+      EnvId: envId,
+    });
+    return res;
+  }
+
+  process.on("uncaughtException", errorHandler);
+  process.on("unhandledRejection", errorHandler);
+
+  // 检查更新
+  const ONE_DAY = 86400000;
+  // Beta 版 1 个小时检查一次，稳定版 1 天检查一次
+  const CheckInterval = isBeta ? 3600000 : ONE_DAY;
+
+  const notifier = updateNotifier({
+    pkg,
+    distTag: isBeta ? "beta" : "latest",
+    // 检查更新间隔 1 天
+    updateCheckInterval: CheckInterval,
+  });
+
+  notifier.notify({
+    isGlobal: true,
+  });
+}
+
+if (require.main === module) {
+  try {
+    main();
+  } catch (error) {
+    console.log(error);
+  }
+}
+
+process.on("unhandledRejection", (err) => {
+  console.log("unhandledRejection", err);
+});
+
+exports.main = main;

package/lib/commands/agent/build.js

@@ -0,0 +1,222 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentDeployCommand = exports.AgentBuildCommand = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const cloud_toolkit_1 = require("@vectorx/cloud-toolkit");
+const chalk_1 = __importDefault(require("chalk"));
+const semver_1 = __importDefault(require("semver"));
+const base_1 = require("../../core/base");
+const decorators_1 = require("../../decorators");
+const auth_1 = require("../../decorators/auth");
+let AgentBuildCommand = class AgentBuildCommand extends base_1.Command {
+    execute(options, log) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const workDir = options.dir || process.cwd();
+            log.info(`工作目录: ${workDir}`);
+            try {
+                const buildSpinner = log.spinner("构建项目中...");
+                const { outputPath, size } = yield (0, cloud_toolkit_1.build)({
+                    workDir,
+                    outputDir: options.output ? path_1.default.resolve(options.output) : undefined,
+                    filename: options.filename,
+                    upload: options.upload,
+                });
+                buildSpinner.succeed(chalk_1.default.green(`构建完成: ${outputPath}`));
+                log.info(`文件大小: ${(size / 1024 / 1024).toFixed(2)} MB`);
+                if (options.upload) {
+                    log.info(chalk_1.default.green("✅ 部署完成"));
+                }
+            }
+            catch (error) {
+                log.error(`构建失败: ${error.message}`);
+                process.exit(1);
+            }
+        });
+    }
+    get options() {
+        return {
+            cmd: "agent",
+            childCmd: "build",
+            desc: "打包 agent 项目",
+            options: [
+                {
+                    flags: "-d, --dir <dir>",
+                    desc: "指定 agent 项目所在的目录，默认为当前目录",
+                },
+                {
+                    flags: "-o, --output <output>",
+                    desc: "指定构建输出目录，默认为项目目录下的 dist 文件夹",
+                },
+                {
+                    flags: "-n, --filename <filename>",
+                    desc: "指定输出文件名，默认为 agent.zip",
+                },
+                {
+                    flags: "-u, --upload",
+                    desc: "构建完成后自动部署到云端",
+                },
+            ],
+        };
+    }
+};
+exports.AgentBuildCommand = AgentBuildCommand;
+__decorate([
+    (0, decorators_1.InjectParams)(),
+    __param(0, (0, decorators_1.ArgsOptions)()),
+    __param(1, (0, decorators_1.Log)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Function]),
+    __metadata("design:returntype", Promise)
+], AgentBuildCommand.prototype, "execute", null);
+exports.AgentBuildCommand = AgentBuildCommand = __decorate([
+    (0, auth_1.AuthGuard)(),
+    (0, base_1.ICommand)()
+], AgentBuildCommand);
+let AgentDeployCommand = class AgentDeployCommand extends base_1.Command {
+    execute(options, log) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const targetPath = options.targetPath;
+            const projectConfig = (options === null || options === void 0 ? void 0 : options.projectConfig) || path_1.default.resolve(process.cwd(), "project.config.json");
+            if (!fs_1.default.existsSync(projectConfig)) {
+                log.error(`项目配置文件不存在: ${projectConfig}`);
+                log.breakLine();
+                process.exit(1);
+            }
+            if (!targetPath) {
+                log.error(`请指定部署文件路径`);
+                log.breakLine();
+                console.log(chalk_1.default.gray("💡 可能的解决方案:"));
+                console.log(chalk_1.default.gray("  • 请检查文件路径是否正确"));
+                console.log(chalk_1.default.gray("  • 请确保文件存在"));
+                console.log(chalk_1.default.gray("  • 使用示例 rcb agent deploy -t ./dist/agent.zip"));
+                log.breakLine();
+                process.exit(1);
+            }
+            if (!fs_1.default.existsSync(targetPath)) {
+                log.error(`文件不存在: ${targetPath}`);
+                log.breakLine();
+                console.log(chalk_1.default.gray("💡 可能的解决方案:"));
+                console.log(chalk_1.default.gray("  • 请检查文件路径是否正确"));
+                console.log(chalk_1.default.gray("  • 请确保文件存在"));
+                console.log(chalk_1.default.gray("  • 使用示例 rcb agent build -d ./ -o ./dist"));
+                log.breakLine();
+                process.exit(1);
+            }
+            try {
+                const projectInfo = JSON.parse(fs_1.default.readFileSync(projectConfig, "utf-8"));
+                if (!projectInfo.agentId || !projectInfo.version || !projectInfo.desc) {
+                    log.error(`项目配置文件中缺少必要字段: ${projectConfig}`);
+                    log.breakLine();
+                    process.exit(1);
+                }
+                if (!projectInfo.version || !projectInfo.agentId) {
+                    log.error(`项目配置文件中缺少必要字段: ${projectConfig}`);
+                    log.breakLine();
+                    process.exit(1);
+                }
+                if (!semver_1.default.valid(projectInfo.version)) {
+                    log.error(`项目配置文件中 version 字段不符合 semver 规范: ${projectConfig}`);
+                    log.breakLine();
+                    process.exit(1);
+                }
+                const uploadService = cloud_toolkit_1.container.get(cloud_toolkit_1.SERVICE_IDENTIFIERS.UploadService);
+                try {
+                    const buildPreCheckResult = yield uploadService.buildPreCheck({
+                        agent_id: projectInfo.agentId,
+                        version: projectInfo.version,
+                        desc: projectInfo.desc || `Agent 发布：${projectInfo.version}`,
+                    });
+                    if (!buildPreCheckResult.success) {
+                        log.error(`部署上传预检失败：${buildPreCheckResult.msg}`);
+                        log.breakLine();
+                        process.exit(1);
+                    }
+                }
+                catch (error) {
+                    log.error(`部署预检异常 ${error.message}`);
+                    log.breakLine();
+                    process.exit(1);
+                }
+                const deploySpinner = require("ora")("开始部署 agent 项目...");
+                const result = yield uploadService.deploy({
+                    targetPath,
+                    agentId: projectInfo.agentId,
+                    version: projectInfo.version,
+                    desc: projectInfo.desc,
+                });
+                if (result.success && result.code === 0) {
+                    log.breakLine();
+                    deploySpinner.succeed(chalk_1.default.green(`部署完成 ✅`));
+                }
+                else {
+                    throw new Error(result.msg);
+                }
+            }
+            catch (e) {
+                log.error(`部署失败: ${e.message}`);
+                log.breakLine();
+                console.log(chalk_1.default.gray("💡 可能的解决方案:"));
+                console.log(chalk_1.default.gray("  • 请检查文件路径是否正确"));
+                console.log(chalk_1.default.gray("  • 请确保文件存在"));
+                console.log(chalk_1.default.gray("  • 使用示例 rcb agent build -d ./ -o ./dist"));
+                log.breakLine();
+                process.exit(1);
+            }
+        });
+    }
+    get options() {
+        return {
+            cmd: "agent",
+            childCmd: "deploy",
+            desc: "部署 agent 项目",
+            options: [
+                {
+                    flags: "-t, --targetPath <targetPath>",
+                    desc: "指定 agent 产物文件所在的目录（不指定则默认读取当前目录）",
+                },
+                {
+                    flags: "-c, --projectConfig <projectConfig>",
+                    desc: "指定 agent project.config.json项目配置文件（不指定则默认读取当前目录）",
+                },
+            ],
+        };
+    }
+};
+exports.AgentDeployCommand = AgentDeployCommand;
+__decorate([
+    (0, decorators_1.InjectParams)(),
+    __param(0, (0, decorators_1.ArgsOptions)()),
+    __param(1, (0, decorators_1.Log)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Function]),
+    __metadata("design:returntype", Promise)
+], AgentDeployCommand.prototype, "execute", null);
+exports.AgentDeployCommand = AgentDeployCommand = __decorate([
+    (0, base_1.ICommand)(),
+    (0, auth_1.AuthGuard)()
+], AgentDeployCommand);

package/lib/commands/agent/dev.js

@@ -0,0 +1,112 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentDevCommand = void 0;
+const fs_1 = __importDefault(require("fs"));
+const cloud_toolkit_1 = require("@vectorx/cloud-toolkit");
+const chalk_1 = __importDefault(require("chalk"));
+const base_1 = require("../../core/base");
+const decorators_1 = require("../../decorators");
+const prefix = chalk_1.default.bgGreenBright(" 🚀 [rcb-ff log] ");
+let AgentDevCommand = class AgentDevCommand extends base_1.Command {
+    execute(options, log) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const workDir = options.dir || process.cwd();
+            if (!fs_1.default.existsSync(workDir)) {
+                throw new Error(`目录不存在: ${workDir}`);
+            }
+            try {
+                const { simulatorPort } = yield (0, cloud_toolkit_1.startDev)({
+                    workDir,
+                    port: options.port ? Number.parseInt(options.port) : undefined,
+                    simulatorPort: options.simulatorport ? Number.parseInt(options.simulatorport) : undefined,
+                    watch: options.watch,
+                    open: false,
+                });
+                if (options.open) {
+                    log.info(`${prefix} 正在打开浏览器访问 localhost:${simulatorPort}`);
+                    (0, cloud_toolkit_1.openBrowser)("localhost", simulatorPort);
+                }
+                log.info(`${prefix} ${chalk_1.default.greenBright("开发环境启动完成！")}`);
+                this.setupProcessCleanup(log);
+            }
+            catch (error) {
+                log.error(`${prefix} 启动开发环境失败: ${error.message}`);
+                throw error;
+            }
+        });
+    }
+    setupProcessCleanup(log) {
+        const cleanupHandler = () => {
+            log.info(`${prefix} 正在关闭服务...`);
+            (0, cloud_toolkit_1.cleanup)();
+            process.exit(0);
+        };
+        process.on("SIGINT", cleanupHandler);
+        process.on("SIGTERM", cleanupHandler);
+    }
+    get options() {
+        return {
+            cmd: "agent",
+            childCmd: "dev",
+            desc: "启动 agent 开发服务器",
+            options: [
+                {
+                    flags: "-d, --dir <dir>",
+                    desc: "指定服务调试的目录，默认为当前目录",
+                },
+                {
+                    flags: "-o, --open",
+                    desc: "自动打开浏览器访问模拟器",
+                },
+                {
+                    flags: "-p, --port <port>",
+                    desc: "指定 Agent Server 端口，默认自动分配",
+                },
+                {
+                    flags: "-sp, --simulatorport <port>",
+                    desc: "指定 Agent 模拟器端口，默认自动分配",
+                },
+                {
+                    flags: "-w, --watch",
+                    desc: "启用文件监听模式，文件变化时自动重启服务",
+                },
+            ],
+        };
+    }
+};
+exports.AgentDevCommand = AgentDevCommand;
+__decorate([
+    (0, decorators_1.InjectParams)(),
+    __param(0, (0, decorators_1.ArgsOptions)()),
+    __param(1, (0, decorators_1.Log)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Function]),
+    __metadata("design:returntype", Promise)
+], AgentDevCommand.prototype, "execute", null);
+exports.AgentDevCommand = AgentDevCommand = __decorate([
+    (0, base_1.ICommand)()
+], AgentDevCommand);

package/lib/commands/agent/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./dev"), exports);
+__exportStar(require("./build"), exports);
+__exportStar(require("./new"), exports);