@tego/devkit 1.3.14

package/lib/commands/dev.mjs

@@ -0,0 +1,131 @@
+// src/commands/dev.ts
+import { createRsbuild, loadConfig } from "@rsbuild/core";
+import { getPortPromise } from "portfinder";
+import { nodeCheck, postCheck, promptForTs, run } from "../util.mjs";
+var dev_default = (cli) => {
+  cli.command("dev").option("-p, --port [port]").option("--proxy-port [port]").option("--client").option("--server").option("--rs").option("-w, --wait-server").option("--no-open").option("--db-sync").option("--inspect [port]").allowUnknownOption().action(async (opts) => {
+    promptForTs();
+    const { APP_SERVER_ROOT, APP_CLIENT_ROOT, SERVER_TSCONFIG_PATH } = process.env;
+    process.env.IS_DEV_CMD = true;
+    if (!SERVER_TSCONFIG_PATH) {
+      throw new Error("SERVER_TSCONFIG_PATH is not set.");
+    }
+    if (process.argv.includes("-h") || process.argv.includes("--help")) {
+      run("tsx", [
+        "--tsconfig",
+        SERVER_TSCONFIG_PATH,
+        "-r",
+        "tsconfig-paths/register",
+        `${APP_SERVER_ROOT}/src/index.ts`,
+        ...process.argv.slice(2)
+      ]);
+      return;
+    }
+    const { port, client, server, inspect, rs } = opts;
+    if (port) {
+      process.env.APP_PORT = opts.port;
+    }
+    const { APP_PORT } = process.env;
+    let clientPort = 0;
+    let serverPort = 0;
+    if (APP_PORT) {
+      clientPort = Number(APP_PORT);
+    }
+    nodeCheck();
+    await postCheck(opts);
+    if (server) {
+      serverPort = Number(APP_PORT);
+    } else if (!server && !client) {
+      serverPort = await getPortPromise({
+        port: 1 * clientPort + 10
+      });
+    }
+    if (server || !client) {
+      console.log("starting server", serverPort);
+      const filteredArgs = process.argv.filter(
+        (item, i) => !item.startsWith("--inspect") && !(process.argv[i - 1] === "--inspect" && Number.parseInt(item))
+      );
+      const argv = [
+        "watch",
+        ...inspect ? [`--inspect=${inspect === true ? 9229 : inspect}`] : [],
+        "--ignore=./storage/plugins/**",
+        "--tsconfig",
+        SERVER_TSCONFIG_PATH,
+        "-r",
+        "tsconfig-paths/register",
+        `${APP_SERVER_ROOT}/src/index.ts`,
+        "start",
+        ...filteredArgs.slice(3),
+        `--port=${serverPort}`
+      ];
+      if (opts.dbSync) {
+        argv.push("--db-sync");
+      }
+      const runDevServer = () => {
+        run("tsx", argv, {
+          env: {
+            APP_PORT: serverPort + ""
+          }
+        }).catch((err) => {
+          if (err.exitCode === 100) {
+            console.log("Restarting server...");
+            runDevServer();
+          } else {
+            console.error(err);
+          }
+        });
+      };
+      runDevServer();
+    }
+    if (client || !server) {
+      const runClient = async () => {
+        const getDevEnvironment = (clientPort2, proxyPort2) => ({
+          PORT: clientPort2 + "",
+          NO_OPEN: opts.open ? void 0 : "1",
+          WEBSOCKET_URL: process.env.WEBSOCKET_URL || (proxyPort2 ? `ws://localhost:${proxyPort2}${process.env.WS_PATH}` : void 0),
+          PROXY_TARGET_URL: process.env.PROXY_TARGET_URL || (proxyPort2 ? `http://127.0.0.1:${proxyPort2}` : void 0)
+        });
+        const proxyPort = opts.proxyPort || serverPort || clientPort + 10;
+        console.log("starting client", 1 * clientPort, "proxy port", proxyPort);
+        const env = getDevEnvironment(clientPort, proxyPort);
+        process.env.PORT = env.PORT;
+        process.env.NO_OPEN = env.NO_OPEN;
+        process.env.WEBSOCKET_URL = env.WEBSOCKET_URL;
+        process.env.PROXY_TARGET_URL = env.PROXY_TARGET_URL;
+        process.env.NODE_ENV = "development";
+        const config = await loadConfig({
+          cwd: APP_CLIENT_ROOT
+        });
+        const rsbuild = await createRsbuild({
+          rsbuildConfig: config.content,
+          cwd: APP_CLIENT_ROOT
+        });
+        await rsbuild.startDevServer();
+      };
+      async function runMqServer() {
+        const proxyPort = opts.proxyPort || serverPort || clientPort + 10;
+        const targetUrl = process.env.PROXY_TARGET_URL || (proxyPort ? `http://127.0.0.1:${proxyPort}` : void 0);
+        try {
+          const result = await fetch(`${targetUrl}/api/__health_check`);
+          const res = await result.text();
+          if (res !== "ok") {
+            throw new Error("server not ready");
+          }
+          await runClient();
+        } catch {
+          setTimeout(() => {
+            runMqServer();
+          }, 500);
+        }
+      }
+      if (opts.waitServer) {
+        runMqServer();
+      } else {
+        runClient();
+      }
+    }
+  });
+};
+export {
+  dev_default as default
+};

package/lib/commands/e2e.mjs

@@ -0,0 +1,204 @@
+// src/commands/e2e.ts
+import { execSync } from "node:child_process";
+import { cpus } from "node:os";
+import chalk from "chalk";
+import treeKill from "tree-kill";
+import { isPortReachable, run } from "../util.mjs";
+import { pTest } from "./p-test.mjs";
+var checkServer = async (duration = 1e3, max = 60 * 10) => {
+  return new Promise((resolve, reject) => {
+    let count = 0;
+    const timer = setInterval(async () => {
+      if (count++ > max) {
+        clearInterval(timer);
+        return reject(new Error("Server start timeout."));
+      }
+      const url = `${process.env.APP_BASE_URL}/api/__health_check`;
+      try {
+        const response = await fetch(url);
+        if (response.status === 200) {
+          clearInterval(timer);
+          resolve(true);
+        }
+      } catch (error) {
+        console.error("Request error:", error);
+      }
+    }, duration);
+  });
+};
+var checkUI = async (duration = 1e3, max = 60 * 10) => {
+  return new Promise((resolve, reject) => {
+    let count = 0;
+    const timer = setInterval(async () => {
+      if (count++ > max) {
+        clearInterval(timer);
+        return reject(new Error("UI start timeout."));
+      }
+      try {
+        const response = await fetch(`${process.env.APP_BASE_URL}/__umi/api/bundle-status`);
+        const result = await response.json();
+        if (result === "ok") {
+          clearInterval(timer);
+          resolve(true);
+          return;
+        }
+        if (result.bundleStatus.done) {
+          clearInterval(timer);
+          resolve(true);
+        }
+      } catch (error) {
+        console.error("Request error:", error);
+      }
+    }, duration);
+  });
+};
+async function appReady() {
+  console.log("check server...");
+  await checkServer();
+  console.log("server is ready, check UI...");
+  await checkUI();
+  console.log("UI is ready.");
+}
+async function runApp(options = {}) {
+  console.log("installing...");
+  await run("tachybase", ["install", "-f"]);
+  if (await isPortReachable(process.env.APP_PORT)) {
+    console.log("app started");
+    return;
+  }
+  console.log("starting...");
+  run("tachybase", [process.env.APP_ENV === "production" ? "start" : "dev"], options);
+}
+process.on("SIGINT", async () => {
+  treeKill(process.pid, (error) => {
+    if (error) {
+      console.error(error);
+    } else {
+      console.log(chalk.yellow("Force killing..."));
+    }
+    process.exit();
+  });
+});
+var commonConfig = {
+  stdio: "inherit"
+};
+var runCodegenSync = () => {
+  try {
+    execSync(
+      `npx playwright codegen --load-storage=storage/playwright/.auth/codegen.auth.json ${process.env.APP_BASE_URL} --save-storage=storage/playwright/.auth/codegen.auth.json`,
+      // @ts-ignore
+      commonConfig
+    );
+  } catch (err) {
+    if (err.message.includes("auth.json")) {
+      execSync(
+        `npx playwright codegen ${process.env.APP_BASE_URL} --save-storage=storage/playwright/.auth/codegen.auth.json`,
+        // @ts-ignore
+        commonConfig
+      );
+    } else {
+      console.error(err);
+    }
+  }
+};
+var filterArgv = () => {
+  const arr = process.argv.slice(4);
+  const argv = [];
+  for (let index = 0; index < arr.length; index++) {
+    const element = arr[index];
+    if (element === "--url") {
+      index++;
+      continue;
+    }
+    if (element.startsWith("--url=")) {
+      continue;
+    }
+    if (element === "--skip-reporter") {
+      continue;
+    }
+    if (element === "--build") {
+      continue;
+    }
+    if (element === "--production") {
+      continue;
+    }
+    argv.push(element);
+  }
+  return argv;
+};
+var e2e_default = (cli) => {
+  const e2e = cli.command("e2e").hook("preAction", () => {
+    if (process.env.APP_BASE_URL) {
+      process.env.APP_BASE_URL = process.env.APP_BASE_URL.replace("localhost", "127.0.0.1");
+      console.log("APP_BASE_URL:", process.env.APP_BASE_URL);
+    }
+  });
+  e2e.command("test").allowUnknownOption().option("--url [url]").option("--skip-reporter").option("--build").option("--production").action(async (options) => {
+    process.env.__E2E__ = true;
+    if (options.production) {
+      process.env.APP_ENV = "production";
+    }
+    if (options.build) {
+      process.env.APP_ENV = "production";
+      await run("pnpm", ["build"]);
+    }
+    if (options.skipReporter) {
+      process.env.PLAYWRIGHT_SKIP_REPORTER = true;
+    }
+    if (options.url) {
+      process.env.APP_BASE_URL = options.url.replace("localhost", "127.0.0.1");
+    } else {
+      await runApp({
+        stdio: "ignore"
+      });
+    }
+    await appReady();
+    await run("npx", ["playwright", "test", ...filterArgv()]);
+    process.exit();
+  });
+  e2e.command("codegen").allowUnknownOption().option("--url [url]").action(async (options) => {
+    if (options.url) {
+      process.env.APP_BASE_URL = options.url.replace("localhost", "127.0.0.1");
+    } else {
+      await runApp({
+        stdio: "ignore"
+      });
+    }
+    await appReady();
+    runCodegenSync();
+  });
+  e2e.command("start-app").option("--production").option("--build").option("--port [port]").action(async (options) => {
+    process.env.__E2E__ = true;
+    if (options.build) {
+      await run("pnpm", ["build"]);
+    }
+    if (options.production) {
+      process.env.APP_ENV = "production";
+    }
+    if (options.port) {
+      process.env.APP_PORT = options.port;
+    }
+    runApp();
+  });
+  e2e.command("reinstall-app").action(async (options) => {
+    await run("tachybase", ["install", "-f"], options);
+  });
+  e2e.command("install-deps").action(async () => {
+    await run("npx", ["playwright", "install", "--with-deps"]);
+  });
+  e2e.command("p-test").option("--stop-on-error").option("--build").option("--concurrency [concurrency]", "", cpus().length + "").option(
+    "--match [match]",
+    "Only the files matching one of these patterns are executed as test files. Matching is performed against the absolute file path. Strings are treated as glob patterns.",
+    "packages/**/__e2e__/**/*.test.ts"
+  ).option("--ignore [ignore]", "Skip tests that match the pattern. Strings are treated as glob patterns.", void 0).action(async (options) => {
+    process.env.__E2E__ = true;
+    if (options.build) {
+      process.env.APP_ENV = "production";
+      await run("pnpm", ["build"]);
+    }
+    await pTest({ ...options, concurrency: 1 * options.concurrency });
+  });
+};
+export {
+  e2e_default as default
+};

package/lib/commands/global.mjs

@@ -0,0 +1,23 @@
+// src/commands/global.ts
+import { isDev, isProd, promptForTs, run } from "../util.mjs";
+var global_default = (cli) => {
+  const { APP_SERVER_ROOT, SERVER_TSCONFIG_PATH } = process.env;
+  cli.allowUnknownOption().option("-h, --help").action((options) => {
+    if (isDev()) {
+      promptForTs();
+      run("tsx", [
+        "--tsconfig",
+        SERVER_TSCONFIG_PATH ?? "",
+        "-r",
+        "tsconfig-paths/register",
+        `${APP_SERVER_ROOT}/src/index.ts`,
+        ...process.argv.slice(2)
+      ]);
+    } else if (isProd()) {
+      run("node", [`${APP_SERVER_ROOT}/lib/index.js`, ...process.argv.slice(2)]);
+    }
+  });
+};
+export {
+  global_default as default
+};

package/lib/commands/index.mjs

@@ -0,0 +1,36 @@
+// src/commands/index.ts
+import { generateAppDir } from "../util.mjs";
+import build from "./build.mjs";
+import clean from "./clean.mjs";
+import createNginxConf from "./create-nginx-conf.mjs";
+import createPlugin from "./create-plugin.mjs";
+import dev from "./dev.mjs";
+import e2e from "./e2e.mjs";
+import global from "./global.mjs";
+import init from "./init.mjs";
+import pm2 from "./pm2.mjs";
+import postinstall from "./postinstall.mjs";
+import start from "./start.mjs";
+import tar from "./tar.mjs";
+import test from "./test.mjs";
+import upgrade from "./upgrade.mjs";
+var commands_default = async (cli) => {
+  generateAppDir();
+  global(cli);
+  createNginxConf(cli);
+  build(cli);
+  tar(cli);
+  dev(cli);
+  start(cli);
+  e2e(cli);
+  clean(cli);
+  pm2(cli);
+  test(cli);
+  upgrade(cli);
+  postinstall(cli);
+  createPlugin(cli);
+  init(cli);
+};
+export {
+  commands_default as default
+};

package/lib/commands/init.mjs

@@ -0,0 +1,13 @@
+// src/commands/init.ts
+var init_default = (cli) => {
+  cli.command("init").option("--plugins <list>", "Comma-separated list of plugins to install", (value) => {
+    return value.split(",").map((s) => s.trim()).filter(Boolean);
+  }).argument("[name]", "project name", "my-app").allowUnknownOption().action(async (name, options) => {
+    console.error("\u274C This command has been deprecated.");
+    console.log("\u2705 Please use: npx tego init <project-name>");
+    process.exit(1);
+  });
+};
+export {
+  init_default as default
+};

package/lib/commands/p-test.mjs

@@ -0,0 +1,79 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/commands/p-test.ts
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { parse } from "dotenv";
+import { execa } from "execa";
+import fastGlob from "fast-glob";
+import lodash from "lodash";
+import pAll from "p-all";
+async function runApp(dir, index = 0) {
+  let ENV_FILE = resolve(process.cwd(), ".env.e2e");
+  if (!existsSync(ENV_FILE)) {
+    ENV_FILE = resolve(process.cwd(), ".env.e2e.example");
+  }
+  const data = readFileSync(ENV_FILE, "utf-8");
+  const config = {
+    ...parse(data),
+    ...process.env
+  };
+  index = index * 2;
+  const { Client } = __require("pg");
+  const database = `tachybase${index}`;
+  const client = new Client({
+    host: config["DB_HOST"],
+    port: Number(config["DB_PORT"]),
+    user: config["DB_USER"],
+    password: config["DB_PASSWORD"],
+    database: "postgres"
+  });
+  await client.connect();
+  await client.query(`DROP DATABASE IF EXISTS "${database}"`);
+  await client.query(`CREATE DATABASE "${database}";`);
+  await client.end();
+  return execa("pnpm", ["tachybase", "e2e", "test", dir, "--skip-reporter"], {
+    shell: true,
+    stdio: "inherit",
+    env: {
+      ...config,
+      CI: process.env.CI,
+      __E2E__: "true",
+      APP_BASE_URL: void 0,
+      LOGGER_LEVEL: "error",
+      APP_ENV: "production",
+      APP_PORT: 2e4 + index + "",
+      DB_DATABASE: `tachybase${index}`,
+      SOCKET_PATH: `storage/e2e/gateway-e2e-${index}.sock`,
+      PM2_HOME: resolve(process.cwd(), `storage/e2e/.pm2-${index}`),
+      PLAYWRIGHT_AUTH_FILE: resolve(process.cwd(), `storage/playwright/.auth/admin-${index}.json`)
+    }
+  });
+}
+async function pTest(options) {
+  const dir = resolve(process.cwd(), "storage/e2e");
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  const files = fastGlob.sync(options.match, {
+    ignore: options.ignore,
+    // @ts-ignore
+    root: process.cwd()
+  });
+  const commands = splitArrayIntoParts(lodash.shuffle(files), options.concurrency || 4).map((v, i) => {
+    return () => runApp(v.join(" "), i);
+  });
+  await pAll(commands, { concurrency: 4, stopOnError: false, ...options });
+}
+function splitArrayIntoParts(array, parts) {
+  const chunkSize = Math.ceil(array.length / parts);
+  return lodash.chunk(array, chunkSize);
+}
+export {
+  pTest
+};

package/lib/commands/pm2.mjs

@@ -0,0 +1,16 @@
+// src/commands/pm2.ts
+import { run } from "../util.mjs";
+var pm2_default = (cli) => {
+  cli.command("pm2").allowUnknownOption().action(() => {
+    run("pm2", process.argv.slice(3));
+  });
+  cli.command("pm2-restart").allowUnknownOption().action(() => {
+    run("pm2", ["restart", "all"]);
+  });
+  cli.command("pm2-stop").allowUnknownOption().action(() => {
+    run("pm2", ["stop", "all"]);
+  });
+};
+export {
+  pm2_default as default
+};

package/lib/commands/postinstall.mjs

@@ -0,0 +1,25 @@
+// src/commands/postinstall.ts
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { generatePlaywrightPath, isDev } from "../util.mjs";
+var postinstall_default = (cli) => {
+  cli.command("postinstall").allowUnknownOption().action(async () => {
+    generatePlaywrightPath(true);
+    if (!isDev()) {
+      return;
+    }
+    const cwd = process.cwd();
+    if (!existsSync(resolve(cwd, ".env")) && existsSync(resolve(cwd, ".env.example"))) {
+      const content = await readFile(resolve(cwd, ".env.example"), "utf-8");
+      await writeFile(resolve(cwd, ".env"), content, "utf-8");
+    }
+    if (!existsSync(resolve(cwd, ".env.test")) && existsSync(resolve(cwd, ".env.test.example"))) {
+      const content = await readFile(resolve(cwd, ".env.test.example"), "utf-8");
+      await writeFile(resolve(cwd, ".env.test"), content, "utf-8");
+    }
+  });
+};
+export {
+  postinstall_default as default
+};

package/lib/commands/start.mjs

@@ -0,0 +1,50 @@
+// src/commands/start.ts
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import chalk from "chalk";
+import { postCheck, promptForTs, run } from "../util.mjs";
+var start_default = (cli) => {
+  const { APP_SERVER_ROOT, NODE_ARGS } = process.env;
+  cli.command("start").option("-p, --port [port]").option("-d, --daemon").option("-i, --instances [number]").option("--db-sync").option("--quickstart").allowUnknownOption().action(async (opts) => {
+    if (opts.port) {
+      process.env.APP_PORT = opts.port;
+    }
+    if (process.argv.includes("-h") || process.argv.includes("--help")) {
+      promptForTs();
+      run("tsx", [
+        "--tsconfig",
+        process.env.SERVER_TSCONFIG_PATH ?? "",
+        "-r",
+        "tsconfig-paths/register",
+        `${APP_SERVER_ROOT}/src/index.ts`,
+        ...process.argv.slice(2)
+      ]);
+      return;
+    }
+    if (!existsSync(resolve(process.cwd(), `${APP_SERVER_ROOT}/lib/index.js`))) {
+      console.log("The code is not compiled, please execute it first");
+      console.log(chalk.yellow("$ pnpm build"));
+      console.log("If you want to run in development mode, please execute");
+      console.log(chalk.yellow("$ pnpm dev"));
+      return;
+    }
+    await postCheck(opts);
+    if (opts.daemon) {
+      run("pm2", ["start", `${APP_SERVER_ROOT}/lib/index.js`, "--", ...process.argv.slice(2)]);
+    } else {
+      run(
+        "pm2-runtime",
+        [
+          "start",
+          `${APP_SERVER_ROOT}/lib/index.js`,
+          NODE_ARGS ? `--node-args="${NODE_ARGS}"` : "",
+          "--",
+          ...process.argv.slice(2)
+        ].filter(Boolean)
+      );
+    }
+  });
+};
+export {
+  start_default as default
+};

package/lib/commands/tar.mjs

@@ -0,0 +1,15 @@
+// src/commands/tar.ts
+import { TachybaseBuilder } from "../builder/index.mjs";
+import { nodeCheck } from "../util.mjs";
+var tar_default = (cli) => {
+  cli.command("tar").allowUnknownOption().argument("[packages...]").action(async (pkgs) => {
+    nodeCheck();
+    const tachybaseBuilder = new TachybaseBuilder({
+      onlyTar: true
+    });
+    await tachybaseBuilder.build(pkgs);
+  });
+};
+export {
+  tar_default as default
+};

package/lib/commands/test.mjs

@@ -0,0 +1,70 @@
+// src/commands/test.ts
+import { sep } from "node:path";
+import { run } from "../util.mjs";
+function addTestCommand(name, cli) {
+  return cli.command(name).option("-w, --watch").option("--run").option("--allowOnly").option("--bail").option("-h, --help").option("--single-thread [singleThread]").arguments("[paths...]").allowUnknownOption().action(async (paths, opts) => {
+    process.argv.push("--disable-console-intercept");
+    if (name === "test:server") {
+      process.env.TEST_ENV = "server-side";
+    } else if (name === "test:client") {
+      process.env.TEST_ENV = "client-side";
+    }
+    if (opts.server) {
+      process.env.TEST_ENV = "server-side";
+      process.argv.splice(process.argv.indexOf("--server"), 1);
+    }
+    if (opts.client) {
+      process.env.TEST_ENV = "client-side";
+      process.argv.splice(process.argv.indexOf("--client"), 1);
+    }
+    process.env.NODE_ENV = "test";
+    if (!opts.watch && !opts.run) {
+      process.argv.push("--run");
+    }
+    const first = paths?.[0];
+    if (!process.env.TEST_ENV && first) {
+      const key = first.split(sep).join("/");
+      if (key.includes("/client/")) {
+        process.env.TEST_ENV = "client-side";
+      } else {
+        process.env.TEST_ENV = "server-side";
+      }
+    }
+    if (process.env.TEST_ENV === "server-side" && opts.singleThread !== "false") {
+      process.argv.push("--poolOptions.threads.singleThread=true");
+    }
+    if (opts.singleThread === "false") {
+      process.argv.splice(process.argv.indexOf("--single-thread=false"), 1);
+    }
+    const cliArgs = ["--max_old_space_size=14096", "./node_modules/.bin/vitest", ...process.argv.slice(3)];
+    if (process.argv.includes("-h") || process.argv.includes("--help")) {
+      await run("node", cliArgs);
+      return;
+    }
+    if (process.env.TEST_ENV) {
+      console.log("process.env.TEST_ENV", process.env.TEST_ENV, cliArgs);
+      await run("node", cliArgs);
+    } else {
+      await Promise.all([
+        run("node", cliArgs, {
+          env: {
+            TEST_ENV: "client-side"
+          }
+        }),
+        run("node", cliArgs, {
+          env: {
+            TEST_ENV: "server-side"
+          }
+        })
+      ]);
+    }
+  });
+}
+var test_default = (cli) => {
+  addTestCommand("test:server", cli);
+  addTestCommand("test:client", cli);
+  addTestCommand("test", cli).option("--client").option("--server");
+};
+export {
+  test_default as default
+};

package/lib/commands/upgrade.mjs

@@ -0,0 +1,13 @@
+// src/commands/upgrade.ts
+import { hasTsNode, promptForTs, runAppCommand } from "../util.mjs";
+var upgrade_default = (cli) => {
+  cli.command("upgrade").allowUnknownOption().option("--raw").option("-S|--skip-code-update").action(async (options) => {
+    if (hasTsNode()) {
+      promptForTs();
+    }
+    await runAppCommand("upgrade");
+  });
+};
+export {
+  upgrade_default as default
+};