@ones-open/cli 0.50.0 → 1.0.1-10001.1957

package/dist/index.js

@@ -0,0 +1,1588 @@
+import _includesInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/includes";
+import { Command } from "commander";
+import { ErrorCode as ErrorCode$1, AppPackageJSONSchema, throwError, AppManifestJSONSchema, getPublicPath as getPublicPath$1, PUBLIC_FILENAME, AppRcJSONSchema, getCommandOptions, HostedTokenScope, addCommandUsage, addCommandOutput, $create, setContext } from "create-ones-app";
+import { dirname, join, resolve, basename } from "node:path";
+import { spawnSync, spawn } from "node:child_process";
+import { readFileSync, createWriteStream } from "node:fs";
+import fse from "fs-extra";
+import archiver from "archiver";
+import { get, merge, noop } from "lodash-es";
+import process$1, { cwd } from "node:process";
+import { fileURLToPath } from "node:url";
+import { cosmiconfig } from "cosmiconfig";
+import getPort from "get-port";
+import envPaths from "env-paths";
+import { z } from "zod";
+import axios from "axios";
+import _reduceInstanceProperty from "@babel/runtime-corejs3/core-js-stable/instance/reduce";
+import WebSocket from "ws";
+import http from "node:http";
+import ora from "ora";
+import open from "open";
+import { v4 } from "uuid";
+const en = {
+  "desc.ones": "ONES CLI/{env}",
+  "desc.build": "Build your ONES App",
+  "desc.build.output": "Specify the output file path",
+  "desc.dev": "Start your local development server and connect to ONES",
+  "desc.dev.install": "Install your ONES App after the server is ready",
+  "desc.dev.command": "Specify the dev command",
+  "desc.tunnel": "Start a tunnel to connect your local server with ONES",
+  "desc.tunnel.port": "Specify the port number for tunnel",
+  "desc.login": "Log in to your ONES account",
+  "desc.login.baseUrl": "Specify the ONES URL for login",
+  "desc.logout": "Log out of your ONES account",
+  "desc.whoami": "Display the account information of the logged in user",
+  "desc.app": "Manage app installations",
+  "desc.install": "Install your ONES App",
+  "desc.enable": "Enable your ONES App",
+  "desc.disable": "Disable your ONES App",
+  "desc.uninstall": "Uninstall your ONES App",
+  "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 "opkx.json" JSON parse error',
+  "error.build.scriptNotFound": 'Npm "build" script not found',
+  "error.dev.scriptNotFound": 'Npm "dev" script not found',
+  "error.dev.incorrectCommand": "Incorrect dev command",
+  "error.store.permission": 'Permission denied, please check the file permission with "{filePath}"',
+  "error.hostedToken.requestFailed": "Failed to request hosted token",
+  "error.hostedToken.empty": "Hosted token is empty"
+};
+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[ErrorCode2["MISSING_PROJECT_PATH"] = ErrorCode$1.MISSING_PROJECT_PATH] = "MISSING_PROJECT_PATH";
+  ErrorCode2["MISSING_BASE_URL"] = "E04";
+  ErrorCode2["MISSING_PORT"] = "E05";
+  ErrorCode2["INCORRECT_BASE_URL"] = "E06";
+  ErrorCode2["INCORRECT_PORT"] = "E07";
+  ErrorCode2["APP_PACKAGE_JSON_PARSE_ERROR"] = "E08";
+  ErrorCode2["APP_MANIFEST_JSON_PARSE_ERROR"] = "E09";
+  ErrorCode2["BUILD_SCRIPT_NOT_FOUND"] = "E10";
+  ErrorCode2["DEV_SCRIPT_NOT_FOUND"] = "E11";
+  ErrorCode2["STORE_PERMISSION"] = "E12";
+  ErrorCode2["HOSTED_TOKEN_REQUEST_FAILED"] = "E13";
+  ErrorCode2["HOSTED_TOKEN_EMPTY"] = "E14";
+  ErrorCode2["INCORRECT_DEV_COMMAND"] = "E15";
+  return ErrorCode2;
+})(ErrorCode || {});
+const getPublicPath = () => {
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  return join(__dirname, "../public");
+};
+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 getAppWorkspacePath = () => {
+  return join(cwd());
+};
+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) {
+    const details = error instanceof Error ? error.message : String(error);
+    return throwError(ErrorCode.APP_PACKAGE_JSON_PARSE_ERROR, `${i18n.t("error.schema.app.package.parseError")}: ${details}`);
+  }
+};
+const getAppManifestJSONPath = () => {
+  return join(cwd(), PUBLIC_FILENAME.MANIFEST);
+};
+const getAppManifestJSON = () => {
+  const path = getAppManifestJSONPath();
+  try {
+    const string = readFileSync(path, {
+      encoding: "utf8"
+    });
+    const json = JSON.parse(string);
+    return AppManifestJSONSchema.parse(json);
+  } catch (error) {
+    const details = error instanceof Error ? error.message : String(error);
+    return throwError(ErrorCode.APP_MANIFEST_JSON_PARSE_ERROR, `${i18n.t("error.schema.app.manifest.parseError")}: ${details}`);
+  }
+};
+const defaultDevCommand = ["npm", "run", "dev"];
+const defaultAppRcJSON = {
+  dev: {
+    command: defaultDevCommand
+  }
+};
+let storeAppRcJSON = null;
+const getAppRcJSON = async () => {
+  if (storeAppRcJSON)
+    ;
+  else {
+    try {
+      const path = join(getPublicPath$1(), PUBLIC_FILENAME.RC);
+      const string = readFileSync(path, {
+        encoding: "utf8"
+      });
+      const json = JSON.parse(string);
+      storeAppRcJSON = AppRcJSONSchema.parse(json);
+    } catch (error) {
+      storeAppRcJSON = {};
+    }
+  }
+  const templateAppRcJSON = storeAppRcJSON || {};
+  let currentAppRcJSON;
+  const explorer = cosmiconfig("ones");
+  try {
+    const result = await explorer.search();
+    const json = result === null || result === void 0 ? void 0 : result.config;
+    currentAppRcJSON = AppRcJSONSchema.parse(json);
+  } catch (error) {
+    currentAppRcJSON = {};
+  }
+  return {
+    ...defaultAppRcJSON,
+    ...templateAppRcJSON,
+    ...currentAppRcJSON
+  };
+};
+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 {
+  existsSync,
+  ensureDirSync
+} = fse;
+const build = async function() {
+  var _appRcJSON$build$comp, _appRcJSON$build;
+  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);
+  const appManifestJSON = getAppManifestJSON();
+  const appRcJSON = await getAppRcJSON();
+  const appPackageJSONPath = getAppPackageJSONPath();
+  const isExists = existsSync(appPackageJSONPath);
+  if (isExists) {
+    var _appPackageJSON$scrip;
+    const appPackageJSON = getAppPackageJSON();
+    if ((_appPackageJSON$scrip = appPackageJSON.scripts) !== null && _appPackageJSON$scrip !== void 0 && _appPackageJSON$scrip.build) {
+      const buildResult = spawnSync("npm", ["run", "build"], {
+        cwd: getAppWorkspacePath(),
+        stdio: "inherit",
+        env: {
+          ...process.env,
+          NODE_ENV: "production"
+        }
+      });
+      if (buildResult.status !== 0 || buildResult.signal) {
+        var _buildResult$status;
+        process.exit((_buildResult$status = buildResult.status) !== null && _buildResult$status !== void 0 ? _buildResult$status : 1);
+      }
+    } else {
+      return throwError(ErrorCode.BUILD_SCRIPT_NOT_FOUND, i18n.t("error.build.scriptNotFound"));
+    }
+  }
+  const appName = appManifestJSON.app.name;
+  const outputPath = normalizedOptions.output;
+  const outputDir = dirname(outputPath);
+  const outputFilename = basename(outputPath);
+  ensureDirSync(outputDir);
+  const outputStream = createWriteStream(outputPath);
+  const files = (_appRcJSON$build$comp = (_appRcJSON$build = appRcJSON.build) === null || _appRcJSON$build === void 0 || (_appRcJSON$build = _appRcJSON$build.compress) === null || _appRcJSON$build === void 0 ? void 0 : _appRcJSON$build.files) !== null && _appRcJSON$build$comp !== void 0 ? _appRcJSON$build$comp : [];
+  const archive = archiver("zip", {
+    zlib: {
+      level: 9
+    }
+  });
+  archive.on("error", (err) => {
+    throw err;
+  });
+  archive.on("warning", (err) => {
+    throw err;
+  });
+  archive.on("progress", (progress) => {
+    const {
+      entries,
+      fs
+    } = progress;
+    const entriesStr = entries.total > 0 ? ` ${entries.processed}/${entries.total} files` : "";
+    const bytesStr = fs.totalBytes > 0 ? ` ${(fs.processedBytes / 1024).toFixed(1)}/${(fs.totalBytes / 1024).toFixed(1)} KB` : "";
+    process.stdout.write(`\rCompressing:${entriesStr}${bytesStr}   `);
+  });
+  archive.on("finish", () => {
+    process.stdout.write("\n");
+    console.log("");
+    console.log("Files in archive: ", PUBLIC_FILENAME.MANIFEST, files);
+    console.log(`App "${appName}" built successfully!`);
+    console.log(`OPKX "${outputFilename}" created successfully!`);
+    console.log(`Output file: ${outputPath}`);
+  });
+  archive.pipe(outputStream);
+  files.forEach((file) => {
+    archive.glob(file, {
+      cwd: getAppWorkspacePath()
+    });
+  });
+  archive.file(PUBLIC_FILENAME.MANIFEST, {
+    name: PUBLIC_FILENAME.MANIFEST
+  });
+  archive.finalize();
+};
+const config = {
+  defaultPort: {
+    login: 8200,
+    hosted: 8201,
+    devWebServer: 8202
+  }
+};
+const getConfig = () => config;
+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(),
+  host_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 version2 = `${getPackageJSON().version}`;
+    const timestamp = Date.now();
+    return await writeJSON(storePath, {
+      ...store,
+      version: version2,
+      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 getBaseURL = async () => {
+  var _store$base_url;
+  const store = await getStore();
+  return (_store$base_url = store.base_url) !== null && _store$base_url !== void 0 ? _store$base_url : "";
+};
+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 getHostToken = async () => {
+  var _store$host_token;
+  const store = await getStore();
+  return (_store$host_token = store.host_token) !== null && _store$host_token !== void 0 ? _store$host_token : "";
+};
+const setHostToken = async (token) => {
+  return mergeStore({
+    host_token: token
+  });
+};
+const API = {
+  TOKEN_INFO: "/project/api/project/auth/token_info",
+  HOSTED_TOKEN: "/platform/runtime_manager/hosted_token",
+  HOSTED_ABILITY_STORAGE_DEV_DECLARE: "/platform/runtime_manager/hosted_ability/storage/dev_declare",
+  APP_LIST: "/platform/api/app/list",
+  APP_INSTALL: "/platform/api/app/install",
+  APP_UPGRADE: "/platform/api/app/upgrade",
+  APP_UNINSTALL: "/platform/api/app/:installation_id/uninstall",
+  APP_ENABLE: "/platform/api/app/:installation_id/enable",
+  APP_DISABLE: "/platform/api/app/:installation_id/disable"
+};
+const REQUEST_TIMEOUT = 1e4;
+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');
+  process.exit(1);
+};
+const consoleAppNotInstalledMessage = () => {
+  console.log("App not installed");
+  process.exit(1);
+};
+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();
+};
+const getHeaders = async (value) => {
+  const token = await getONESToken();
+  if (token) {
+    return merge({
+      Authorization: `Bearer ${token}`
+    }, value);
+  }
+  consoleUnauthorizedMessage();
+  process.exit(1);
+};
+const handleError = (error) => {
+  var _error$response, _error$response2;
+  if (((_error$response = error.response) === null || _error$response === void 0 ? void 0 : _error$response.status) === 401) {
+    console.log(error.response.statusText);
+    consoleUnauthorizedMessage();
+    process.exit(1);
+  }
+  if ((_error$response2 = error.response) !== null && _error$response2 !== void 0 && _error$response2.data) {
+    try {
+      const message = JSON.stringify(error.response.data, null, 2);
+      console.error(message);
+      process.exit(1);
+    } catch (error2) {
+    }
+  }
+  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,
+    timeout: REQUEST_TIMEOUT
+  });
+  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 fetchHostedToken = async (data) => {
+  return await fetchAppBase({
+    url: API.HOSTED_TOKEN,
+    method: "POST",
+    data
+  }).catch(handleError);
+};
+const fetchHostedAbilityStorageDevDeclare = async (data) => {
+  return await fetchAppBase({
+    url: API.HOSTED_ABILITY_STORAGE_DEV_DECLARE,
+    method: "POST",
+    data
+  }).catch(handleError);
+};
+const fetchAppInstall = async (data) => {
+  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 : "";
+  const url = installationID ? API.APP_UPGRADE : API.APP_INSTALL;
+  return await fetchAppBase({
+    url,
+    method: "POST",
+    data
+  }).catch(handleError);
+};
+const fetchAppUninstall = 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 : "";
+  if (installationID) {
+    return await fetchAppBase({
+      url: API.APP_UNINSTALL,
+      method: "POST",
+      pathMap: {
+        installation_id: installationID
+      }
+    }).catch(handleError);
+  }
+  consoleAppNotInstalledMessage();
+  process.exit(1);
+};
+const fetchAppEnable = async () => {
+  var _appList$data$0$insta3, _appList$data3;
+  const appID = getAppManifestJSON().app.id;
+  const appList = await fetchAppList(appID);
+  const installationID = (_appList$data$0$insta3 = (_appList$data3 = appList.data) === null || _appList$data3 === void 0 || (_appList$data3 = _appList$data3[0]) === null || _appList$data3 === void 0 ? void 0 : _appList$data3.installation_id) !== null && _appList$data$0$insta3 !== void 0 ? _appList$data$0$insta3 : "";
+  if (installationID) {
+    return await fetchAppBase({
+      url: API.APP_ENABLE,
+      method: "POST",
+      pathMap: {
+        installation_id: installationID
+      }
+    }).catch(handleError);
+  }
+  consoleAppNotInstalledMessage();
+  process.exit(1);
+};
+const fetchAppDisable = async () => {
+  var _appList$data$0$insta4, _appList$data4;
+  const appID = getAppManifestJSON().app.id;
+  const appList = await fetchAppList(appID);
+  const installationID = (_appList$data$0$insta4 = (_appList$data4 = appList.data) === null || _appList$data4 === void 0 || (_appList$data4 = _appList$data4[0]) === null || _appList$data4 === void 0 ? void 0 : _appList$data4.installation_id) !== null && _appList$data$0$insta4 !== void 0 ? _appList$data$0$insta4 : "";
+  if (installationID) {
+    return await fetchAppBase({
+      url: API.APP_DISABLE,
+      method: "POST",
+      pathMap: {
+        installation_id: installationID
+      }
+    }).catch(handleError);
+  }
+  consoleAppNotInstalledMessage();
+  process.exit(1);
+};
+const checkTokenInfo = async () => {
+  var _store$ones_token, _store$region_url;
+  let boolean = true;
+  const store = await getStore();
+  const token = (_store$ones_token = store.ones_token) !== null && _store$ones_token !== void 0 ? _store$ones_token : "";
+  const regionURL = (_store$region_url = store.region_url) !== null && _store$region_url !== void 0 ? _store$region_url : "";
+  if (token && regionURL) {
+    await fetchAppBase({
+      url: API.TOKEN_INFO,
+      method: "GET"
+    }).catch(() => {
+      boolean = false;
+    });
+  } else {
+    boolean = false;
+  }
+  return boolean;
+};
+const isPortNumber = /^[1-9]\d{0,4}$/;
+const minPortNumber = 1;
+const maxPortNumber = 65535;
+const MANIFEST_PATH = "/manifest";
+const ONES_CLI_INTERNAL_MANIFEST_PATH = "/__ones_cli_internal_manifest__";
+const MAX_RELAY_BODY_BYTES = 64 * 1024 * 1024;
+const normalize$9 = 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 getTunnelContext = async () => {
+  var _appManifestJSON$app$, _appManifestJSON$app, _store$region_url, _store$ones_token;
+  const appManifestJSON = getAppManifestJSON();
+  const appID = (_appManifestJSON$app$ = (_appManifestJSON$app = appManifestJSON.app) === null || _appManifestJSON$app === void 0 ? void 0 : _appManifestJSON$app.id) !== null && _appManifestJSON$app$ !== void 0 ? _appManifestJSON$app$ : "";
+  const store = await getStore();
+  const regionURL = (_store$region_url = store.region_url) !== null && _store$region_url !== void 0 ? _store$region_url : "";
+  const onesToken = (_store$ones_token = store.ones_token) !== null && _store$ones_token !== void 0 ? _store$ones_token : "";
+  if (appID && regionURL && onesToken) {
+    return {
+      appID,
+      regionURL,
+      onesToken,
+      store,
+      appManifestJSON
+    };
+  }
+  consoleUnauthorizedMessage();
+  process.exit(1);
+};
+const getHostedTokenScopes = (ones2) => {
+  const storage = ones2 === null || ones2 === void 0 ? void 0 : ones2.storage;
+  if (!storage) {
+    return [];
+  }
+  const scopes = /* @__PURE__ */ new Set();
+  if (Array.isArray(storage.entities) && storage.entities.length > 0) {
+    scopes.add(HostedTokenScope.STORAGE_ENTITY);
+  }
+  if (storage.object !== void 0 && storage.object !== null && storage.object !== false) {
+    scopes.add(HostedTokenScope.STORAGE_OBJECT);
+  }
+  return Array.from(scopes);
+};
+const getRelayScope = () => {
+  return HostedTokenScope.RELAY;
+};
+const buildTunnelUrl = async () => {
+  const {
+    appID,
+    regionURL
+  } = await getTunnelContext();
+  const url = new URL(regionURL);
+  url.pathname = `/platform/app/relay/dispatch/${appID}`;
+  return url.toString();
+};
+class TunnelClient {
+  constructor(localPort, baseUrl, appID, hostedToken) {
+    let enableInternalManifestRoute = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : true;
+    let replaceExisting = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : true;
+    this.ws = null;
+    this.localPort = localPort;
+    this.baseUrl = baseUrl;
+    this.appID = appID;
+    this.hostedToken = hostedToken;
+    this.enableInternalManifestRoute = enableInternalManifestRoute;
+    this.replaceExisting = replaceExisting;
+  }
+  async connect() {
+    const proxyUrl = this.buildProxyUrl();
+    this.ws = new WebSocket(proxyUrl, {
+      headers: {
+        Authorization: `Bearer ${this.hostedToken}`
+      },
+      maxPayload: MAX_RELAY_BODY_BYTES
+    });
+    this.ws.on("message", async (data) => {
+      const message = this.parseMessage(data);
+      if (!message) {
+        return;
+      }
+      await this.handleMessage(message);
+    });
+    this.ws.on("ping", (data) => {
+      var _this$ws;
+      (_this$ws = this.ws) === null || _this$ws === void 0 || _this$ws.pong(data);
+    });
+    this.ws.on("error", (error) => {
+      console.error("WebSocket error:", error);
+    });
+    return new Promise((resolve2, reject) => {
+      var _this$ws2, _this$ws3;
+      (_this$ws2 = this.ws) === null || _this$ws2 === void 0 || _this$ws2.on("open", () => resolve2());
+      (_this$ws3 = this.ws) === null || _this$ws3 === void 0 || _this$ws3.on("error", reject);
+    });
+  }
+  close() {
+    var _this$ws4;
+    (_this$ws4 = this.ws) === null || _this$ws4 === void 0 || _this$ws4.close();
+  }
+  buildProxyUrl() {
+    const url = new URL("/platform/app/relay/", this.baseUrl);
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    url.searchParams.set("app_id", this.appID);
+    url.searchParams.set("replace_existing", String(this.replaceExisting));
+    return url.toString();
+  }
+  parseMessage(data) {
+    const buffer = this.toBuffer(data);
+    if (!buffer) {
+      return null;
+    }
+    if (buffer.length >= 4) {
+      const binary = this.parseBinaryEnvelope(buffer);
+      if (binary) {
+        return binary;
+      }
+    }
+    return this.parseJSONEnvelope(buffer.toString());
+  }
+  async handleMessage(message) {
+    const request = this.getRequestPayload(message);
+    if (!request) {
+      return;
+    }
+    if (this.enableInternalManifestRoute && request.path === ONES_CLI_INTERNAL_MANIFEST_PATH) {
+      const appManifest = getAppManifestJSON().app;
+      const baseURL = await buildTunnelUrl();
+      const reply = {
+        id: message.id,
+        payload: {
+          status: 200,
+          headers: {
+            "content-type": ["application/json"]
+          },
+          body: {
+            ...appManifest,
+            base_url: baseURL
+          }
+        }
+      };
+      this.sendBinaryEnvelope(reply);
+      return;
+    }
+    try {
+      const response = await this.forwardRequest(request);
+      const reply = {
+        id: message.id,
+        payload: response
+      };
+      this.sendBinaryEnvelope(reply);
+    } catch (error) {
+      const reply = {
+        id: message.id,
+        payload: {
+          status: 500,
+          headers: {
+            "x-agent-error": [error instanceof Error ? error.message : "Unknown error"]
+          },
+          body: "agent request error"
+        }
+      };
+      this.sendBinaryEnvelope(reply);
+    }
+  }
+  getRequestPayload(message) {
+    const payload = message.payload;
+    if (!(payload !== null && payload !== void 0 && payload.method) || !(payload !== null && payload !== void 0 && payload.path)) {
+      return null;
+    }
+    return payload;
+  }
+  async forwardRequest(payload) {
+    const url = new URL(payload.path, `http://127.0.0.1:${this.localPort}`);
+    if (payload.query) {
+      Object.entries(payload.query).forEach((_ref) => {
+        let [key, value] = _ref;
+        if (Array.isArray(value)) {
+          value.forEach((item) => {
+            url.searchParams.append(key, item);
+          });
+          return;
+        }
+        url.searchParams.append(key, value);
+      });
+    }
+    const response = await axios.request({
+      url: url.toString(),
+      method: payload.method,
+      headers: payload.headers,
+      data: payload.body,
+      responseType: "arraybuffer",
+      validateStatus: () => true,
+      maxBodyLength: MAX_RELAY_BODY_BYTES,
+      maxContentLength: MAX_RELAY_BODY_BYTES
+    });
+    const responseBytes = Buffer.from(response.data);
+    return {
+      status: response.status,
+      headers: this.collectHeaders(response.headers),
+      body: responseBytes
+    };
+  }
+  collectHeaders(headers) {
+    const collected = {};
+    Object.entries(headers).forEach((_ref2) => {
+      let [key, value] = _ref2;
+      if (Array.isArray(value)) {
+        collected[key] = value.map((item) => String(item));
+        return;
+      }
+      if (value !== void 0 && value !== null) {
+        collected[key] = [String(value)];
+      }
+    });
+    return collected;
+  }
+  sendBinaryEnvelope(envelope) {
+    var _this$ws5;
+    const encoded = this.encodeBinaryEnvelope(envelope);
+    (_this$ws5 = this.ws) === null || _this$ws5 === void 0 || _this$ws5.send(encoded);
+  }
+  encodeBinaryEnvelope(envelope) {
+    var _envelope$payload;
+    const payload = (_envelope$payload = envelope.payload) !== null && _envelope$payload !== void 0 ? _envelope$payload : {};
+    const body = this.toBodyBuffer(payload.body);
+    if (body.length > MAX_RELAY_BODY_BYTES) {
+      throw new Error("relay body too large");
+    }
+    const metaPayload = {
+      ...payload
+    };
+    delete metaPayload.body;
+    const meta = Buffer.from(JSON.stringify({
+      id: envelope.id,
+      payload: metaPayload
+    }), "utf8");
+    const header = Buffer.allocUnsafe(4);
+    header.writeUInt32BE(meta.length, 0);
+    return Buffer.concat([header, meta, body]);
+  }
+  toBodyBuffer(body) {
+    if (body === void 0 || body === null) {
+      return Buffer.alloc(0);
+    }
+    if (Buffer.isBuffer(body)) {
+      return body;
+    }
+    if (body instanceof ArrayBuffer) {
+      return Buffer.from(body);
+    }
+    if (ArrayBuffer.isView(body)) {
+      return Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+    }
+    if (typeof body === "string") {
+      return Buffer.from(body, "utf8");
+    }
+    return Buffer.from(JSON.stringify(body), "utf8");
+  }
+  parseBinaryEnvelope(buffer) {
+    const metaLength = buffer.readUInt32BE(0);
+    if (metaLength <= 0 || 4 + metaLength > buffer.length) {
+      return null;
+    }
+    const metaRaw = buffer.subarray(4, 4 + metaLength).toString("utf8");
+    try {
+      const envelope = JSON.parse(metaRaw);
+      if (!(envelope !== null && envelope !== void 0 && envelope.payload)) {
+        return envelope;
+      }
+      const body = buffer.subarray(4 + metaLength);
+      if (body.length > MAX_RELAY_BODY_BYTES) {
+        console.error("Binary tunnel body exceeds size limit");
+        return null;
+      }
+      const payload = envelope.payload;
+      payload.body = body;
+      return envelope;
+    } catch (error) {
+      console.error("Invalid binary tunnel message:", error);
+      return null;
+    }
+  }
+  parseJSONEnvelope(payload) {
+    try {
+      const message = JSON.parse(payload);
+      if (!message) {
+        return null;
+      }
+      return message;
+    } catch (error) {
+      console.error("Invalid tunnel message:", error);
+      return null;
+    }
+  }
+  toBuffer(data) {
+    if (Buffer.isBuffer(data)) {
+      return data;
+    }
+    if (Array.isArray(data)) {
+      return Buffer.concat(data);
+    }
+    if (data instanceof ArrayBuffer) {
+      return Buffer.from(data);
+    }
+    return null;
+  }
+}
+const invokeTunnel = async function(port) {
+  var _options$rebuildWhenE, _options$enableIntern, _hostedTokenResponse$;
+  let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  const {
+    appManifestJSON,
+    appID,
+    regionURL
+  } = await getTunnelContext();
+  const rebuildWhenExists = (_options$rebuildWhenE = options.rebuildWhenExists) !== null && _options$rebuildWhenE !== void 0 ? _options$rebuildWhenE : true;
+  const enableInternalManifestRoute = (_options$enableIntern = options.enableInternalManifestRoute) !== null && _options$enableIntern !== void 0 ? _options$enableIntern : true;
+  const storageScopes = getHostedTokenScopes(appManifestJSON.ones);
+  const scopes = Array.from(/* @__PURE__ */ new Set([...storageScopes, getRelayScope()]));
+  const hostedTokenResponse = await fetchHostedToken({
+    app_id: appID,
+    scopes
+  });
+  const hostedToken = hostedTokenResponse === null || hostedTokenResponse === void 0 || (_hostedTokenResponse$ = hostedTokenResponse.data) === null || _hostedTokenResponse$ === void 0 ? void 0 : _hostedTokenResponse$.hosted_token;
+  if (!hostedToken) {
+    return throwError(ErrorCode.HOSTED_TOKEN_EMPTY, i18n.t("error.hostedToken.empty"));
+  }
+  await setHostToken(hostedToken);
+  const client = new TunnelClient(port, regionURL, appID, hostedToken, enableInternalManifestRoute, rebuildWhenExists);
+  await client.connect();
+};
+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$9(options);
+  const port = Number(normalizedOptions.port);
+  await invokeTunnel(port, {
+    enableInternalManifestRoute: false,
+    rebuildWhenExists: true
+  });
+  const runnelUrl = await buildTunnelUrl();
+  console.log(`Relay endpoint: ${runnelUrl}`);
+};
+const normalize$8 = async (options) => {
+  noop(options);
+  return {};
+};
+const displayAppDetail = async (installationID) => {
+  var _tokenInfo$org$uuid, _tokenInfo$org, _tokenInfo$teams$0$uu, _tokenInfo$teams, _tokenInfo$org$visibi, _tokenInfo$org2;
+  const tokenInfo = await fetchTokenInfo();
+  const orgUUID = (_tokenInfo$org$uuid = (_tokenInfo$org = tokenInfo.org) === null || _tokenInfo$org === void 0 ? void 0 : _tokenInfo$org.uuid) !== null && _tokenInfo$org$uuid !== void 0 ? _tokenInfo$org$uuid : "";
+  const teamUUID = (_tokenInfo$teams$0$uu = (_tokenInfo$teams = tokenInfo.teams) === null || _tokenInfo$teams === void 0 || (_tokenInfo$teams = _tokenInfo$teams[0]) === null || _tokenInfo$teams === void 0 ? void 0 : _tokenInfo$teams.uuid) !== null && _tokenInfo$teams$0$uu !== void 0 ? _tokenInfo$teams$0$uu : "";
+  const isOrgVisible = (_tokenInfo$org$visibi = (_tokenInfo$org2 = tokenInfo.org) === null || _tokenInfo$org2 === void 0 ? void 0 : _tokenInfo$org2.visibility) !== null && _tokenInfo$org$visibi !== void 0 ? _tokenInfo$org$visibi : false;
+  const baseURL = await getBaseURL();
+  if (isOrgVisible && orgUUID) {
+    const url = `${baseURL}project/#/org/${orgUUID}/setting/app_manager/platform_app/${installationID}`;
+    console.log(`See App detail: ${url}`);
+  }
+  if (!isOrgVisible && teamUUID) {
+    const url = `${baseURL}project/#/team/${teamUUID}/team_setting/app_manager/platform_app/${installationID}`;
+    console.log(`See App detail: ${url}`);
+  }
+};
+const invokeInstall = async (manifestUrl) => {
+  const {
+    app
+  } = getAppManifestJSON();
+  const appName = app.name;
+  const appID = app.id;
+  const result = await fetchAppInstall({
+    manifest_url: manifestUrl,
+    options: {
+      enable: true
+    }
+  });
+  if (result.code === "OK") {
+    var _appList$data$0$insta, _appList$data;
+    console.log(`App "${appName}" installed successfully!`);
+    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 : "";
+    if (installationID) {
+      await displayAppDetail(installationID);
+    }
+  } else {
+    console.log(`App "${appName}" installed failed!`);
+    console.error(JSON.stringify(result, null, 2));
+  }
+};
+const getManifestUrl = async () => {
+  const runnelUrl = await buildTunnelUrl();
+  const customManifestUrl = `${runnelUrl}${MANIFEST_PATH}`;
+  const internalManifestUrl = `${runnelUrl}${ONES_CLI_INTERNAL_MANIFEST_PATH}`;
+  const internalResult = await axios.get(internalManifestUrl).then((response) => {
+    if (response.status === 200) {
+      return internalManifestUrl;
+    }
+    return null;
+  }).catch(noop);
+  if (internalResult) {
+    return internalResult;
+  }
+  const customResult = await axios.get(customManifestUrl).then((response) => {
+    if (response.status === 200) {
+      return customManifestUrl;
+    }
+    return null;
+  }).catch(noop);
+  if (customResult) {
+    return customResult;
+  }
+  return null;
+};
+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$8(options);
+  noop(normalizedOptions);
+  const {
+    app
+  } = getAppManifestJSON();
+  const appName = app.name;
+  const manifestUrl = await getManifestUrl();
+  if (!manifestUrl) {
+    console.log(`App "${appName}" server not available!`);
+    console.log('Use "ones dev" command or "ones tunnel" command to start the server first');
+    process.exit(1);
+  }
+  await invokeInstall(manifestUrl);
+};
+var InstallOptions = /* @__PURE__ */ ((InstallOptions2) => {
+  InstallOptions2["AUTO"] = "auto";
+  InstallOptions2["TRUE"] = "true";
+  InstallOptions2["FALSE"] = "false";
+  return InstallOptions2;
+})(InstallOptions || {});
+const defaultInstall = InstallOptions.AUTO;
+const normalize$7 = async (options) => {
+  var _options$install, _options$command;
+  let install2 = (_options$install = options.install) !== null && _options$install !== void 0 ? _options$install : defaultInstall;
+  const command = (_options$command = options.command) !== null && _options$command !== void 0 ? _options$command : "";
+  switch (true) {
+    case install2 === InstallOptions.AUTO:
+      break;
+    case Boolean(install2):
+      install2 = InstallOptions.TRUE;
+      break;
+    default:
+      install2 = InstallOptions.FALSE;
+      break;
+  }
+  return {
+    install: install2,
+    command
+  };
+};
+const IDLE_MS = 2e3;
+function createReadyStatusPipes(onReady) {
+  let readyTimer = null;
+  let summaryPrinted = false;
+  const scheduleReady = () => {
+    if (summaryPrinted)
+      return;
+    if (readyTimer)
+      clearTimeout(readyTimer);
+    readyTimer = setTimeout(() => {
+      readyTimer = null;
+      if (!summaryPrinted) {
+        summaryPrinted = true;
+        onReady();
+      }
+    }, IDLE_MS);
+  };
+  const pipe = (stream, isStderr) => {
+    const write = (chunk) => {
+      if (isStderr)
+        process.stderr.write(chunk);
+      else
+        process.stdout.write(chunk);
+    };
+    stream.on("data", (chunk) => {
+      const str = typeof chunk === "string" ? chunk : chunk.toString();
+      write(str);
+      if (str.startsWith("[backend]") || str.startsWith("[web]")) {
+        scheduleReady();
+      }
+    });
+  };
+  return pipe;
+}
+const dev = async function() {
+  var _appRcJSON$dev, _defaultAppRcJSON$dev, _appRcJSON$dev$comman, _appRcJSON$dev2;
+  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$7(options);
+  const appRcJSON = await getAppRcJSON();
+  const appPackageJSON = getAppPackageJSON();
+  const firstCommand = normalizedOptions.command || ((_appRcJSON$dev = appRcJSON.dev) === null || _appRcJSON$dev === void 0 || (_appRcJSON$dev = _appRcJSON$dev.command) === null || _appRcJSON$dev === void 0 ? void 0 : _appRcJSON$dev[0]) || ((_defaultAppRcJSON$dev = defaultAppRcJSON.dev) === null || _defaultAppRcJSON$dev === void 0 || (_defaultAppRcJSON$dev = _defaultAppRcJSON$dev.command) === null || _defaultAppRcJSON$dev === void 0 ? void 0 : _defaultAppRcJSON$dev[0]) || "";
+  if (!firstCommand) {
+    return throwError(ErrorCode.INCORRECT_DEV_COMMAND, i18n.t("error.dev.incorrectCommand"));
+  }
+  const currentCommand = normalizedOptions.command ? normalizedOptions.command.split(" ") : (_appRcJSON$dev$comman = (_appRcJSON$dev2 = appRcJSON.dev) === null || _appRcJSON$dev2 === void 0 ? void 0 : _appRcJSON$dev2.command) !== null && _appRcJSON$dev$comman !== void 0 ? _appRcJSON$dev$comman : [];
+  const currentCommandString = currentCommand.join(" ");
+  const defaultDevCommandString = defaultDevCommand.join(" ");
+  if (currentCommandString === defaultDevCommandString) {
+    var _appPackageJSON$scrip;
+    if (!((_appPackageJSON$scrip = appPackageJSON.scripts) !== null && _appPackageJSON$scrip !== void 0 && _appPackageJSON$scrip.dev)) {
+      return throwError(ErrorCode.DEV_SCRIPT_NOT_FOUND, i18n.t("error.dev.scriptNotFound"));
+    }
+  }
+  let enableTunnel = true;
+  if (normalizedOptions.install === InstallOptions.TRUE)
+    ;
+  else {
+    enableTunnel = await checkTokenInfo();
+  }
+  const appManifestJSON = getAppManifestJSON();
+  const {
+    app,
+    ones: ones2
+  } = appManifestJSON;
+  const appID = app.id;
+  const config2 = getConfig();
+  const ONES_HOSTED_PORT = await getPort({
+    port: config2.defaultPort.hosted
+  });
+  const ONES_DEV_WEB_SERVER_PORT = await getPort({
+    port: config2.defaultPort.devWebServer
+  });
+  const env2 = {
+    ...process.env,
+    NODE_ENV: "development",
+    ONES_HOSTED_PORT: `${ONES_HOSTED_PORT}`,
+    ONES_DEV_WEB_SERVER_PORT: `${ONES_DEV_WEB_SERVER_PORT}`,
+    ONES_HOSTED_TOKEN: "",
+    ONES_HOSTED_APP_ID: "",
+    ONES_HOSTED_BASE_URL: ""
+  };
+  if (enableTunnel) {
+    var _ones$storage$entitie, _ones$storage;
+    await invokeTunnel(ONES_HOSTED_PORT, {
+      enableInternalManifestRoute: true,
+      rebuildWhenExists: true
+    });
+    const regionURL = await getRegionURL();
+    const ONES_HOSTED_TOKEN = await getHostToken();
+    const ONES_HOSTED_APP_ID = appID;
+    const ONES_HOSTED_BASE_URL = `${regionURL}/platform/runtime_manager`;
+    env2.ONES_HOSTED_TOKEN = ONES_HOSTED_TOKEN;
+    env2.ONES_HOSTED_APP_ID = ONES_HOSTED_APP_ID;
+    env2.ONES_HOSTED_BASE_URL = ONES_HOSTED_BASE_URL;
+    const entities = (_ones$storage$entitie = ones2 === null || ones2 === void 0 || (_ones$storage = ones2.storage) === null || _ones$storage === void 0 ? void 0 : _ones$storage.entities) !== null && _ones$storage$entitie !== void 0 ? _ones$storage$entitie : [];
+    if (entities.length > 0) {
+      await fetchHostedAbilityStorageDevDeclare({
+        app_id: appID,
+        cleanup_legacy: false,
+        opkx_content: appManifestJSON
+      });
+    }
+  }
+  const onReady = async () => {
+    const appName = app.name;
+    let manifestUrl = "";
+    console.log("");
+    console.log(`Local: http://localhost:${ONES_HOSTED_PORT}`);
+    if (enableTunnel) {
+      const runnelUrl = await buildTunnelUrl();
+      console.log(`URL: ${runnelUrl}`);
+      manifestUrl = `${runnelUrl}${ONES_CLI_INTERNAL_MANIFEST_PATH}`;
+    }
+    console.log("Docs site: https://open.ones.com/");
+    console.log(`App "${appName}" server is ready!`);
+    console.log("");
+    if (enableTunnel) {
+      switch (normalizedOptions.install) {
+        case InstallOptions.TRUE:
+          await invokeInstall(manifestUrl);
+          break;
+        case InstallOptions.AUTO:
+          {
+            var _appList$data$0$insta, _appList$data;
+            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 : "";
+            if (installationID) {
+              await displayAppDetail(installationID);
+            } else {
+              await invokeInstall(manifestUrl);
+            }
+          }
+          break;
+        case InstallOptions.FALSE:
+          break;
+      }
+    }
+  };
+  const cwd2 = getAppWorkspacePath();
+  const child = spawn(firstCommand, currentCommand.slice(1), {
+    cwd: cwd2,
+    stdio: ["inherit", "pipe", "pipe"],
+    env: env2,
+    shell: true
+  });
+  const pipe = createReadyStatusPipes(onReady);
+  if (child.stdout)
+    pipe(child.stdout, false);
+  if (child.stderr)
+    pipe(child.stderr, true);
+  const cleanup = () => {
+    child.kill();
+  };
+  const onSignal = () => {
+    cleanup();
+    process.exit(128 + 2);
+  };
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+  await new Promise((resolve2) => {
+    child.on("exit", () => {
+      cleanup();
+      process.off("SIGINT", onSignal);
+      process.off("SIGTERM", onSignal);
+      resolve2();
+    });
+  });
+};
+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$6 = 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$6(options);
+  const base = normalizedOptions.baseURL;
+  const path = "project/oauth2.html";
+  const config2 = getConfig();
+  const port = await getPort({
+    port: config2.defaultPort.login
+  });
+  const uuid = v4();
+  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 logoPath = join(publicPath, "logo.svg");
+  const logo = readFileSync(logoPath, {
+    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");
+    if (state === "logo") {
+      res.writeHead(200, {
+        "Content-Type": "image/svg+xml"
+      });
+      res.end(logo);
+      return;
+    }
+    if (state === "cancel") {
+      res.writeHead(200, {
+        "Content-Type": "image/svg+xml"
+      });
+      res.end(logo);
+      resolve2(null);
+      return;
+    }
+    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);
+      return;
+    }
+    res.writeHead(200, {
+      "Content-Type": "text/html"
+    });
+    res.end("Invalid state error, please try again!");
+  });
+  server.listen(port);
+  promise.then(async (store) => {
+    await sleep(100);
+    server.closeAllConnections();
+    if (store) {
+      var _store$base_url, _store$ones_token, _store$region_url;
+      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!");
+    } else {
+      console.log("Login canceled!");
+    }
+    process$1.exit(0);
+  });
+  console.log("Logging into your ONES account...");
+  console.log(`Opening ${url}`);
+  ora("Waiting for authorization...").start();
+  await open(url);
+};
+const normalize$5 = 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$5(options);
+  noop(normalizedOptions);
+  await setStore({});
+  console.log("Logged out successfully!");
+};
+const normalize$4 = 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$4(options);
+  noop(normalizedOptions);
+  const baseURL = await getBaseURL();
+  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(`User: ${name2}`);
+    console.log(`Email: ${email}`);
+    console.log(`ONES: ${baseURL}`);
+  } else {
+    consoleUnauthorizedMessage();
+  }
+};
+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 appName = getAppManifestJSON().app.name;
+  const result = await fetchAppEnable();
+  if (result.code === "OK") {
+    console.log(`App "${appName}" enabled successfully!`);
+  } else {
+    console.log(`App "${appName}" enabled failed!`);
+    console.error(JSON.stringify(result, null, 2));
+  }
+};
+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 appName = getAppManifestJSON().app.name;
+  const result = await fetchAppDisable();
+  if (result.code === "OK") {
+    console.log(`App "${appName}" disabled successfully!`);
+  } else {
+    console.log(`App "${appName}" disabled failed!`);
+    console.error(JSON.stringify(result, null, 2));
+  }
+};
+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 appName = getAppManifestJSON().app.name;
+  const result = await fetchAppUninstall();
+  if (result.code === "OK") {
+    console.log(`App "${appName}" uninstalled successfully!`);
+  } else {
+    console.log(`App "${appName}" uninstalled failed!`);
+    console.error(JSON.stringify(result, null, 2));
+  }
+};
+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")).option("-c, --command [string]", i18n.t("desc.dev.command")).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");
+const version = `${getPackageJSON().version}`;
+const env = `${version} Node/${process.version}`;
+ones.description(i18n.t("desc.ones", {
+  env
+})).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 version2 = `${getPackageJSON().version}`;
+  command.version(version2, "-v, --version");
+  await command.parse();
+};
+export {
+  runCommandONES
+};