@tego/devkit 1.3.52 → 1.3.54-alpha.0

package/lib/commands/build.mjs

@@ -1,9 +1,7 @@
 // src/commands/build.ts
 import { TachybaseBuilder } from "../builder/index.mjs";
-import { nodeCheck } from "../util.mjs";
 var build_default = (cli) => {
   cli.command("build").allowUnknownOption().argument("[packages...]").option("-r, --retry", "retry the last failed package").option("-s, --sourcemap", "generate server sourcemap").option("--no-dts", "not generate dts").option("--tar", "tar the package").option("--only-tar", "only tar the package").option("--development", "development mode").action(async (pkgs, options) => {
-    nodeCheck();
     const tachybaseBuilder = new TachybaseBuilder({
       dts: options.dts,
       sourcemap: options.sourcemap,

package/lib/commands/clean.mjs

@@ -1,12 +1,8 @@
 // src/commands/clean.ts
 import { rimrafSync } from "rimraf";
-import { isDev } from "../util.mjs";
 var clean_default = (cli) => {
   cli.command("clean").option("--all").allowUnknownOption().action((opts) => {
-    if (!isDev()) {
-      return;
-    }
-    rimrafSync("{packages}/*/{lib,esm,es,dist,node_modules}", { glob: true });
+    rimrafSync("packages/*/{lib,esm,es,dist,node_modules}", { glob: true });
     if (opts.all) {
       rimrafSync("node_modules", { glob: true });
     }

package/lib/commands/dev.mjs

@@ -1,15 +1,108 @@
 // src/commands/dev.ts
+import fs from "fs";
+import path from "path";
+import { confirm, input, select } from "@inquirer/prompts";
 import { createRsbuild, loadConfig } from "@rsbuild/core";
 import { getPortPromise } from "portfinder";
-import { nodeCheck, postCheck, promptForTs, run } from "../util.mjs";
+import simpleGit from "simple-git";
+import { fsExists, postCheck, promptForTs, run, runAppCommand } from "../util.mjs";
+async function prepare() {
+  const git = simpleGit();
+  const branch = (await git.branch()).current;
+  let runtime = branch.replace(/\//g, "__");
+  let runtimeDir = path.resolve(process.env.TEGO_HOME, runtime);
+  let settingsFile = path.join(runtimeDir, "settings.js");
+  console.log(process.env.TEGO_HOME);
+  const result = [];
+  const rootDir = process.env.TEGO_HOME;
+  let runtimeIncludes = false;
+  for (const entry of fs.readdirSync(rootDir)) {
+    const fullPath = path.join(rootDir, entry);
+    if (fs.statSync(fullPath).isDirectory()) {
+      const settingsPath = path.join(fullPath, "settings.js");
+      if (fs.existsSync(settingsPath)) {
+        if (fullPath === runtimeDir) {
+          runtimeIncludes = true;
+        }
+        result.push(entry);
+      }
+    }
+  }
+  if (fs.existsSync(path.join(process.cwd(), "storage"))) {
+    result.push(process.cwd());
+  }
+  if (!runtimeIncludes) {
+    result.push("\u4EE5\u5F53\u524D\u5206\u652F\u521B\u5EFA\u76EE\u5F55");
+  }
+  result.push("\u521B\u5EFA\u65B0\u7684\u914D\u7F6E\u76EE\u5F55\uFF0C\u8BF7\u6307\u5B9A");
+  const selected = await select({
+    message: "\u8BF7\u9009\u62E9\u4E00\u4E2A\u76EE\u5F55",
+    default: runtimeIncludes ? runtime : process.cwd(),
+    choices: result.map((item) => ({
+      name: item,
+      value: item
+    }))
+  });
+  if (selected === runtime) {
+    process.env.TEGO_RUNTIME_NAME = runtime;
+    process.env.TEGO_RUNTIME_HOME = runtimeDir;
+    return;
+  } else if (selected === "\u521B\u5EFA\u65B0\u7684\u914D\u7F6E\u76EE\u5F55\uFF0C\u8BF7\u6307\u5B9A") {
+    runtime = await input({
+      message: "\u8BF7\u8F93\u5165\u65B0\u7684\u914D\u7F6E\u76EE\u5F55"
+    });
+    if (!runtime) {
+      console.log("\u8BF7\u8F93\u5165\u65B0\u7684\u914D\u7F6E\u76EE\u5F55");
+      process.exit(1);
+    }
+    runtimeDir = path.resolve(process.env.TEGO_HOME, runtime);
+    settingsFile = path.join(runtimeDir, "settings.js");
+  } else if (selected === "\u4EE5\u5F53\u524D\u5206\u652F\u521B\u5EFA\u76EE\u5F55") {
+  } else if (selected === process.cwd()) {
+    process.env.TEGO_RUNTIME_NAME = "__NO_RUNTIME_NAME__";
+    process.env.TEGO_RUNTIME_HOME = process.cwd();
+  } else {
+    process.env.TEGO_RUNTIME_NAME = selected;
+    process.env.TEGO_RUNTIME_HOME = path.join(process.env.TEGO_HOME, selected);
+    return;
+  }
+  if (!fs.existsSync(settingsFile)) {
+    const answer = await confirm({
+      message: `\u73AF\u5883 "${runtime}" \u5C1A\u672A\u521D\u59CB\u5316\uFF0C\u662F\u5426\u8981\u521D\u59CB\u5316\uFF1F`,
+      default: true
+    });
+    if (!answer) {
+      console.log("\u5DF2\u53D6\u6D88\u521D\u59CB\u5316");
+      process.exit(1);
+    }
+    process.env.TEGO_RUNTIME_NAME = runtime;
+    process.env.TEGO_RUNTIME_HOME = runtimeDir;
+    await runAppCommand("init", []);
+    const ok = await confirm({
+      message: `\u8BF7\u4FEE\u6539 ${settingsFile}\uFF0C\u8C03\u6574\u76F8\u5173\u914D\u7F6E\uFF0C\u786E\u8BA4\u540E\u4E0B\u4E00\u6B65`,
+      default: true
+    });
+    if (!ok) {
+      console.log("\u8BF7\u5B8C\u6210\u4FEE\u6539\u540E\u518D\u8FD0\u884C pnpm dev");
+      process.exit(1);
+    }
+    await runAppCommand("install", ["-f"]);
+  }
+}
 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) => {
+  cli.command("dev").option("--no-prepare", "skip prepare").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.");
     }
+    try {
+      if (opts.prepare) {
+        await prepare();
+      }
+    } catch (error) {
+      process.exit(1);
+    }
     if (process.argv.includes("-h") || process.argv.includes("--help")) {
       run("tsx", [
         "--tsconfig",
@@ -31,7 +124,6 @@ var dev_default = (cli) => {
     if (APP_PORT) {
       clientPort = Number(APP_PORT);
     }
-    nodeCheck();
     await postCheck(opts);
     if (server) {
       serverPort = Number(APP_PORT);
@@ -78,6 +170,9 @@ var dev_default = (cli) => {
       runDevServer();
     }
     if (client || !server) {
+      if (!APP_CLIENT_ROOT || !await fsExists(APP_CLIENT_ROOT)) {
+        return;
+      }
       const runClient = async () => {
         const getDevEnvironment = (clientPort2, proxyPort2) => ({
           PORT: clientPort2 + "",

package/lib/commands/global.mjs

@@ -1,21 +1,17 @@
 // src/commands/global.ts
-import { isDev, isProd, promptForTs, run } from "../util.mjs";
+import { 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)]);
-    }
+    promptForTs();
+    run("tsx", [
+      "--tsconfig",
+      SERVER_TSCONFIG_PATH ?? "",
+      "-r",
+      "tsconfig-paths/register",
+      `${APP_SERVER_ROOT}/src/index.ts`,
+      ...process.argv.slice(2)
+    ]);
   });
 };
 export {

package/lib/commands/index.mjs

@@ -10,7 +10,7 @@ import global from "./global.mjs";
 import install from "./install.mjs";
 import postinstall from "./postinstall.mjs";
 import tar from "./tar.mjs";
-import test from "./test.mjs";
+import ui from "./ui.mjs";
 import upgrade from "./upgrade.mjs";
 var commands_default = async (cli) => {
   generateAppDir();
@@ -19,9 +19,9 @@ var commands_default = async (cli) => {
   build(cli);
   tar(cli);
   dev(cli);
+  ui(cli);
   e2e(cli);
   clean(cli);
-  test(cli);
   upgrade(cli);
   install(cli);
   postinstall(cli);

package/lib/commands/install.mjs

@@ -1,11 +1,8 @@
 // src/commands/install.ts
-import { hasTsNode, promptForTs, runAppCommand } from "../util.mjs";
+import { promptForTs, runAppCommand } from "../util.mjs";
 var install_default = (cli) => {
-  cli.command("install").allowUnknownOption().option("--raw").option("-S|--skip-code-update").action(async (options) => {
-    if (hasTsNode()) {
-      promptForTs();
-    }
-    process.env.IS_DEV_CMD = "true";
+  cli.command("install").allowUnknownOption().action(async (options) => {
+    promptForTs();
     await runAppCommand("install", process.argv.slice(2));
   });
 };

package/lib/commands/p-test.mjs

@@ -45,7 +45,6 @@ async function runApp(dir, index = 0) {
       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}`,

package/lib/commands/postinstall.mjs

@@ -1,23 +1,8 @@
 // src/commands/postinstall.ts
-import { existsSync } from "fs";
-import { readFile, writeFile } from "fs/promises";
-import { resolve } from "path";
-import { generatePlaywrightPath, isDev } from "../util.mjs";
+import { generatePlaywrightPath } 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 {

package/lib/commands/tar.mjs

@@ -1,9 +1,7 @@
 // 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
     });

package/lib/commands/ui.mjs

@@ -0,0 +1,160 @@
+// src/commands/ui.ts
+import { createRequire } from "module";
+import { confirm, input } from "@inquirer/prompts";
+import { execa } from "execa";
+var require2 = createRequire(import.meta.url);
+var term = require2("terminal-kit").terminal;
+var ui_default = (cli) => {
+  cli.command("ui").action(async () => {
+    const DEFAULTS = {
+      inspect: false,
+      port: 3e3,
+      dbSync: false
+    };
+    let proc;
+    let opts = { ...DEFAULTS };
+    let mouseEnabled = false;
+    let logLines = [];
+    let scrollPos = 0;
+    console.log(term);
+    function draw() {
+      term.clear();
+      const width = term.width;
+      const height = term.height;
+      const logHeight = height - 2;
+      for (let i = 0; i < logHeight; i++) {
+        const line = logLines[scrollPos + i] ?? "";
+        term.moveTo(1, 1 + i);
+        term.eraseLine();
+        term(line);
+      }
+      term.moveTo(1, height - 1);
+      term.gray("\u2500".repeat(width));
+      term.moveTo(1, height);
+      term.cyan("tegod> ");
+    }
+    function log(txt) {
+      txt.split("\n").forEach((l) => {
+        logLines.push(l);
+      });
+      scrollPos = Math.max(0, logLines.length - (term.height - 2));
+      draw();
+    }
+    function startProc() {
+      const args = [
+        "watch",
+        ...opts.inspect ? [`--inspect=${opts.inspect === true ? 9229 : opts.inspect}`] : [],
+        "--ignore=./storage/plugins/**",
+        "--tsconfig",
+        process.env.SERVER_TSCONFIG_PATH,
+        "-r",
+        "tsconfig-paths/register",
+        `${process.env.APP_SERVER_ROOT}/src/index.ts`,
+        "start",
+        `--port=${opts.port}`
+      ];
+      if (opts.dbSync) args.push("--db-sync");
+      log(`[dev] starting ${args.join(" ")}`);
+      proc = execa("node", ["./node_modules/tsx/dist/cli.mjs", ...args], {
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: true,
+        env: { ...process.env, APP_PORT: String(opts.port), FORCE_COLOR: "1" }
+      });
+      proc.stdout?.on("data", (d) => log(d.toString()));
+      proc.stderr?.on("data", (d) => log(d.toString()));
+      proc.on("exit", (code) => {
+        if (code === 100) {
+          log("[dev] exited 100, restarting...");
+          startProc();
+        } else {
+          log(`[dev] exited (${code})`);
+        }
+      });
+    }
+    async function handleCommand(cmd) {
+      cmd = cmd.trim();
+      if (cmd === "restart") {
+        log("[dev] restarting...");
+        proc?.kill();
+        startProc();
+      } else if (cmd === "exit") {
+        proc?.kill();
+        process.exit(0);
+      } else if (cmd === "help") {
+        log("Commands: restart, setup, help, exit, togglemouse");
+      } else if (cmd === "setup") {
+        const port = await input({ message: "Server port", default: String(opts.port) });
+        const inspect = await confirm({ message: "Enable inspect?", default: Boolean(opts.inspect) });
+        const dbSync = await confirm({ message: "Enable dbSync?", default: opts.dbSync });
+        opts = { port: Number(port), inspect: inspect ? 9229 : false, dbSync };
+        log("[setup] updated config. restarting...");
+        proc?.kill();
+        startProc();
+      } else if (cmd === "togglemouse") {
+        mouseEnabled = !mouseEnabled;
+        log(`[info] mouse support ${mouseEnabled ? "enabled" : "disabled"}`);
+      } else {
+        log(`[unknown] ${cmd}`);
+      }
+    }
+    draw();
+    startProc();
+    const onMouse = (name, data) => {
+      if (name === "MOUSE_WHEEL_UP") {
+        scrollPos = Math.max(0, scrollPos - 1);
+      }
+      if (name === "MOUSE_WHEEL_DOWN") {
+        scrollPos = Math.min(Math.max(0, logLines.length - (term.height - 2)), scrollPos + 1);
+      }
+      draw();
+    };
+    function toggleMouse() {
+      mouseEnabled = !mouseEnabled;
+      if (mouseEnabled) {
+        term.grabInput({ mouse: "motion" });
+        term.on("mouse", onMouse);
+        log("[info] Mouse wheel scroll enabled");
+      } else {
+        term.grabInput({ mouse: "off" });
+        term.off("mouse", onMouse);
+        log("[info] Mouse wheel scroll disabled");
+      }
+      draw();
+    }
+    term.grabInput({ mouse: "motion" });
+    term.on("key", async (name, matches, data) => {
+      log(`[DEBUG] ${name}`);
+      if (name === "CTRL_L") {
+        toggleMouse();
+      }
+      if (name === "PAGE_UP") {
+        scrollPos = Math.max(0, scrollPos - 3);
+        draw();
+      }
+      if (name === "PAGE_DOWN") {
+        scrollPos = Math.min(Math.max(0, logLines.length - (term.height - 2)), scrollPos + 3);
+        draw();
+      }
+      if (name === "CTRL_C") {
+        proc?.kill();
+        term.processExit();
+      }
+    });
+    async function inputLoop() {
+      term.moveTo("tegod> ".length + 1, term.height);
+      term.inputField(
+        { cancelable: true, autoComplete: ["exit", "restart", "setup", "help", "exit", "togglemouse"] },
+        async (err, value) => {
+          if (value !== void 0) {
+            await handleCommand(value);
+          }
+          inputLoop();
+        }
+      );
+    }
+    inputLoop();
+  });
+};
+export {
+  ui_default as default
+};

package/lib/commands/upgrade.mjs

@@ -1,11 +1,8 @@
 // src/commands/upgrade.ts
-import { hasTsNode, promptForTs, runAppCommand } from "../util.mjs";
+import { 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();
-    }
-    process.env.IS_DEV_CMD = "true";
+  cli.command("upgrade").allowUnknownOption().action(async (options) => {
+    promptForTs();
     await runAppCommand("upgrade");
   });
 };

package/lib/util.mjs

@@ -1,29 +1,21 @@
 // src/util.ts
-import { createHash } from "crypto";
 import {
   cpSync as _cpSync,
   existsSync as _existsSync,
   writeFileSync as _writeFileSync,
-  createWriteStream,
-  existsSync,
   readFileSync,
   rmSync,
-  symlinkSync,
-  unlinkSync,
   writeFileSync
 } from "fs";
-import { mkdir, readFile, stat, unlink, writeFile } from "fs/promises";
+import { readFile, stat, writeFile } from "fs/promises";
 import { createRequire } from "module";
 import { Socket } from "net";
 import os from "os";
 import { dirname, join, resolve, sep } from "path";
-import { pipeline } from "stream/promises";
 import chalk from "chalk";
 import { config } from "dotenv";
 import { execa } from "execa";
 import fastGlob from "fast-glob";
-import packageJson from "package-json";
-import * as tar from "tar";
 import { DEFAULT_DEV_HOST } from "./constants.mjs";
 var require2 = createRequire(import.meta.url);
 async function fsExists(path) {
@@ -34,72 +26,7 @@ async function fsExists(path) {
     return false;
   }
 }
-function isPackageValid(pkg) {
-  try {
-    require2.resolve(pkg);
-    return true;
-  } catch (error) {
-    return false;
-  }
-}
-async function downloadTar(packageName, target) {
-  const info = await packageJson(packageName, { fullMetadata: true });
-  const url = info.dist.tarball;
-  const tarballFile = join(target, "..", `${createHash("md5").update(packageName).digest("hex")}-tarball.gz`);
-  await mkdir(dirname(tarballFile), { recursive: true });
-  const writer = createWriteStream(tarballFile);
-  const response = await fetch(url);
-  if (!response.ok || !response.body) {
-    throw new Error(`Failed to fetch tarball: ${response.statusText}`);
-  }
-  await pipeline(response.body, writer);
-  await mkdir(target, { recursive: true });
-  await tar.x({
-    file: tarballFile,
-    gzip: true,
-    cwd: target,
-    strip: 1,
-    k: true
-  });
-  await unlink(tarballFile);
-}
-function hasCorePackages() {
-  const coreDir = resolve(process.cwd(), "apps/build");
-  return existsSync(coreDir);
-}
-function hasTsNode() {
-  return isPackageValid("tsx");
-}
-function isDev() {
-  if (process.env.APP_ENV === "production") {
-    return false;
-  }
-  return hasTsNode();
-}
-var isProd = () => {
-  const { APP_SERVER_ROOT } = process.env;
-  const file = `${APP_SERVER_ROOT}/lib/index.js`;
-  if (!existsSync(resolve(process.cwd(), file))) {
-    console.log("For production environment, please build the code first.");
-    console.log();
-    console.log(chalk.yellow("$ pnpm build"));
-    console.log();
-    process.exit(1);
-  }
-  return true;
-};
-function nodeCheck() {
-  if (!hasTsNode()) {
-    console.log("Please install all dependencies");
-    console.log(chalk.yellow("$ pnpm install"));
-    process.exit(1);
-  }
-}
 function run(command, args, options) {
-  if (command === "tsx") {
-    command = "node";
-    args = ["./node_modules/tsx/dist/cli.mjs"].concat(args || []);
-  }
   return execa(command, args, {
     shell: true,
     stdio: "inherit",
@@ -142,48 +69,49 @@ async function postCheck(opts) {
     process.exit(1);
   }
 }
+async function runWithTsx(argv, options) {
+  try {
+    await run("tsx", argv, options);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      const tsxCliPath = require2.resolve("tsx/dist/cli.mjs");
+      await run("node", [tsxCliPath, ...argv], options);
+    } else {
+      throw error;
+    }
+  }
+}
 async function runInstall() {
   const { APP_SERVER_ROOT, SERVER_TSCONFIG_PATH } = process.env;
   if (!SERVER_TSCONFIG_PATH) {
     throw new Error("SERVER_TSCONFIG_PATH is empty.");
   }
-  if (isDev()) {
-    const argv = [
-      "--tsconfig",
-      SERVER_TSCONFIG_PATH,
-      "-r",
-      "tsconfig-paths/register",
-      `${APP_SERVER_ROOT}/src/index.ts`,
-      "install",
-      "-s"
-    ];
-    await run("tsx", argv);
-  } else if (isProd()) {
-    const file = `${APP_SERVER_ROOT}/lib/index.js`;
-    const argv = [file, "install", "-s"];
-    await run("node", argv);
-  }
+  const argv = [
+    "--tsconfig",
+    SERVER_TSCONFIG_PATH,
+    "-r",
+    "tsconfig-paths/register",
+    `${APP_SERVER_ROOT}/src/index.ts`,
+    "install",
+    "-s"
+  ];
+  await runWithTsx(argv);
 }
 async function runAppCommand(command, args = []) {
   const { APP_SERVER_ROOT, SERVER_TSCONFIG_PATH } = process.env;
   if (!SERVER_TSCONFIG_PATH) {
     throw new Error("SERVER_TSCONFIG_PATH is not set");
   }
-  if (isDev()) {
-    const argv = [
-      "--tsconfig",
-      SERVER_TSCONFIG_PATH,
-      "-r",
-      "tsconfig-paths/register",
-      `${APP_SERVER_ROOT}/src/index.ts`,
-      command,
-      ...args
-    ];
-    await run("tsx", argv);
-  } else if (isProd()) {
-    const argv = [`${APP_SERVER_ROOT}/lib/index.js`, command, ...args];
-    await run("node", argv);
-  }
+  const argv = [
+    "--tsconfig",
+    SERVER_TSCONFIG_PATH,
+    "-r",
+    "tsconfig-paths/register",
+    `${APP_SERVER_ROOT}/src/index.ts`,
+    command,
+    ...args
+  ];
+  await runWithTsx(argv);
 }
 function promptForTs() {
   console.log(chalk.green("WAIT: ") + "TypeScript compiling...");
@@ -200,15 +128,6 @@ function generateAppDir() {
   process.env.APP_CLIENT_ROOT = process.env.APP_CLIENT_ROOT || defaultClientRoot;
 }
 async function genTsConfigPaths() {
-  try {
-    unlinkSync(resolve(process.cwd(), "node_modules/.bin/tsx"));
-    symlinkSync(
-      resolve(process.cwd(), "node_modules/tsx/dist/cli.mjs"),
-      resolve(process.cwd(), "node_modules/.bin/tsx"),
-      "file"
-    );
-  } catch (error) {
-  }
   const cwd = process.cwd();
   const cwdLength = cwd.length;
   const paths = {};
@@ -251,17 +170,6 @@ function generatePlaywrightPath(clean = false) {
   } catch (error) {
   }
 }
-function parseEnv(name) {
-  if (name === "DB_UNDERSCORED") {
-    if (process.env.DB_UNDERSCORED === "true") {
-      return "true";
-    }
-    if (process.env.DB_UNDERSCORED) {
-      return "true";
-    }
-    return "false";
-  }
-}
 function initEnv() {
   const env = {
     APP_ENV: "development",
@@ -269,9 +177,7 @@ function initEnv() {
     APP_PORT: 3e3,
     API_BASE_PATH: "/api/",
     DB_DIALECT: "sqlite",
-    DB_STORAGE: "storage/db/tachybase.sqlite",
     DB_TIMEZONE: "+00:00",
-    DB_UNDERSCORED: parseEnv("DB_UNDERSCORED"),
     DEFAULT_STORAGE_TYPE: "local",
     LOCAL_STORAGE_DEST: "storage/uploads",
     PLUGIN_STORAGE_PATH: "storage/plugins",
@@ -281,14 +187,12 @@ function initEnv() {
     PLUGIN_PACKAGE_PREFIX: "@tachybase/plugin-,@tachybase/module-",
     SERVER_TSCONFIG_PATH: "./tsconfig.server.json",
     PLAYWRIGHT_AUTH_FILE: "storage/playwright/.auth/admin.json",
-    CACHE_DEFAULT_STORE: "memory",
-    CACHE_MEMORY_MAX: 2e3,
     PLUGIN_STATICS_PATH: "/static/plugins/",
-    LOGGER_BASE_PATH: "storage/logs",
     APP_SERVER_BASE_URL: "",
     APP_PUBLIC_PATH: "/",
     TEGO_HOME: join(os.homedir(), ".tego"),
-    TEGO_RUNTIME_NAME: "current"
+    TEGO_RUNTIME_NAME: "current",
+    IS_DEV_CMD: "1"
   };
   if (!process.env.APP_ENV_PATH && process.argv[2] && ["test", "test:client", "test:server"].includes(process.argv[2])) {
     if (_existsSync(resolve(process.cwd(), ".env.test"))) {
@@ -354,20 +258,13 @@ var castArray = (arr) => {
 };
 export {
   castArray,
-  downloadTar,
   fsExists,
   genTsConfigPaths,
   generateAppDir,
   generatePlaywrightPath,
   getHostInUrl,
-  hasCorePackages,
-  hasTsNode,
   initEnv,
-  isDev,
-  isPackageValid,
   isPortReachable,
-  isProd,
-  nodeCheck,
   postCheck,
   promptForTs,
   run,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tego/devkit",
-  "version": "1.3.52",
+  "version": "1.3.54-alpha.0",
   "description": "",
   "license": "Apache-2.0",
   "type": "module",
@@ -8,7 +8,7 @@
     ".": "./lib/index.mjs"
   },
   "bin": {
-    "tachybase": "./bin/cli.js"
+    "tegod": "./bin/cli.js"
   },
   "files": [
     "assets",
@@ -19,39 +19,44 @@
   ],
   "dependencies": {
     "@hapi/topo": "^6.0.2",
-    "@npmcli/arborist": "^9.1.3",
+    "@inquirer/prompts": "^7.8.6",
+    "@npmcli/arborist": "^9.1.4",
     "@pnpm/workspace.find-packages": "^1.1.12",
-    "@rsbuild/core": "^1.4.12",
-    "@rsbuild/plugin-less": "^1.3.1",
-    "@rsbuild/plugin-react": "^1.3.4",
-    "@rslib/core": "^0.11.0",
+    "@rsbuild/core": "^1.5.10",
+    "@rsbuild/plugin-less": "^1.5.0",
+    "@rsbuild/plugin-react": "^1.3.5",
+    "@rslib/core": "^0.13.2",
     "@types/fs-extra": "^11.0.4",
-    "@umijs/utils": "^4.4.12",
+    "@types/terminal-kit": "^2.5.7",
+    "@umijs/utils": "^4.5.3",
     "@vercel/ncc": "^0.38.3",
-    "@vitejs/plugin-react": "^4.6.0",
-    "chalk": "^5.4.1",
+    "@vitejs/plugin-react": "^5.0.2",
+    "chalk": "^5.5.0",
     "commander": "^12.1.0",
     "dotenv": "16.6.1",
     "execa": "^8.0.1",
     "fast-glob": "^3.3.3",
-    "fs-extra": "^11.3.0",
+    "fs-extra": "^11.3.2",
     "lodash": "^4.17.21",
-    "npm-packlist": "^10.0.1",
+    "npm-packlist": "^10.0.2",
     "open": "^10.2.0",
     "p-all": "^3.0.0",
     "package-json": "^10.0.1",
-    "portfinder": "^1.0.37",
+    "portfinder": "^1.0.38",
     "rimraf": "^6.0.1",
     "semver": "^7.7.2",
-    "tar": "^7.4.3",
+    "simple-git": "^3.28.0",
+    "tar": "^7.5.1",
+    "terminal-kit": "^3.1.2",
     "tree-kill": "^1.2.2",
     "tsconfig-paths": "^4.2.0",
     "tsup": "^8.5.0",
-    "tsx": "^4.20.3",
-    "typescript": "^5.8.3",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.2",
     "update-notifier": "^7.3.1",
-    "vite": "^7.0.1",
-    "vite-plugin-css-injected-by-js": "^3.5.2"
+    "vite": "^7.1.10",
+    "vite-plugin-css-injected-by-js": "^3.5.2",
+    "@tachybase/test": "1.3.54-alpha.0"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
@@ -59,13 +64,14 @@
     "@types/node": "20.17.10",
     "@types/npm-packlist": "^7.0.3",
     "@types/npmcli__arborist": "^6.3.1",
-    "@types/semver": "^7.7.0",
+    "@types/semver": "^7.7.1",
     "@types/tar": "^6.1.13",
     "@types/update-notifier": "^6.0.8",
     "esbuild-plugin-file-path-extensions": "^2.1.4"
   },
   "scripts": {
     "build": "tsup",
+    "dev": "tsup --watch",
     "typecheck": "tsc --noEmit"
   }
 }

package/lib/commands/test.mjs

@@ -1,70 +0,0 @@
-// src/commands/test.ts
-import { sep } from "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
-};