@ones-open/cli 0.50.0 → 1.0.1-16596.1816

package/dist/index.js

@@ -0,0 +1,835 @@
+import _includesInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/includes";
+import { Command } from "commander";
+import { ErrorCode as ErrorCode$1, throwError, getCommandOptions, addCommandUsage, addCommandOutput, $create, setContext } from "create-ones-app";
+import { get, noop, merge } from "lodash-es";
+import process, { cwd, exit } from "node:process";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { readFileSync } from "node:fs";
+import { z } from "zod";
+import fse from "fs-extra";
+import envPaths from "env-paths";
+import http from "node:http";
+import ora from "ora";
+import open from "open";
+import getPort from "get-port";
+import { v7 } from "uuid";
+import axios from "axios";
+import _reduceInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/reduce";
+const en = {
+  "desc.ones": "cli for ones",
+  "desc.build": "build the application",
+  "desc.build.output": "specify the output file path",
+  "desc.dev": "develop the application",
+  "desc.dev.install": "whether to install the application",
+  "desc.tunnel": "start a tunnel to the application",
+  "desc.tunnel.port": "specify the port number for serve",
+  "desc.login": "login to the environment",
+  "desc.login.baseUrl": "specify the environment url for login",
+  "desc.logout": "logout from the environment",
+  "desc.whoami": "show the current user",
+  "desc.app": "app command",
+  "desc.install": "install the application",
+  "desc.enable": "enable the application",
+  "desc.disable": "disable the application",
+  "desc.uninstall": "uninstall the application",
+  "desc.legacy": "legacy command",
+  "error.login.missingBaseURL": "missing base url",
+  "error.login.incorrectBaseURL": "incorrect base url",
+  "error.tunnel.missingPort": "missing port",
+  "error.tunnel.incorrectPort": "incorrect port",
+  "error.schema.app.package.parseError": "app package json parse error",
+  "error.schema.app.manifest.parseError": "app manifest json parse error",
+  "error.build.scriptNotFound": "build script not found",
+  "error.dev.scriptNotFound": "dev script not found",
+  "error.store.permission": 'permission denied, please check the file permission with "{filePath}"'
+};
+const map = {
+  en
+};
+const getCurrentLanguageList = () => {
+  return ["en"];
+};
+const translate = (key, params) => {
+  const list = getCurrentLanguageList();
+  for (let index = 0; index < list.length; index++) {
+    const language = list[index];
+    let value = get(map[language], key);
+    if (value) {
+      if (params && typeof value === "string") {
+        value = value.replace(/\{(\w+)\}/g, (match, paramKey) => {
+          var _params$paramKey;
+          const result = (_params$paramKey = params === null || params === void 0 ? void 0 : params[paramKey]) !== null && _params$paramKey !== void 0 ? _params$paramKey : match;
+          return String(result);
+        });
+      }
+      return value;
+    }
+  }
+  return key;
+};
+const i18n = {
+  t: translate
+};
+var ErrorCode = ((ErrorCode2) => {
+  ErrorCode2[ErrorCode2["UNKNOWN_ERROR"] = ErrorCode$1.UNKNOWN_ERROR] = "UNKNOWN_ERROR";
+  ErrorCode2[ErrorCode2["COMMAND_ERROR"] = ErrorCode$1.COMMAND_ERROR] = "COMMAND_ERROR";
+  ErrorCode2[ErrorCode2["TEMPLATE_NOT_FOUND"] = ErrorCode$1.TEMPLATE_NOT_FOUND] = "TEMPLATE_NOT_FOUND";
+  ErrorCode2["MISSING_BASE_URL"] = "E03";
+  ErrorCode2["MISSING_PORT"] = "E04";
+  ErrorCode2["INCORRECT_BASE_URL"] = "E05";
+  ErrorCode2["INCORRECT_PORT"] = "E06";
+  ErrorCode2["APP_PACKAGE_JSON_PARSE_ERROR"] = "E07";
+  ErrorCode2["APP_MANIFEST_JSON_PARSE_ERROR"] = "E08";
+  ErrorCode2["BUILD_SCRIPT_NOT_FOUND"] = "E09";
+  ErrorCode2["DEV_SCRIPT_NOT_FOUND"] = "E10";
+  ErrorCode2["STORE_PERMISSION"] = "E11";
+  return ErrorCode2;
+})(ErrorCode || {});
+const AppPackageJSONSchema = z.object({
+  scripts: z.object({
+    dev: z.string().optional(),
+    build: z.string().optional()
+  }).optional()
+});
+const AppManifestJSONSchema = z.object({
+  app: z.object({
+    id: z.string(),
+    name: z.string(),
+    version: z.string(),
+    logo: z.string().optional(),
+    desc: z.string().optional(),
+    base_url: z.string().optional(),
+    auth: z.object({
+      type: z.literal("jwt")
+    }),
+    ones_version: z.object({
+      min: z.string(),
+      max: z.string()
+    }).optional(),
+    lifecycle_callback: z.object({
+      install: z.string(),
+      enabled: z.string().optional(),
+      disabled: z.string().optional(),
+      uninstalled: z.string().optional()
+    }),
+    oauth: z.object({
+      type: z.array(z.enum(["app", "user"])).optional(),
+      scope: z.array(z.string()),
+      redirect_url: z.string().optional()
+    }).optional(),
+    events: z.object({
+      url: z.string(),
+      types: z.array(z.object({
+        eventType: z.string()
+      }))
+    }).optional(),
+    extensions: z.record(z.unknown()).optional()
+  })
+});
+const getPackageJSONPath = () => {
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  return join(__dirname, "../package.json");
+};
+const getPackageJSON = () => {
+  const path = getPackageJSONPath();
+  try {
+    const string = readFileSync(path, {
+      encoding: "utf8"
+    });
+    return JSON.parse(string);
+  } catch (error) {
+    return {};
+  }
+};
+const getAppPackageJSONPath = () => {
+  return join(cwd(), "./package.json");
+};
+const getAppPackageJSON = () => {
+  const path = getAppPackageJSONPath();
+  try {
+    const string = readFileSync(path, {
+      encoding: "utf8"
+    });
+    const json = JSON.parse(string);
+    return AppPackageJSONSchema.parse(json);
+  } catch (error) {
+    console.error(error);
+    return throwError(ErrorCode.APP_PACKAGE_JSON_PARSE_ERROR, i18n.t("error.schema.app.package.parseError"));
+  }
+};
+const getAppManifestJSONPath = () => {
+  return join(cwd(), "./opkx.json");
+};
+const getAppManifestJSON = () => {
+  const path = getAppManifestJSONPath();
+  try {
+    const string = readFileSync(path, {
+      encoding: "utf8"
+    });
+    const json = JSON.parse(string);
+    return AppManifestJSONSchema.parse(json);
+  } catch (error) {
+    console.error(error);
+    return throwError(ErrorCode.APP_MANIFEST_JSON_PARSE_ERROR, i18n.t("error.schema.app.manifest.parseError"));
+  }
+};
+const isOPKXFilename = /\.opkx$/;
+const defaultOutputPath = "";
+const normalize$a = async (options) => {
+  var _options$output;
+  let output = resolve(cwd(), (_options$output = options.output) !== null && _options$output !== void 0 ? _options$output : defaultOutputPath);
+  if (isOPKXFilename.test(output))
+    ;
+  else {
+    const appManifestJSON = getAppManifestJSON();
+    const defaultOutputFilename = `${appManifestJSON.app.name}.opkx`;
+    output = resolve(output, defaultOutputFilename);
+  }
+  return {
+    output
+  };
+};
+const build = async function() {
+  var _appPackageJSON$scrip;
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  const {
+    options
+  } = getCommandOptions(args, buildCommandArguments);
+  const normalizedOptions = await normalize$a(options);
+  console.log("build", normalizedOptions);
+  const appPackageJSON = getAppPackageJSON();
+  console.log("appPackageJSON", appPackageJSON);
+  const appManifestJSON = getAppManifestJSON();
+  console.log("appManifestJSON", appManifestJSON);
+  if ((_appPackageJSON$scrip = appPackageJSON.scripts) !== null && _appPackageJSON$scrip !== void 0 && _appPackageJSON$scrip.build)
+    ;
+  else {
+    return throwError(ErrorCode.BUILD_SCRIPT_NOT_FOUND, i18n.t("error.build.scriptNotFound"));
+  }
+};
+var InstallOptions = /* @__PURE__ */ ((InstallOptions2) => {
+  InstallOptions2["AUTO"] = "auto";
+  InstallOptions2["TRUE"] = "true";
+  InstallOptions2["FALSE"] = "false";
+  return InstallOptions2;
+})(InstallOptions || {});
+const defaultInstall = InstallOptions.AUTO;
+const normalize$9 = async (options) => {
+  var _options$install;
+  let install2 = (_options$install = options.install) !== null && _options$install !== void 0 ? _options$install : defaultInstall;
+  switch (true) {
+    case install2 === InstallOptions.AUTO:
+      break;
+    case Boolean(install2):
+      install2 = InstallOptions.TRUE;
+      break;
+    default:
+      install2 = InstallOptions.FALSE;
+      break;
+  }
+  return {
+    install: install2
+  };
+};
+const dev = async function() {
+  var _appPackageJSON$scrip;
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  const {
+    options
+  } = getCommandOptions(args, devCommandArguments);
+  const normalizedOptions = await normalize$9(options);
+  console.log("dev", normalizedOptions);
+  const appPackageJSON = getAppPackageJSON();
+  console.log("appPackageJSON", appPackageJSON);
+  const appManifestJSON = getAppManifestJSON();
+  console.log("appManifestJSON", appManifestJSON);
+  if ((_appPackageJSON$scrip = appPackageJSON.scripts) !== null && _appPackageJSON$scrip !== void 0 && _appPackageJSON$scrip.dev) {
+    if (normalizedOptions.install)
+      ;
+  } else {
+    return throwError(ErrorCode.DEV_SCRIPT_NOT_FOUND, i18n.t("error.dev.scriptNotFound"));
+  }
+};
+const isPortNumber = /^[1-9]\d{0,4}$/;
+const minPortNumber = 1;
+const maxPortNumber = 65535;
+const normalize$8 = async (options) => {
+  const portInput = options.port;
+  if (portInput)
+    ;
+  else {
+    return throwError(ErrorCode.MISSING_PORT, i18n.t("error.tunnel.missingPort"));
+  }
+  const portString = String(portInput);
+  const portNumber = Number(portString);
+  if (isPortNumber.test(portString))
+    ;
+  else {
+    return throwError(ErrorCode.INCORRECT_PORT, i18n.t("error.tunnel.incorrectPort"));
+  }
+  if (portNumber < minPortNumber || portNumber > maxPortNumber) {
+    return throwError(ErrorCode.INCORRECT_PORT, i18n.t("error.tunnel.incorrectPort"));
+  }
+  const port = portString;
+  return {
+    port
+  };
+};
+const StoreJSONSchema = z.object({
+  version: z.string().optional(),
+  timestamp: z.number().optional(),
+  base_url: z.string().optional(),
+  region_url: z.string().optional(),
+  ones_token: z.string().optional()
+});
+const {
+  ensureFile,
+  readJSON,
+  writeJSON
+} = fse;
+const name = "@ones-open/cli";
+const paths = envPaths(name);
+const storeDir = paths.config;
+const storePath = join(storeDir, "config.json");
+const getStore = async () => {
+  let json = {};
+  try {
+    await ensureFile(storePath);
+    json = await readJSON(storePath, {
+      encoding: "utf8"
+    });
+  } catch (error) {
+    const $error = error;
+    if ($error.code === "EPERM" || $error.code === "EACCES") {
+      return throwError(ErrorCode.STORE_PERMISSION, i18n.t("error.store.permission", {
+        filePath: storePath
+      }));
+    }
+    if ($error instanceof SyntaxError) {
+      return {};
+    }
+    throw error;
+  }
+  try {
+    return StoreJSONSchema.parse(json);
+  } catch (error) {
+    return {};
+  }
+};
+const setStore = async (store) => {
+  try {
+    await ensureFile(storePath);
+    const version = `${getPackageJSON().version}`;
+    const timestamp = Date.now();
+    return await writeJSON(storePath, {
+      ...store,
+      version,
+      timestamp
+    }, {
+      encoding: "utf8"
+    });
+  } catch (error) {
+    const $error = error;
+    if ($error.code === "EPERM" || $error.code === "EACCES") {
+      return throwError(ErrorCode.STORE_PERMISSION, i18n.t("error.store.permission", {
+        filePath: storePath
+      }));
+    }
+    throw error;
+  }
+};
+const mergeStore = async (store) => {
+  const currentStore = await getStore();
+  return setStore({
+    ...currentStore,
+    ...store
+  });
+};
+const setBaseURL = async (baseURL) => {
+  return mergeStore({
+    base_url: baseURL
+  });
+};
+const getRegionURL = async () => {
+  var _store$region_url;
+  const store = await getStore();
+  return (_store$region_url = store.region_url) !== null && _store$region_url !== void 0 ? _store$region_url : "";
+};
+const setRegionURL = async (regionURL) => {
+  return mergeStore({
+    region_url: regionURL
+  });
+};
+const getONESToken = async () => {
+  var _store$ones_token;
+  const store = await getStore();
+  return (_store$ones_token = store.ones_token) !== null && _store$ones_token !== void 0 ? _store$ones_token : "";
+};
+const setONESToken = async (token) => {
+  return mergeStore({
+    ones_token: token
+  });
+};
+const invokeTunnel = async (port) => {
+  console.log("invokeTunnel", port);
+  const appManifestJSON = getAppManifestJSON();
+  console.log("appManifestJSON", appManifestJSON);
+  const regionURL = await getRegionURL();
+  const onesToken = await getONESToken();
+  console.log("regionURL", regionURL);
+  console.log("onesToken", onesToken);
+};
+const tunnel = async function() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  const {
+    options
+  } = getCommandOptions(args, tunnelCommandArguments);
+  const normalizedOptions = await normalize$8(options);
+  await invokeTunnel(normalizedOptions.port);
+};
+const config = {
+  defaultPort: {
+    login: 8200
+  }
+};
+const getConfig = () => config;
+const getPublicPath = () => {
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  return join(__dirname, "../public");
+};
+function createPromise() {
+  let resolve2;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve2 = res;
+    reject = rej;
+  });
+  return {
+    promise,
+    resolve: resolve2,
+    reject
+  };
+}
+const sleep = (number) => {
+  return new Promise((resolve2) => {
+    setTimeout(resolve2, number);
+  });
+};
+const isURL = /^https?:\/\//;
+const HostBlackList = ["ones.cn", "www.ones.cn", "ones.com", "www.ones.com"];
+const normalize$7 = async (options) => {
+  const baseURLInput = options.baseURL;
+  if (baseURLInput)
+    ;
+  else {
+    return throwError(ErrorCode.MISSING_BASE_URL, i18n.t("error.login.missingBaseURL"));
+  }
+  if (isURL.test(baseURLInput))
+    ;
+  else {
+    return throwError(ErrorCode.INCORRECT_BASE_URL, i18n.t("error.login.incorrectBaseURL"));
+  }
+  let baseURL = "";
+  try {
+    const url = new URL(baseURLInput);
+    const host = url.hostname;
+    if (_includesInstanceProperty(HostBlackList).call(HostBlackList, host)) {
+      return throwError(ErrorCode.INCORRECT_BASE_URL, i18n.t("error.login.incorrectBaseURL"));
+    }
+    url.pathname = "";
+    url.search = "";
+    url.hash = "";
+    baseURL = url.toString();
+  } catch (error) {
+    return throwError(ErrorCode.INCORRECT_BASE_URL, i18n.t("error.login.incorrectBaseURL"));
+  }
+  return {
+    baseURL
+  };
+};
+const login = async function() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  const {
+    options
+  } = getCommandOptions(args, loginCommandArguments);
+  const normalizedOptions = await normalize$7(options);
+  const base = normalizedOptions.baseURL;
+  const path = "project/oauth2.html";
+  const config2 = getConfig();
+  const port = await getPort({
+    port: config2.defaultPort.login
+  });
+  const uuid = v7();
+  const search = new URLSearchParams();
+  search.set("redirect_path", "/developer/cli");
+  search.set("redirect_url", `http://localhost:${port}`);
+  search.set("state", uuid);
+  const url = `${base}${path}?${search}`;
+  const publicPath = getPublicPath();
+  const htmlPath = join(publicPath, "callback.html");
+  const html = readFileSync(htmlPath, {
+    encoding: "utf-8"
+  });
+  const {
+    promise,
+    resolve: resolve2
+  } = createPromise();
+  const server = http.createServer((req, res) => {
+    var _req$url$split$, _req$url, _search2$get, _search2$get2;
+    const search2 = new URLSearchParams((_req$url$split$ = (_req$url = req.url) === null || _req$url === void 0 ? void 0 : _req$url.split("?")[1]) !== null && _req$url$split$ !== void 0 ? _req$url$split$ : "");
+    const state = search2.get("state");
+    const token = (_search2$get = search2.get("access_token")) !== null && _search2$get !== void 0 ? _search2$get : "";
+    const region = (_search2$get2 = search2.get("region_url")) !== null && _search2$get2 !== void 0 ? _search2$get2 : "";
+    if (state === uuid && token && region) {
+      resolve2({
+        base_url: base,
+        ones_token: token,
+        region_url: region
+      });
+    }
+    res.writeHead(200, {
+      "Content-Type": "text/html"
+    });
+    res.end(html);
+  });
+  server.listen(port);
+  promise.then(async (store) => {
+    var _store$base_url, _store$ones_token, _store$region_url;
+    await sleep(100);
+    server.closeAllConnections();
+    await setBaseURL((_store$base_url = store.base_url) !== null && _store$base_url !== void 0 ? _store$base_url : "");
+    await setONESToken((_store$ones_token = store.ones_token) !== null && _store$ones_token !== void 0 ? _store$ones_token : "");
+    await setRegionURL((_store$region_url = store.region_url) !== null && _store$region_url !== void 0 ? _store$region_url : "");
+    console.log("Logged in successfully!");
+    process.exit(0);
+  });
+  console.log("Logging into your ONES account...");
+  console.log(`Opening ${url}`);
+  ora("Waiting for authorization...").start();
+  await open(url);
+};
+const normalize$6 = async (options) => {
+  noop(options);
+  return {};
+};
+const logout = async function() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  const {
+    options
+  } = getCommandOptions(args, logoutCommandArguments);
+  const normalizedOptions = await normalize$6(options);
+  noop(normalizedOptions);
+  await setStore({});
+  console.log("Logged out successfully!");
+};
+const API = {
+  TOKEN_INFO: "/project/api/project/auth/token_info",
+  APP_LIST: "/platform/api/app/list",
+  APP_INSTALL: "/app/install",
+  APP_UNINSTALL: "/app/uninstall",
+  APP_ENABLE: "/platform/api/app/:installation_id/enable",
+  APP_DISABLE: "/platform/api/app/:installation_id/disable"
+};
+const getPath = (path, map2) => {
+  var _context;
+  return _reduceInstanceProperty(_context = path.split("/")).call(_context, (base, part) => {
+    if (/^:/.test(part)) {
+      return `${base}/${map2[part.slice(1)]}`;
+    }
+    return `${base}/${part}`;
+  }, "").slice(1);
+};
+const consoleUnauthorizedMessage = () => {
+  console.log("Not logged in");
+  console.log('Login with "ones login" command');
+};
+const getURL = async (path, pathMap, queryMap) => {
+  const base = await getRegionURL();
+  if (base) {
+    const query = new URLSearchParams(queryMap !== null && queryMap !== void 0 ? queryMap : {}).toString();
+    return `${base}${getPath(path, pathMap !== null && pathMap !== void 0 ? pathMap : {})}${query ? `?${query}` : ""}`;
+  }
+  consoleUnauthorizedMessage();
+  exit(1);
+};
+const getHeaders = async (value) => {
+  const token = await getONESToken();
+  if (token) {
+    return merge({
+      Authorization: `Bearer ${token}`
+    }, value);
+  }
+  consoleUnauthorizedMessage();
+  exit(1);
+};
+const handleError = (error) => {
+  var _error$response;
+  if (((_error$response = error.response) === null || _error$response === void 0 ? void 0 : _error$response.status) === 401) {
+    console.log(error.response.statusText);
+    consoleUnauthorizedMessage();
+  } else {
+    console.error(error);
+  }
+  return {};
+};
+const fetchAppBase = async (params) => {
+  var _params$url;
+  const url = await getURL((_params$url = params.url) !== null && _params$url !== void 0 ? _params$url : "", params.pathMap, params.queryMap);
+  const headers = await getHeaders(params.headers);
+  const response = await axios({
+    ...params,
+    url,
+    headers
+  });
+  return response.data;
+};
+const fetchAppList = async (appID) => {
+  return await fetchAppBase({
+    url: API.APP_LIST,
+    method: "GET",
+    queryMap: {
+      app_id: appID
+    }
+  }).catch(handleError);
+};
+const fetchTokenInfo = async () => {
+  return await fetchAppBase({
+    url: API.TOKEN_INFO,
+    method: "GET"
+  }).catch(handleError);
+};
+const fetchAppInstall = async () => {
+  return await fetchAppBase({
+    url: API.APP_INSTALL,
+    method: "POST"
+  }).catch(handleError);
+};
+const fetchAppUninstall = async () => {
+  return await fetchAppBase({
+    url: API.APP_UNINSTALL,
+    method: "POST"
+  }).catch(handleError);
+};
+const fetchAppEnable = async () => {
+  var _appList$data$0$insta, _appList$data;
+  const appID = getAppManifestJSON().app.id;
+  const appList = await fetchAppList(appID);
+  const installationID = (_appList$data$0$insta = (_appList$data = appList.data) === null || _appList$data === void 0 || (_appList$data = _appList$data[0]) === null || _appList$data === void 0 ? void 0 : _appList$data.installation_id) !== null && _appList$data$0$insta !== void 0 ? _appList$data$0$insta : "";
+  return await fetchAppBase({
+    url: API.APP_ENABLE,
+    method: "POST",
+    pathMap: {
+      installation_id: installationID
+    }
+  }).catch(handleError);
+};
+const fetchAppDisable = async () => {
+  var _appList$data$0$insta2, _appList$data2;
+  const appID = getAppManifestJSON().app.id;
+  const appList = await fetchAppList(appID);
+  const installationID = (_appList$data$0$insta2 = (_appList$data2 = appList.data) === null || _appList$data2 === void 0 || (_appList$data2 = _appList$data2[0]) === null || _appList$data2 === void 0 ? void 0 : _appList$data2.installation_id) !== null && _appList$data$0$insta2 !== void 0 ? _appList$data$0$insta2 : "";
+  return await fetchAppBase({
+    url: API.APP_DISABLE,
+    method: "POST",
+    pathMap: {
+      installation_id: installationID
+    }
+  }).catch(handleError);
+};
+const normalize$5 = async (options) => {
+  noop(options);
+  return {};
+};
+const whoami = async function() {
+  var _tokenInfo$user, _tokenInfo$user2;
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  const {
+    options
+  } = getCommandOptions(args, whoamiCommandArguments);
+  const normalizedOptions = await normalize$5(options);
+  noop(normalizedOptions);
+  const tokenInfo = await fetchTokenInfo();
+  const name2 = (_tokenInfo$user = tokenInfo.user) === null || _tokenInfo$user === void 0 ? void 0 : _tokenInfo$user.name;
+  const email = (_tokenInfo$user2 = tokenInfo.user) === null || _tokenInfo$user2 === void 0 ? void 0 : _tokenInfo$user2.email;
+  if (name2 && email) {
+    console.log(`${name2} <${email}>`);
+  } else {
+    consoleUnauthorizedMessage();
+  }
+};
+const normalize$4 = async (options) => {
+  noop(options);
+  return {};
+};
+const install = async function() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  const {
+    options
+  } = getCommandOptions(args, installCommandArguments);
+  const normalizedOptions = await normalize$4(options);
+  noop(normalizedOptions);
+  const result = await fetchAppInstall();
+  if (result.code === "OK") {
+    console.log("App installed successfully!");
+  } else {
+    console.error(result);
+  }
+};
+const normalize$3 = async (options) => {
+  noop(options);
+  return {};
+};
+const enable = async function() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  const {
+    options
+  } = getCommandOptions(args, enableCommandArguments);
+  const normalizedOptions = await normalize$3(options);
+  noop(normalizedOptions);
+  const result = await fetchAppEnable();
+  if (result.code === "OK") {
+    console.log("App enabled successfully!");
+  } else {
+    console.error(result);
+  }
+};
+const normalize$2 = async (options) => {
+  noop(options);
+  return {};
+};
+const disable = async function() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  const {
+    options
+  } = getCommandOptions(args, disableCommandArguments);
+  const normalizedOptions = await normalize$2(options);
+  noop(normalizedOptions);
+  const result = await fetchAppDisable();
+  if (result.code === "OK") {
+    console.log("App disabled successfully!");
+  } else {
+    console.error(result);
+  }
+};
+const normalize$1 = async (options) => {
+  noop(options);
+  return {};
+};
+const uninstall = async function() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  const {
+    options
+  } = getCommandOptions(args, uninstallCommandArguments);
+  const normalizedOptions = await normalize$1(options);
+  noop(normalizedOptions);
+  const result = await fetchAppUninstall();
+  if (result.code === "OK") {
+    console.log("App uninstalled successfully!");
+  } else {
+    console.error(result);
+  }
+};
+const normalize = async (options) => {
+  noop(options);
+  return {};
+};
+const legacy = async function() {
+  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+    args[_key] = arguments[_key];
+  }
+  const {
+    options
+  } = getCommandOptions(args, legacyCommandArguments);
+  const normalizedOptions = await normalize(options);
+  console.log("legacy", normalizedOptions);
+};
+const buildCommandArguments = [];
+const $build = new Command("build").description(i18n.t("desc.build")).option("-o, --output [file-path]", i18n.t("desc.build.output")).action(build);
+addCommandUsage($build);
+addCommandOutput($build);
+const devCommandArguments = [];
+const $dev = new Command("dev").description(i18n.t("desc.dev")).option("-i, --install [boolean]", i18n.t("desc.dev.install")).action(dev);
+addCommandUsage($dev);
+addCommandOutput($dev);
+const tunnelCommandArguments = ["port"];
+const $tunnel = new Command("tunnel").description(i18n.t("desc.tunnel")).argument("<port>", i18n.t("desc.tunnel.port")).action(tunnel);
+addCommandUsage($tunnel);
+addCommandOutput($tunnel);
+const loginCommandArguments = ["baseURL"];
+const $login = new Command("login").description(i18n.t("desc.login")).argument("<base-url>", i18n.t("desc.login.baseUrl")).action(login);
+addCommandUsage($login);
+addCommandOutput($login);
+const logoutCommandArguments = [];
+const $logout = new Command("logout").description(i18n.t("desc.logout")).action(logout);
+addCommandUsage($logout);
+addCommandOutput($logout);
+const whoamiCommandArguments = [];
+const $whoami = new Command("whoami").description(i18n.t("desc.whoami")).action(whoami);
+addCommandUsage($whoami);
+addCommandOutput($whoami);
+const installCommandArguments = [];
+const $install = new Command("install").description(i18n.t("desc.install")).action(install);
+addCommandUsage($install);
+addCommandOutput($install);
+const enableCommandArguments = [];
+const $enable = new Command("enable").description(i18n.t("desc.enable")).action(enable);
+addCommandUsage($enable);
+addCommandOutput($enable);
+const disableCommandArguments = [];
+const $disable = new Command("disable").description(i18n.t("desc.disable")).action(disable);
+addCommandUsage($disable);
+addCommandOutput($disable);
+const uninstallCommandArguments = [];
+const $uninstall = new Command("uninstall").description(i18n.t("desc.uninstall")).action(uninstall);
+addCommandUsage($uninstall);
+addCommandOutput($uninstall);
+const $app = new Command("app").description(i18n.t("desc.app"));
+$app.addCommand($install).addCommand($enable).addCommand($disable).addCommand($uninstall);
+addCommandUsage($app);
+addCommandOutput($app);
+const legacyCommandArguments = [];
+const $legacy = new Command("legacy").description(i18n.t("desc.legacy")).action(legacy);
+addCommandUsage($legacy);
+addCommandOutput($legacy);
+const ones = new Command("ones");
+ones.description(i18n.t("desc.ones")).addCommand($create).addCommand($build).addCommand($dev).addCommand($tunnel).addCommand($app).addCommand($login).addCommand($logout).addCommand($whoami).addCommand($legacy).configureHelp({
+  visibleCommands: (cmd) => {
+    const blackList = ["legacy"];
+    return cmd.commands.filter((command) => !_includesInstanceProperty(blackList).call(blackList, command.name()));
+  },
+  subcommandTerm: (subcommand) => {
+    return `${subcommand.name()} ${subcommand.usage()}`.trim();
+  }
+});
+addCommandOutput(ones);
+const runCommandONES = async () => {
+  const command = ones;
+  setContext("command", command);
+  const version = `${getPackageJSON().version}`;
+  command.version(version);
+  await command.parse();
+};
+export {
+  runCommandONES
+};