@chatbi-v/cli 2.0.4 → 2.0.5

package/dist/index.js

@@ -14,12 +14,12 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// ../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/esm_shims.js
+// ../../../chatbi-v/node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/esm_shims.js
 import path from "path";
 import { fileURLToPath } from "url";
 var getFilename, getDirname, __dirname;
 var init_esm_shims = __esm({
-  "../../node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/esm_shims.js"() {
+  "../../../chatbi-v/node_modules/.pnpm/tsup@8.5.1_jiti@2.6.1_postcss@8.5.6_typescript@5.9.3_yaml@2.8.2/node_modules/tsup/assets/esm_shims.js"() {
     "use strict";
     getFilename = () => fileURLToPath(import.meta.url);
     getDirname = () => path.dirname(getFilename());
@@ -84,11 +84,7 @@ var init_utils = __esm({
         if (pkgName === "@chatbi-v/cli") {
           return path2.resolve(_dirname, "../../");
         }
-        const localPath = path2.resolve(_dirname, "../../node_modules", pkgName);
-        if (fs.existsSync(localPath)) {
-          return localPath;
-        }
-        throw new Error(`\u65E0\u6CD5\u627E\u5230\u5305 ${pkgName}\uFF0C\u8BF7\u786E\u4FDD\u5DF2\u901A\u8FC7 pnpm/npm \u5B89\u88C5\u3002`);
+        return null;
       }
     };
     getCliRoot = async () => {
@@ -105,269 +101,299 @@ var init_utils = __esm({
         checkDir = path2.dirname(checkDir);
       }
       if (!myCliRoot) {
-        myCliRoot = findPackageRoot("@chatbi-v/cli");
+        myCliRoot = findPackageRoot("@chatbi-v/cli") || "";
       }
       return myCliRoot;
     };
   }
 });
 
-// src/sandbox.ts
-import fs2 from "fs-extra";
+// src/constants.ts
 import path3 from "path";
 import os from "os";
-import pc2 from "picocolors";
-import { execa } from "execa";
-import Handlebars from "handlebars";
-import fg from "fast-glob";
-var Sandbox;
-var init_sandbox = __esm({
-  "src/sandbox.ts"() {
+var SANDBOX_CONFIG, GLOBAL_PATHS, DEPENDENCY_VERSIONS, DEFAULT_CONFIG;
+var init_constants = __esm({
+  "src/constants.ts"() {
     "use strict";
     init_esm_shims();
-    init_utils();
-    Sandbox = class _Sandbox {
-      static {
-        this.BASE_DIR = path3.join(os.homedir(), ".chatbi-v-core");
-      }
-      static {
-        this.CORE_PACKAGES = [
-          "@chatbi-v/core",
-          "@chatbi-v/mocks",
-          "@chatbi-v/tsconfig",
-          "@chatbi-v/tailwind-config",
-          "@chatbi-v/plugin-theme-manager",
-          "@chatbi-v/plugin-layout-transform",
-          "@chatbi-v/plugin-system-monitor"
-        ];
-      }
+    SANDBOX_CONFIG = {
+      /** 用户主目录下的沙箱根目录名 */
+      BASE_NAME: ".chatbi-v-core",
+      /** 内部子目录结构 */
+      DIRS: {
+        VERSIONS: "versions",
+        CURRENT: "current",
+        CACHE: ".chatbi"
+      },
+      /** 关键标识文件 */
+      LOCK_FILE: ".chatbi-version"
+    };
+    GLOBAL_PATHS = {
+      /** 沙箱根路径 */
+      BASE_DIR: path3.join(os.homedir(), SANDBOX_CONFIG.BASE_NAME),
+      /** Monorepo 扫描目录 */
+      MONOREPO_ROOTS: ["apps", "plugins", "packages"]
+    };
+    DEPENDENCY_VERSIONS = {
+      // 基础框架
+      "react": "^18.3.1",
+      "react-dom": "^18.3.1",
+      "antd": "^5.20.0",
+      // 构建工具
+      "vite": "^5.0.8",
+      "typescript": "^5.3.3",
+      "tailwindcss": "^3.4.1",
+      "autoprefixer": "^10.4.17",
+      "postcss": "^8.4.35",
+      "less": "^4.2.0",
+      // 类型定义
+      "@types/react": "^18.3.1",
+      "@types/react-dom": "^18.3.1",
+      "@types/node": "^20.11.20",
+      "@vitejs/plugin-react": "^4.2.1"
+    };
+    DEFAULT_CONFIG = {
+      /** 支持的配置文件名 */
+      CONFIG_FILES: [
+        "chatbi.config.ts",
+        "chatbi.config.js",
+        "chatbi.config.json",
+        ".chatbirc"
+      ],
+      /** 默认 UI 主题 */
+      THEME: "standard"
+    };
+  }
+});
+
+// src/sandbox/SandboxPath.ts
+import path4 from "path";
+import fs2 from "fs-extra";
+var SandboxPath;
+var init_SandboxPath = __esm({
+  "src/sandbox/SandboxPath.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_constants();
+    SandboxPath = class {
       static {
-        this.RUNTIME_DEPS = [
-          "@ant-design/x",
-          "@ant-design/icons",
-          "antd",
-          "react",
-          "react-dom",
-          "lucide-react",
-          "framer-motion",
-          "clsx",
-          "tailwind-merge",
-          "react-router-dom",
-          "zustand",
-          "axios",
-          "less",
-          "vite"
-        ];
+        /**
+         * 沙箱的基础存储目录，通常位于用户主目录下的 .chatbi-v-core
+         */
+        this.BASE_DIR = GLOBAL_PATHS.BASE_DIR;
       }
+      /**
+       * 获取沙箱根目录
+       * @returns 沙箱根目录的绝对路径
+       */
       static getRoot() {
         return this.BASE_DIR;
       }
+      /**
+       * 获取存储所有版本的根目录
+       * @returns versions 目录的绝对路径
+       */
       static getVersionRoot() {
-        return path3.join(this.BASE_DIR, "versions");
+        return path4.join(this.BASE_DIR, SANDBOX_CONFIG.DIRS.VERSIONS);
       }
+      /**
+       * 获取指定版本的沙箱路径
+       * @param version 版本号，或者 'current' 表示当前激活版本
+       * @returns 对应版本的绝对路径
+       */
       static getVersionPath(version) {
-        if (version === "current") {
-          return path3.join(this.BASE_DIR, "versions", "current");
+        if (version === SANDBOX_CONFIG.DIRS.CURRENT) {
+          return path4.join(this.BASE_DIR, SANDBOX_CONFIG.DIRS.VERSIONS, SANDBOX_CONFIG.DIRS.CURRENT);
         }
-        return path3.join(this.BASE_DIR, "versions", version);
+        return path4.join(this.BASE_DIR, SANDBOX_CONFIG.DIRS.VERSIONS, version);
       }
       /**
-       * 优雅清理缓存环境
-       * @param cwd 当前工作目录
-       * @param deep 是否递归清理子包
+       * 递归向上查找工作区根目录
+       * 识别标准：包含 pnpm-workspace.yaml 或 package.json 中定义了 workspaces
+       * @param cwd 起始查找目录
+       * @returns 查找到的工作区根目录路径，若未找到则返回 cwd
        */
-      static async clean(cwd, deep = false) {
-        const localCache = path3.join(cwd, ".chatbi");
-        if (fs2.existsSync(localCache)) {
-          await fs2.remove(localCache);
-        }
-        if (deep) {
-          const pkgPath = path3.join(cwd, "package.json");
+      static async getWorkspaceRoot(cwd) {
+        let current = cwd;
+        while (current !== path4.parse(current).root) {
+          const pkgPath = path4.join(current, "package.json");
+          const pnpmWorkspacePath = path4.join(current, "pnpm-workspace.yaml");
+          if (fs2.existsSync(pnpmWorkspacePath)) return current;
           if (fs2.existsSync(pkgPath)) {
-            const pkg = await fs2.readJson(pkgPath);
-            if (pkg.workspaces || fs2.existsSync(path3.join(cwd, "pnpm-workspace.yaml"))) {
-              const subDirs = ["apps", "plugins", "packages"];
-              for (const dir of subDirs) {
-                const dirPath = path3.join(cwd, dir);
-                if (fs2.existsSync(dirPath)) {
-                  const entries = await fs2.readdir(dirPath, { withFileTypes: true });
-                  for (const entry of entries) {
-                    if (entry.isDirectory()) {
-                      const subPkgCache = path3.join(dirPath, entry.name, ".chatbi");
-                      if (fs2.existsSync(subPkgCache)) {
-                        await fs2.remove(subPkgCache);
-                      }
-                    }
-                  }
-                }
-              }
+            try {
+              const pkg = await fs2.readJson(pkgPath);
+              if (pkg.workspaces) return current;
+            } catch (e) {
             }
           }
+          current = path4.dirname(current);
         }
-        if (fs2.existsSync(this.BASE_DIR)) {
-          await fs2.remove(this.BASE_DIR);
-        }
+        return cwd;
+      }
+    };
+  }
+});
+
+// src/sandbox/SandboxRenderer.ts
+import fs3 from "fs-extra";
+import path5 from "path";
+import Handlebars from "handlebars";
+var SandboxRenderer;
+var init_SandboxRenderer = __esm({
+  "src/sandbox/SandboxRenderer.ts"() {
+    "use strict";
+    init_esm_shims();
+    Handlebars.registerHelper("json", (obj) => JSON.stringify(obj, null, 2));
+    Handlebars.registerHelper("eq", (a, b) => a === b);
+    SandboxRenderer = class {
+      static {
+        /**
+         * 需要转义的模板关键字列表
+         * 只有匹配这些关键字的 {{ }} 才会被 Handlebars 处理，其余（如 React 的 {{ style }}）将被转义跳过
+         */
+        this.TEMPLATE_KEYWORDS = [
+          "name",
+          "version",
+          "projectName",
+          "projectTitle",
+          "projectVersion",
+          "cliVersion",
+          "tsconfigPath",
+          "theme",
+          "isNebula",
+          "isGlass",
+          "isBusiness",
+          "isApp",
+          "isShell",
+          "pluginName",
+          "pluginPackageName",
+          "pluginVersion",
+          "pluginDisplayName",
+          "pluginDescription",
+          "pluginClassName",
+          "pluginPath",
+          "pluginFolderName",
+          "pluginType",
+          "pluginId",
+          "className",
+          "dependencies",
+          "devDependencies",
+          "json"
+        ];
       }
       /**
-       * 准备内核沙箱环境 (安装/更新)
+       * 递归渲染目录模板
+       * @param srcDir 模板源目录
+       * @param destDir 目标输出目录
+       * @param data 渲染模板所需的变量上下文
        */
-      static async prepare(version, force = false) {
-        const versionPath = this.getVersionPath(version);
-        if (fs2.existsSync(versionPath) && !force) {
-          if (fs2.existsSync(path3.join(versionPath, "node_modules/tailwindcss")) && fs2.existsSync(path3.join(versionPath, "node_modules/react-router-dom"))) {
-            return versionPath;
-          }
-        }
-        if (fs2.existsSync(versionPath)) {
-          await fs2.remove(path3.join(versionPath, "node_modules"));
-          await fs2.remove(path3.join(versionPath, "pnpm-lock.yaml"));
-        }
-        await fs2.ensureDir(versionPath);
-        const spinner = createSpinner(`\u6B63\u5728\u521D\u59CB\u5316\u5185\u6838\u6C99\u7BB1 ${pc2.cyan(version)}...`).start();
-        try {
-          const rootPkgJson = {
-            name: `chatbi-sandbox-${version}`,
-            private: true,
-            dependencies: {},
-            devDependencies: {
-              "tailwindcss": "^3.4.1",
-              "autoprefixer": "^10.4.17",
-              "postcss": "^8.4.35",
-              "vite": "^5.0.8",
-              "@vitejs/plugin-react": "^4.2.1",
-              "less": "^4.2.0",
-              "typescript": "^5.3.3",
-              "@types/react": "^18.3.1",
-              "@types/react-dom": "^18.3.1",
-              "@types/node": "^20.11.20"
-            }
-          };
-          for (const pkgName of _Sandbox.CORE_PACKAGES) {
-            rootPkgJson.dependencies[pkgName] = pkgName === "@chatbi-v/core" ? version : "latest";
-          }
-          for (const pkgName of _Sandbox.RUNTIME_DEPS) {
-            if (!rootPkgJson.dependencies[pkgName]) {
-              rootPkgJson.dependencies[pkgName] = "latest";
-            }
-          }
-          rootPkgJson.dependencies["react"] = "^18.3.1";
-          rootPkgJson.dependencies["react-dom"] = "^18.3.1";
-          rootPkgJson.dependencies["antd"] = "^5.20.0";
-          await fs2.writeJson(path3.join(versionPath, "package.json"), rootPkgJson, { spaces: 2 });
-          await fs2.writeFile(path3.join(versionPath, ".npmrc"), "shamefully-hoist=true\nauto-install-peers=true\n");
-          spinner.text = pc2.gray("  \u{1F50D} \u68C0\u67E5\u672C\u5730\u5F00\u53D1\u73AF\u5883...");
-          const isLocalDev = await this.tryLinkLocalPackages(versionPath);
-          const installArgs = ["install"];
-          if (isLocalDev) {
-            installArgs.push("--no-frozen-lockfile");
+      static async renderDirectory(srcDir, destDir, data) {
+        if (!fs3.existsSync(srcDir)) return;
+        const entries = await fs3.readdir(srcDir, { withFileTypes: true });
+        for (const entry of entries) {
+          const srcPath = path5.join(srcDir, entry.name);
+          const destPath = path5.join(destDir, entry.name.replace(/\.hbs$/, ""));
+          if (entry.isDirectory()) {
+            await fs3.ensureDir(destPath);
+            await this.renderDirectory(srcPath, destPath, data);
+          } else {
+            await this.renderFile(srcPath, destPath, data);
           }
-          spinner.text = pc2.gray(`  \u23F3 \u6267\u884C pnpm ${installArgs.join(" ")}...`);
-          await execa("pnpm", installArgs, { cwd: versionPath });
-          spinner.text = pc2.gray("  \u{1F3A8} \u540C\u6B65 Shell \u6A21\u677F...");
-          await this.ensureShell(version, force);
-          spinner.succeed(pc2.green(`\u5185\u6838\u6C99\u7BB1 ${version} \u521D\u59CB\u5316\u6210\u529F`));
-        } catch (e) {
-          spinner.fail(pc2.red(`\u5185\u6838\u6C99\u7BB1\u521D\u59CB\u5316\u5931\u8D25: ${e.message}`));
-          throw e;
         }
-        return versionPath;
       }
       /**
-       * 确保 Shell 模板已同步到沙箱
+       * 渲染单个文件
        */
-      static async ensureShell(version, force = false) {
-        const versionPath = this.getVersionPath(version);
-        const shellDestDir = path3.join(versionPath, "shell");
-        const needsRender = force || !fs2.existsSync(shellDestDir) || !fs2.existsSync(path3.join(shellDestDir, "tsconfig.paths.json"));
-        if (!needsRender) {
-          return shellDestDir;
+      static async renderFile(srcPath, destPath, data) {
+        const isTemplate = srcPath.endsWith(".hbs");
+        if (!isTemplate) {
+          await fs3.copy(srcPath, destPath);
+          return;
         }
-        const cliRoot = await getCliRoot();
-        const shellTemplateDir = path3.join(cliRoot, "templates", "app");
-        if (fs2.existsSync(shellTemplateDir)) {
-          await fs2.remove(shellDestDir);
-          await fs2.ensureDir(path3.join(shellDestDir, "empty"));
-          let kernelVersion = version;
-          const templateData = {
-            name: "chatbi-shell",
-            projectName: "chatbi-shell",
-            projectTitle: "ChatBI Shell",
-            projectVersion: "0.1.0",
-            version: kernelVersion,
-            cliVersion: version,
-            theme: "standard",
-            isNebula: false,
-            isGlass: false,
-            isBusiness: true,
-            isApp: true,
-            isShell: true,
-            tsconfigPath: "./tsconfig.paths.json"
-          };
-          await this.renderDirectory(shellTemplateDir, shellDestDir, templateData);
-          const tsConfigPaths = {
-            compilerOptions: {
-              baseUrl: ".",
-              paths: {
-                "@/*": ["./src/*"]
-              }
-            }
-          };
-          await fs2.writeJson(path3.join(shellDestDir, "tsconfig.paths.json"), tsConfigPaths, { spaces: 2 });
+        const content = await fs3.readFile(srcPath, "utf-8");
+        if (!content.includes("{{")) {
+          await fs3.outputFile(destPath, content);
+          return;
+        }
+        try {
+          const keywordsPattern = this.TEMPLATE_KEYWORDS.join("|");
+          const safeContent = content.replace(
+            new RegExp(`\\{\\{(?!\\{)(?!\\s*([#/]?(?:${keywordsPattern}))\\b)`, "g"),
+            "\\{{"
+          );
+          const template = Handlebars.compile(safeContent);
+          const result = template(data);
+          await fs3.outputFile(destPath, result);
+        } catch (e) {
+          let result = content;
+          for (const [key, val] of Object.entries(data)) {
+            const regex = new RegExp(`\\{\\{\\s*${key}\\s*\\}\\}`, "g");
+            result = result.replace(regex, typeof val === "object" ? JSON.stringify(val) : String(val));
+          }
+          await fs3.outputFile(destPath, result);
         }
-        return shellDestDir;
       }
+    };
+  }
+});
+
+// src/sandbox/SandboxContext.ts
+import fs4 from "fs-extra";
+import path6 from "path";
+var SandboxContext;
+var init_SandboxContext = __esm({
+  "src/sandbox/SandboxContext.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_SandboxPath();
+    init_constants();
+    SandboxContext = class {
       /**
-       * 递归渲染目录模板
+       * 注入项目虚拟上下文
+       * 包括：
+       * 1. 确定集中式 .chatbi 存放位置并处理子包软链
+       * 2. 生成适配沙箱的 tsconfig.json (配置路径别名)
+       * 3. 软链接沙箱的 node_modules 到项目 .chatbi 目录下
+       * 4. 确保 .chatbi 被加入 .gitignore
+       * 
+       * @param projectRoot 当前项目根目录
+       * @param version 内核版本号
+       * @param corePackages 核心包名列表
+       * @param runtimeDeps 运行时依赖包名列表
        */
-      static async renderDirectory(srcDir, destDir, data) {
-        const entries = await fs2.readdir(srcDir, { withFileTypes: true });
-        for (const entry of entries) {
-          const srcPath = path3.join(srcDir, entry.name);
-          const destPath = path3.join(destDir, entry.name.replace(/\.hbs$/, ""));
-          if (entry.isDirectory()) {
-            await fs2.ensureDir(destPath);
-            await this.renderDirectory(srcPath, destPath, data);
-          } else {
-            if (entry.name.endsWith(".hbs")) {
-              const content = await fs2.readFile(srcPath, "utf-8");
-              const hasHandlebarsVars = content.includes("{{");
-              if (hasHandlebarsVars) {
-                try {
-                  const safeContent = content.replace(/\{\{(?!\s*([#/]?(?:if|else|each|with|unless|name|version|projectName|projectTitle|projectVersion|cliVersion|tsconfigPath|theme|isNebula|isGlass|isBusiness|isApp|isShell|pluginName|pluginPackageName|pluginVersion|pluginDisplayName|pluginDescription|pluginClassName|pluginPath|pluginFolderName|pluginType|pluginId|className))\b)/g, "\\{{");
-                  const template = Handlebars.compile(safeContent);
-                  const result = template(data);
-                  await fs2.outputFile(destPath, result);
-                } catch (e) {
-                  let result = content;
-                  for (const [key, val] of Object.entries(data)) {
-                    const regex = new RegExp(`\\{\\{\\s*${key}\\s*\\}\\}`, "g");
-                    result = result.replace(regex, String(val));
-                  }
-                  await fs2.outputFile(destPath, result);
+      static async inject(projectRoot, version, corePackages, runtimeDeps) {
+        const workspaceRoot = await SandboxPath.getWorkspaceRoot(projectRoot);
+        const chatbiDir = path6.join(workspaceRoot, SANDBOX_CONFIG.DIRS.CACHE);
+        await fs4.ensureDir(chatbiDir);
+        if (workspaceRoot !== projectRoot) {
+          const localChatbi = path6.join(projectRoot, SANDBOX_CONFIG.DIRS.CACHE);
+          try {
+            const stats = await fs4.lstat(localChatbi).catch(() => null);
+            if (stats) {
+              if (stats.isSymbolicLink()) {
+                const linkTarget = await fs4.readlink(localChatbi);
+                if (linkTarget !== chatbiDir) {
+                  await fs4.remove(localChatbi);
+                  await fs4.symlink(chatbiDir, localChatbi, "dir");
                 }
               } else {
-                await fs2.outputFile(destPath, content);
+                await fs4.remove(localChatbi);
+                await fs4.symlink(chatbiDir, localChatbi, "dir");
               }
             } else {
-              await fs2.copy(srcPath, destPath);
+              await fs4.symlink(chatbiDir, localChatbi, "dir");
             }
+          } catch (e) {
           }
         }
-      }
-      /**
-       * 注入项目虚拟上下文 (tsconfig, alias)
-       */
-      static async injectContext(projectRoot, version) {
-        const chatbiDir = path3.join(projectRoot, ".chatbi");
-        await fs2.ensureDir(chatbiDir);
-        const versionPath = this.getVersionPath(version);
-        const sandboxNodeModules = path3.join(versionPath, "node_modules");
+        const versionPath = SandboxPath.getVersionPath(version);
+        const sandboxNodeModules = path6.join(versionPath, "node_modules");
         const corePaths = {};
-        for (const pkgName of _Sandbox.CORE_PACKAGES) {
+        for (const pkgName of corePackages) {
           corePaths[pkgName] = [`./node_modules/${pkgName}`];
           corePaths[`${pkgName}/*`] = [`./node_modules/${pkgName}/*`];
         }
-        for (const pkgName of _Sandbox.RUNTIME_DEPS) {
+        for (const pkgName of runtimeDeps) {
           corePaths[pkgName] = [`./node_modules/${pkgName}`];
           corePaths[`${pkgName}/*`] = [`./node_modules/${pkgName}/*`];
           if (["react", "react-dom", "node"].includes(pkgName)) {
@@ -378,152 +404,119 @@ var init_sandbox = __esm({
         }
         corePaths["@types/*"] = ["./node_modules/@types/*"];
         corePaths["vite/client"] = ["./node_modules/vite/client.d.ts"];
-        const baseConfigPath = path3.join(sandboxNodeModules, "@chatbi-v/tsconfig/base.json");
-        let projectPaths = { "@/*": ["../src/*"] };
+        const baseConfigPath = path6.join(sandboxNodeModules, "@chatbi-v/tsconfig/base.json");
         const tsConfig = {
           extends: baseConfigPath,
           compilerOptions: {
             baseUrl: ".",
             moduleResolution: "bundler",
             skipLibCheck: true,
-            // Fix: Use relative path to the symlinked node_modules in .chatbi
-            // This is much more robust as it works relative to the config file (.chatbi/tsconfig.json)
-            typeRoots: [
-              "./node_modules/@types"
-            ],
-            // Crucial for symlinked node_modules: treat them as if they are in the project
+            typeRoots: ["./node_modules/@types"],
             preserveSymlinks: true,
             paths: {
               ...corePaths,
-              ...projectPaths,
-              // Fallback: Try to find anything else in the virtual node_modules
+              "@/*": ["../src/*"],
               "*": ["./node_modules/*"]
             }
           }
         };
-        await fs2.writeJson(path3.join(chatbiDir, "tsconfig.json"), tsConfig, { spaces: 2 });
-        await fs2.writeJson(path3.join(chatbiDir, "tsconfig.paths.json"), { compilerOptions: tsConfig.compilerOptions }, { spaces: 2 });
-        const virtualNodeModules = path3.join(chatbiDir, "node_modules");
-        if (!fs2.existsSync(sandboxNodeModules)) {
-          return;
-        }
-        try {
+        await fs4.writeJson(path6.join(chatbiDir, "tsconfig.json"), tsConfig, { spaces: 2 });
+        await fs4.writeJson(path6.join(chatbiDir, "tsconfig.paths.json"), { compilerOptions: tsConfig.compilerOptions }, { spaces: 2 });
+        const virtualNodeModules = path6.join(chatbiDir, "node_modules");
+        if (fs4.existsSync(sandboxNodeModules)) {
           try {
-            const stats = await fs2.lstat(virtualNodeModules);
-            if (stats) {
-              await fs2.remove(virtualNodeModules);
-            }
-          } catch (e) {
-          }
-          await fs2.ensureSymlink(sandboxNodeModules, virtualNodeModules, "dir");
-          const rootNodeModules = path3.join(projectRoot, "node_modules");
-          let rootNmExists = false;
-          try {
-            rootNmExists = fs2.existsSync(rootNodeModules);
+            await fs4.remove(virtualNodeModules).catch(() => {
+            });
+            await fs4.ensureSymlink(sandboxNodeModules, virtualNodeModules, "dir");
           } catch (e) {
           }
-          if (!rootNmExists) {
-            try {
-              await fs2.ensureSymlink(sandboxNodeModules, rootNodeModules, "dir");
-            } catch (linkErr) {
-              const appsDir = path3.join(projectRoot, "apps");
-              if (fs2.existsSync(appsDir)) {
-                const appDirs = await fg("*", { cwd: appsDir, onlyDirectories: true, absolute: true });
-                for (const appDir of appDirs) {
-                  const appNm = path3.join(appDir, "node_modules");
-                  if (!fs2.existsSync(appNm)) {
-                    await fs2.ensureSymlink(sandboxNodeModules, appNm, "dir").catch(() => {
-                    });
-                  }
-                }
-              }
-            }
-          }
-        } catch (e) {
         }
-        const gitignorePath = path3.join(projectRoot, ".gitignore");
-        if (fs2.existsSync(gitignorePath)) {
-          let content = await fs2.readFile(gitignorePath, "utf-8");
-          if (!content.includes(".chatbi")) {
-            await fs2.appendFile(gitignorePath, "\n# ChatBI\n.chatbi\n");
+        const gitignorePath = path6.join(workspaceRoot, ".gitignore");
+        if (fs4.existsSync(gitignorePath)) {
+          let content = await fs4.readFile(gitignorePath, "utf-8");
+          if (!content.includes(SANDBOX_CONFIG.DIRS.CACHE)) {
+            await fs4.appendFile(gitignorePath, `
+# ChatBI
+${SANDBOX_CONFIG.DIRS.CACHE}
+`);
           }
         }
       }
+    };
+  }
+});
+
+// src/sandbox/SandboxPkgManager.ts
+import fs5 from "fs-extra";
+import path7 from "path";
+import pc2 from "picocolors";
+import fg from "fast-glob";
+var SandboxPkgManager;
+var init_SandboxPkgManager = __esm({
+  "src/sandbox/SandboxPkgManager.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+    init_SandboxPath();
+    SandboxPkgManager = class {
       /**
-       * 获取核心库的 Vite Alias 配置
-       */
-      static getCoreAlias(version) {
-        const versionPath = this.getVersionPath(version);
-        const sandboxNodeModules = path3.join(versionPath, "node_modules");
-        const aliases = {};
-        for (const pkg of this.CORE_PACKAGES) {
-          aliases[pkg] = path3.join(sandboxNodeModules, pkg);
-        }
-        return aliases;
-      }
-      /**
-       * 尝试将本地包 Link 到沙箱中 (模拟安装)
+       * 尝试将本地开发环境的包 Link 到沙箱中 (模拟安装)
+       * 用于 Monorepo 场景下，让沙箱直接使用最新的本地源码
+       * @param versionPath 沙箱版本的存储路径
+       * @param corePackages 核心包名列表
+       * @param runtimeDeps 运行时依赖包名列表
+       * @returns 是否成功 Link 了至少一个包
        */
-      static async tryLinkLocalPackages(versionPath) {
+      static async tryLinkLocalPackages(versionPath, corePackages, runtimeDeps) {
         try {
           const cliRoot = await getCliRoot();
-          let projectRoot = path3.resolve(cliRoot, "../../..");
-          let currentDir = cliRoot;
-          while (currentDir !== path3.parse(currentDir).root) {
-            if (fs2.existsSync(path3.join(currentDir, "pnpm-workspace.yaml"))) {
-              projectRoot = currentDir;
-              break;
-            }
-            currentDir = path3.dirname(currentDir);
+          const projectRoot = await SandboxPath.getWorkspaceRoot(cliRoot);
+          if (projectRoot === cliRoot && !fs5.existsSync(path7.join(projectRoot, "pnpm-workspace.yaml"))) {
+            return false;
           }
           const possiblePackagesDirs = [
-            path3.join(projectRoot, "packages"),
-            // 兼容某些特殊结构，比如 chatbi-v 仓库
-            path3.resolve(projectRoot, "../chatbi-v/packages")
+            path7.join(projectRoot, "packages"),
+            // 兼容旧版或其他可能的路径结构
+            path7.resolve(projectRoot, "../chatbi-v/packages")
           ];
           const localPackages = {};
-          const patterns = possiblePackagesDirs.filter((dir) => fs2.existsSync(dir)).map((dir) => path3.join(dir, "**/package.json"));
+          const patterns = possiblePackagesDirs.filter((dir) => fs5.existsSync(dir)).map((dir) => path7.join(dir, "**/package.json"));
           if (patterns.length > 0) {
             const pkgJsonFiles = await fg(patterns, {
               ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"],
               absolute: true,
               deep: 5
-              // 允许一定的嵌套深度
             });
             for (const pkgJsonPath of pkgJsonFiles) {
               try {
-                const pkgJson = await fs2.readJson(pkgJsonPath);
-                if (this.CORE_PACKAGES.includes(pkgJson.name) || this.RUNTIME_DEPS.includes(pkgJson.name)) {
-                  localPackages[pkgJson.name] = path3.dirname(pkgJsonPath);
+                const pkgJson = await fs5.readJson(pkgJsonPath);
+                if (corePackages.includes(pkgJson.name) || runtimeDeps.includes(pkgJson.name)) {
+                  localPackages[pkgJson.name] = path7.dirname(pkgJsonPath);
                 }
               } catch (e) {
               }
             }
           }
-          if (Object.keys(localPackages).length === 0) {
-            return false;
-          }
+          if (Object.keys(localPackages).length === 0) return false;
           const linkSummary = Object.entries(localPackages).map(([name, pkgPath]) => `${pc2.cyan(name.padEnd(30))} -> ${pc2.gray(pkgPath)}`).join("\n");
           printBox(
             pc2.green("\u{1F517} \u5DF2\u68C0\u6D4B\u5230\u672C\u5730\u5F00\u53D1\u73AF\u5883\uFF0C\u5C06\u94FE\u63A5\u4EE5\u4E0B\u6838\u5FC3\u5305\uFF1A\n\n") + linkSummary,
             "Monorepo Link Mode"
           );
-          const sandboxNodeModules = path3.join(versionPath, "node_modules");
-          await fs2.ensureDir(sandboxNodeModules);
+          const sandboxNodeModules = path7.join(versionPath, "node_modules");
+          await fs5.ensureDir(sandboxNodeModules);
           for (const [name, pkgPath] of Object.entries(localPackages)) {
-            const targetLinkPath = path3.join(sandboxNodeModules, name);
-            await fs2.ensureDir(path3.dirname(targetLinkPath));
+            const targetLinkPath = path7.join(sandboxNodeModules, name);
+            await fs5.ensureDir(path7.dirname(targetLinkPath));
             try {
-              const stats = await fs2.lstat(targetLinkPath).catch(() => null);
-              if (stats) {
-                await fs2.remove(targetLinkPath);
-              }
+              const stats = await fs5.lstat(targetLinkPath).catch(() => null);
+              if (stats) await fs5.remove(targetLinkPath);
             } catch (e) {
             }
-            await fs2.symlink(pkgPath, targetLinkPath, "dir");
+            await fs5.symlink(pkgPath, targetLinkPath, "dir");
           }
-          const sandboxPkgJsonPath = path3.join(versionPath, "package.json");
-          const sandboxPkgJson = await fs2.readJson(sandboxPkgJsonPath);
+          const sandboxPkgJsonPath = path7.join(versionPath, "package.json");
+          const sandboxPkgJson = await fs5.readJson(sandboxPkgJsonPath);
           const sections = ["dependencies", "devDependencies"];
           let modified = false;
           for (const section of sections) {
@@ -536,95 +529,287 @@ var init_sandbox = __esm({
               }
             }
           }
-          if (modified) {
-            await fs2.writeJson(sandboxPkgJsonPath, sandboxPkgJson, { spaces: 2 });
-          }
+          if (modified) await fs5.writeJson(sandboxPkgJsonPath, sandboxPkgJson, { spaces: 2 });
           return true;
         } catch (e) {
           console.warn(pc2.yellow(`  \u26A0\uFE0F  Link \u672C\u5730\u6E90\u7801\u5931\u8D25\uFF0C\u5C06\u5C1D\u8BD5\u4ECE NPM \u5B89\u88C5: ${e.message}`));
           return false;
         }
       }
-      /**
-       * 切换全局当前使用的内核版本
-       */
-      static async useVersion(version) {
-        const versionRoot = this.getVersionRoot();
-        const currentLinkPath = path3.join(versionRoot, "current");
-        const targetPath = this.getVersionPath(version);
-        if (!fs2.existsSync(targetPath)) {
-          throw new Error(`\u7248\u672C ${version} \u5C1A\u672A\u5B89\u88C5`);
-        }
-        if (fs2.existsSync(currentLinkPath)) {
-          await fs2.remove(currentLinkPath);
+    };
+  }
+});
+
+// src/sandbox.ts
+import fs6 from "fs-extra";
+import path8 from "path";
+import pc3 from "picocolors";
+import fg2 from "fast-glob";
+import { execa } from "execa";
+var Sandbox;
+var init_sandbox = __esm({
+  "src/sandbox.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_utils();
+    init_SandboxPath();
+    init_SandboxRenderer();
+    init_SandboxContext();
+    init_SandboxPkgManager();
+    init_constants();
+    Sandbox = class {
+      static {
+        /** 核心源码包列表 */
+        this.CORE_PACKAGES = [
+          "@chatbi-v/core",
+          "@chatbi-v/mocks",
+          "@chatbi-v/tsconfig",
+          "@chatbi-v/tailwind-config",
+          "@chatbi-v/plugin-theme-manager",
+          "@chatbi-v/plugin-layout-transform",
+          "@chatbi-v/plugin-system-monitor"
+        ];
+      }
+      static {
+        /** 运行时必须依赖 */
+        this.RUNTIME_DEPS = [
+          "@ant-design/x",
+          "@ant-design/icons",
+          "antd",
+          "react",
+          "react-dom",
+          "lucide-react",
+          "framer-motion",
+          "clsx",
+          "tailwind-merge",
+          "react-router-dom",
+          "zustand",
+          "axios",
+          "less",
+          "vite"
+        ];
+      }
+      /** 获取沙箱根目录 */
+      static getRoot() {
+        return SandboxPath.getRoot();
+      }
+      /** 获取所有版本的根目录 */
+      static getVersionRoot() {
+        return SandboxPath.getVersionRoot();
+      }
+      /** 获取指定版本的沙箱路径 */
+      static getVersionPath(version) {
+        return SandboxPath.getVersionPath(version);
+      }
+      /** 获取项目的工作区根目录 (Monorepo 支持) */
+      static async getWorkspaceRoot(cwd) {
+        return SandboxPath.getWorkspaceRoot(cwd);
+      }
+      /** 清理指定版本的沙箱物理文件 */
+      static async cleanVersion(version) {
+        const versionPath = this.getVersionPath(version);
+        if (fs6.existsSync(versionPath)) {
+          await fs6.remove(versionPath);
         }
-        await fs2.symlink(targetPath, currentLinkPath, "dir");
       }
       /**
-       * 可视化展示沙箱状态
+       * 优雅清理缓存环境
+       * @param cwd 当前项目路径
+       * @param deep 是否执行深度清理
        */
-      static async visualizeStatus(projectRoot) {
-        const version = await this.getCurrentVersion(projectRoot);
-        const versionPath = this.getVersionPath(version);
-        const isInstalled = fs2.existsSync(versionPath);
-        const sandboxNm = path3.join(versionPath, "node_modules");
-        let statusText = "";
-        statusText += `${pc2.bold("\u5F53\u524D\u5185\u6838\u7248\u672C:")} ${pc2.cyan(version)}
-`;
-        statusText += `${pc2.bold("\u6C99\u7BB1\u5B89\u88C5\u8DEF\u5F84:")} ${pc2.gray(versionPath)}
-`;
-        statusText += `${pc2.bold("\u5B89\u88C5\u72B6\u6001:")} ${isInstalled ? pc2.green("\u5DF2\u5C31\u7EEA") : pc2.red("\u672A\u5B89\u88C5")}
-`;
-        if (isInstalled) {
-          const corePkgs = this.CORE_PACKAGES.map((pkg) => {
-            const pkgPath = path3.join(sandboxNm, pkg);
-            const exists = fs2.existsSync(pkgPath);
-            let linkTarget = "";
-            if (exists) {
-              try {
-                const stats = fs2.lstatSync(pkgPath);
-                if (stats.isSymbolicLink()) {
-                  linkTarget = ` -> ${pc2.yellow(fs2.readlinkSync(pkgPath))}`;
+      static async clean(cwd, deep = false) {
+        const spinner = createSpinner("\u6B63\u5728\u6E05\u7406\u7F13\u5B58\u76EE\u5F55...").start();
+        try {
+          const workspaceRoot = await this.getWorkspaceRoot(cwd);
+          let cleanedCount = 0;
+          const cachePatterns = [
+            path8.join(workspaceRoot, `**/${SANDBOX_CONFIG.DIRS.CACHE}`)
+          ];
+          const cacheDirs = await fg2(cachePatterns, {
+            onlyFiles: false,
+            // 允许匹配文件和符号链接
+            absolute: true,
+            ignore: ["**/node_modules/**"],
+            dot: true
+            // 确保能匹配到以 . 开头的目录
+          });
+          for (const dir of cacheDirs) {
+            const stats = await fs6.lstat(dir).catch(() => null);
+            if (stats) {
+              await fs6.remove(dir);
+              cleanedCount++;
+            }
+          }
+          if (deep) {
+            const distPatterns = [
+              path8.join(workspaceRoot, "**/dist")
+            ];
+            const distDirs = await fg2(distPatterns, {
+              onlyFiles: false,
+              absolute: true,
+              ignore: [
+                "**/node_modules/**",
+                "**/packages/cli/dist/**",
+                // 保护 CLI 自身构建产物
+                "**/.git/**"
+              ]
+            });
+            for (const dir of distDirs) {
+              const stats = await fs6.lstat(dir).catch(() => null);
+              if (stats) {
+                const hasPkg = fs6.existsSync(path8.join(path8.dirname(dir), "package.json"));
+                if (hasPkg) {
+                  await fs6.remove(dir);
+                  cleanedCount++;
                 }
-              } catch (e) {
               }
             }
-            return `  ${exists ? pc2.green("\u2713") : pc2.red("\u2717")} ${pkg.padEnd(30)}${linkTarget}`;
-          }).join("\n");
-          statusText += `
-${pc2.bold("\u6838\u5FC3\u7EC4\u4EF6\u72B6\u6001:")}
-${corePkgs}`;
+            const globalRoot = this.getRoot();
+            if (fs6.existsSync(globalRoot)) {
+              await fs6.remove(globalRoot);
+              cleanedCount++;
+            }
+          }
+          spinner.succeed(pc3.green(`\u6E05\u7406\u5B8C\u6210\uFF0C\u5171\u6E05\u7406 ${cleanedCount} \u4E2A\u9879\u76EE/\u7F13\u5B58\u76EE\u5F55`));
+        } catch (e) {
+          spinner.fail(pc3.red(`\u6E05\u7406\u5931\u8D25: ${e.message}`));
         }
-        printBox(statusText, "ChatBI \u5185\u6838\u53EF\u89C2\u6D4B\u6027\u9762\u677F");
       }
       /**
-       * 获取当前项目使用的内核版本
+       * 准备内核沙箱环境 (安装/更新)
        */
-      static async getCurrentVersion(projectRoot) {
+      static async prepare(version, force = false) {
+        const versionPath = this.getVersionPath(version);
+        if (!force && fs6.existsSync(path8.join(versionPath, "node_modules/tailwindcss"))) {
+          return versionPath;
+        }
+        if (fs6.existsSync(versionPath)) {
+          await fs6.remove(path8.join(versionPath, "node_modules"));
+        }
+        await fs6.ensureDir(versionPath);
+        const spinner = createSpinner(`\u6B63\u5728\u521D\u59CB\u5316\u5185\u6838\u6C99\u7BB1 ${pc3.cyan(version)}...`).start();
         try {
-          const chatbiDir = path3.join(projectRoot, ".chatbi");
-          const tsconfigPath = path3.join(chatbiDir, "tsconfig.json");
-          if (fs2.existsSync(tsconfigPath)) {
-            const tsconfig = await fs2.readJson(tsconfigPath);
-            if (tsconfig.extends && tsconfig.extends.includes("/versions/")) {
-              const parts = tsconfig.extends.split("/");
-              const vIdx = parts.indexOf("versions");
-              if (vIdx !== -1 && parts[vIdx + 1]) {
-                return parts[vIdx + 1];
-              }
-            }
+          const cliRoot = await getCliRoot();
+          const dependencies = {};
+          for (const pkg of this.RUNTIME_DEPS) {
+            dependencies[pkg] = DEPENDENCY_VERSIONS[pkg] || "latest";
+          }
+          for (const pkg of this.CORE_PACKAGES) {
+            dependencies[pkg] = pkg === "@chatbi-v/core" ? version : "latest";
           }
+          const templateData = {
+            version,
+            dependencies,
+            devDependencies: DEPENDENCY_VERSIONS
+          };
+          await SandboxRenderer.renderDirectory(
+            path8.join(cliRoot, "templates/sandbox"),
+            versionPath,
+            templateData
+          );
+          spinner.text = pc3.gray("  \u{1F50D} \u68C0\u67E5\u672C\u5730\u5F00\u53D1\u73AF\u5883...");
+          const isLocalDev = await SandboxPkgManager.tryLinkLocalPackages(versionPath, this.CORE_PACKAGES, this.RUNTIME_DEPS);
+          const installArgs = isLocalDev ? ["install", "--no-frozen-lockfile"] : ["install"];
+          spinner.text = pc3.gray(`  \u23F3 \u6267\u884C pnpm ${installArgs.join(" ")}...`);
+          await execa("pnpm", installArgs, { cwd: versionPath });
+          spinner.text = pc3.gray("  \u{1F3A8} \u540C\u6B65 Shell \u6A21\u677F...");
+          await this.ensureShell(version, force);
+          spinner.succeed(pc3.green(`\u5185\u6838\u6C99\u7BB1 ${version} \u521D\u59CB\u5316\u6210\u529F`));
         } catch (e) {
+          spinner.fail(pc3.red(`\u5185\u6838\u6C99\u7BB1\u521D\u59CB\u5316\u5931\u8D25: ${e.message}`));
+          throw e;
         }
-        return "current";
+        return versionPath;
+      }
+      /**
+       * 确保 Shell 模板已同步到沙箱
+       */
+      static async ensureShell(version, force = false) {
+        const versionPath = this.getVersionPath(version);
+        const shellDestDir = path8.join(versionPath, "shell");
+        if (!force && fs6.existsSync(path8.join(shellDestDir, "tsconfig.paths.json"))) {
+          return shellDestDir;
+        }
+        const cliRoot = await getCliRoot();
+        const shellTemplateDir = path8.join(cliRoot, "templates/app");
+        if (fs6.existsSync(shellTemplateDir)) {
+          await fs6.remove(shellDestDir);
+          const templateData = {
+            name: "chatbi-shell",
+            version,
+            cliVersion: version,
+            theme: DEFAULT_CONFIG.THEME,
+            isShell: true,
+            isBusiness: true,
+            tsconfigPath: "./tsconfig.paths.json"
+          };
+          await SandboxRenderer.renderDirectory(shellTemplateDir, shellDestDir, templateData);
+          await fs6.writeJson(path8.join(shellDestDir, "tsconfig.paths.json"), {
+            compilerOptions: { baseUrl: ".", paths: { "@/*": ["./src/*"] } }
+          }, { spaces: 2 });
+        }
+        return shellDestDir;
+      }
+      /** 注入项目虚拟上下文 */
+      static async injectContext(projectRoot, version) {
+        return SandboxContext.inject(projectRoot, version, this.CORE_PACKAGES, this.RUNTIME_DEPS);
+      }
+      /** 获取核心库的 Vite Alias 配置 */
+      static getCoreAlias(version) {
+        const versionPath = this.getVersionPath(version);
+        const sandboxNodeModules = path8.join(versionPath, "node_modules");
+        return Object.fromEntries(this.CORE_PACKAGES.map((pkg) => [pkg, path8.join(sandboxNodeModules, pkg)]));
+      }
+      /** 切换内核版本 */
+      static async useVersion(version) {
+        const versionRoot = this.getVersionRoot();
+        const currentLink = path8.join(versionRoot, SANDBOX_CONFIG.DIRS.CURRENT);
+        const targetPath = this.getVersionPath(version);
+        if (!fs6.existsSync(targetPath)) throw new Error(`\u7248\u672C ${version} \u4E0D\u5B58\u5728`);
+        if (fs6.existsSync(currentLink)) await fs6.remove(currentLink);
+        await fs6.ensureSymlink(targetPath, currentLink, "dir");
+      }
+      /** 解析版本号 */
+      static async resolveVersion(version) {
+        if (!version || version === "latest" || version === "current") {
+          const currentLink = path8.join(this.getVersionRoot(), SANDBOX_CONFIG.DIRS.CURRENT);
+          if (fs6.existsSync(currentLink)) {
+            return path8.basename(await fs6.readlink(currentLink));
+          }
+          const versions = await this.listVersions();
+          return versions[0] || "1.0.0";
+        }
+        return version;
+      }
+      /** 列出所有已安装版本 */
+      static async listVersions() {
+        const versionRoot = this.getVersionRoot();
+        if (!fs6.existsSync(versionRoot)) return [];
+        const dirs = await fs6.readdir(versionRoot);
+        return dirs.filter((d) => d !== SANDBOX_CONFIG.DIRS.CURRENT && !d.startsWith(".")).sort().reverse();
+      }
+      /** 可视化展示沙箱状态 */
+      static async visualizeStatus(cwd) {
+        const workspaceRoot = await this.getWorkspaceRoot(cwd);
+        const isMonorepo = workspaceRoot !== cwd;
+        const currentVersion = await this.resolveVersion("current");
+        const versions = await this.listVersions();
+        const statusInfo = [
+          `${pc3.bold("\u9879\u76EE\u8DEF\u5F84:")}   ${pc3.cyan(cwd)}`,
+          `${pc3.bold("\u67B6\u6784\u6A21\u5F0F:")}   ${isMonorepo ? pc3.yellow("Monorepo") : pc3.green("Standalone")}`,
+          `${pc3.bold("\u5F53\u524D\u5185\u6838:")}   ${pc3.green(currentVersion)}`,
+          `${pc3.bold("\u5DF2\u88C5\u7248\u672C:")}   ${pc3.gray(versions.join(", ") || "none")}`,
+          `${pc3.bold("\u6C99\u7BB1\u6839\u76EE\u5F55:")} ${pc3.gray(this.getRoot())}`
+        ].join("\n");
+        printBox(statusInfo, "ChatBI Sandbox Status");
       }
     };
   }
 });
 
 // src/config.ts
-import fs3 from "fs-extra";
-import path4 from "path";
+import fs7 from "fs-extra";
+import path9 from "path";
 import { createJiti } from "jiti";
 var ConfigManager;
 var init_config = __esm({
@@ -632,15 +817,11 @@ var init_config = __esm({
     "use strict";
     init_esm_shims();
     init_utils();
+    init_constants();
+    init_utils();
     ConfigManager = class {
       static {
-        this.CONFIG_FILES = [
-          "chatbi.config.ts",
-          "chatbi.config.js",
-          "chatbi.config.json",
-          ".chatbirc",
-          ".chatbirc.json"
-        ];
+        this.CONFIG_FILES = DEFAULT_CONFIG.CONFIG_FILES;
       }
       /**
        * 加载项目配置
@@ -648,10 +829,10 @@ var init_config = __esm({
        */
       static async loadConfig(cwd = process.cwd()) {
         const config = {};
-        const versionFilePath = path4.join(cwd, ".chatbi-version");
-        if (fs3.existsSync(versionFilePath)) {
+        const versionFilePath = path9.join(cwd, SANDBOX_CONFIG.LOCK_FILE);
+        if (fs7.existsSync(versionFilePath)) {
           try {
-            const version = (await fs3.readFile(versionFilePath, "utf-8")).trim();
+            const version = (await fs7.readFile(versionFilePath, "utf-8")).trim();
             if (version) {
               config.coreVersion = version;
             }
@@ -660,15 +841,15 @@ var init_config = __esm({
         }
         const jiti = createJiti(cwd);
         for (const file of this.CONFIG_FILES) {
-          const configPath = path4.join(cwd, file);
-          if (fs3.existsSync(configPath)) {
+          const configPath = path9.join(cwd, file);
+          if (fs7.existsSync(configPath)) {
             try {
               let projectConfig = {};
               if (file.endsWith(".ts") || file.endsWith(".js")) {
                 const mod = await jiti.import(configPath, { default: true });
                 projectConfig = mod.default || mod || {};
               } else if (file.endsWith(".json") || file.startsWith(".chatbirc")) {
-                projectConfig = await fs3.readJson(configPath);
+                projectConfig = await fs7.readJson(configPath);
               }
               return {
                 ...projectConfig,
@@ -681,16 +862,76 @@ var init_config = __esm({
         }
         return config;
       }
+      /**
+       * 解析核心依赖的具体路径或版本号
+       * @param config 项目配置
+       * @param relativeTo 相对路径（用于 local 模式下的 file: 协议生成）
+       */
+      static async resolveCoreDependency(config, relativeTo = ".") {
+        const { coreSource = "local", coreVersion } = config;
+        if (coreSource === "npm") {
+          if (coreVersion) return coreVersion;
+          const cliRoot = await getCliRoot();
+          const cliPkg = await fs7.readJson(path9.join(cliRoot, "package.json"));
+          return cliPkg.version;
+        }
+        const sandboxCorePath = path9.join(SANDBOX_CONFIG.DIRS.CACHE, "core");
+        const cwd = process.cwd();
+        const absoluteRelativeTo = path9.isAbsolute(relativeTo) ? relativeTo : path9.resolve(cwd, relativeTo);
+        const absoluteProjectRoot = cwd;
+        const relativePath = path9.relative(absoluteRelativeTo, path9.join(absoluteProjectRoot, sandboxCorePath));
+        return `file:${relativePath}`;
+      }
+      /**
+       * 加载 tsup 配置
+       * @param cwd 项目根目录
+       */
+      static async loadTsupConfig(cwd = process.cwd()) {
+        const TSUP_CONFIG_FILES = [
+          "tsup.config.ts",
+          "tsup.config.js",
+          "tsup.config.cjs",
+          "tsup.config.mjs",
+          "tsup.config.json"
+        ];
+        const jiti = createJiti(cwd);
+        for (const file of TSUP_CONFIG_FILES) {
+          const configPath = path9.join(cwd, file);
+          if (fs7.existsSync(configPath)) {
+            try {
+              if (file.endsWith(".json")) {
+                return await fs7.readJson(configPath);
+              } else {
+                const mod = await jiti.import(configPath, { default: true });
+                return mod.default || mod || {};
+              }
+            } catch (e) {
+              logger.warn(`\u52A0\u8F7D tsup \u914D\u7F6E\u6587\u4EF6 ${file} \u5931\u8D25: ${e.message}`);
+            }
+          }
+        }
+        const pkgPath = path9.join(cwd, "package.json");
+        if (fs7.existsSync(pkgPath)) {
+          try {
+            const pkg = await fs7.readJson(pkgPath);
+            if (pkg.tsup) {
+              return pkg.tsup;
+            }
+          } catch (e) {
+          }
+        }
+        return {};
+      }
     };
   }
 });
 
 // src/corekit.ts
-import path5 from "path";
-import fs4 from "fs-extra";
-import pc3 from "picocolors";
+import path10 from "path";
+import fs8 from "fs-extra";
+import pc4 from "picocolors";
 import prompts from "prompts";
-import fg2 from "fast-glob";
+import fg3 from "fast-glob";
 var CoreKit;
 var init_corekit = __esm({
   "src/corekit.ts"() {
@@ -704,20 +945,20 @@ var init_corekit = __esm({
        * 解析项目模式
        */
       static async detectMode(cwd) {
-        const pkgPath = path5.join(cwd, "package.json");
-        if (!fs4.existsSync(pkgPath)) return "app";
-        const pkg = await fs4.readJson(pkgPath);
-        if (pkg.workspaces || fs4.existsSync(path5.join(cwd, "pnpm-workspace.yaml"))) {
+        const pkgPath = path10.join(cwd, "package.json");
+        if (!fs8.existsSync(pkgPath)) return "app";
+        const pkg = await fs8.readJson(pkgPath);
+        if (pkg.workspaces || fs8.existsSync(path10.join(cwd, "pnpm-workspace.yaml"))) {
           return "monorepo";
         }
         if (pkg.chatbi?.type === "plugin" || pkg.plugin === true) return "plugin";
         if (pkg.chatbi?.type === "app") return "app";
-        const pluginEntries = await fg2(["index.plugin.{ts,js}", "src/index.plugin.{ts,js}"], { cwd });
+        const pluginEntries = await fg3(["index.plugin.{ts,js}", "src/index.plugin.{ts,js}"], { cwd });
         if (pluginEntries.length > 0) return "plugin";
-        if (fs4.existsSync(path5.join(cwd, "index.html"))) {
+        if (fs8.existsSync(path10.join(cwd, "index.html"))) {
           return "app";
         }
-        if (fs4.existsSync(path5.join(cwd, "src/index.ts")) || fs4.existsSync(path5.join(cwd, "src/index.tsx"))) {
+        if (fs8.existsSync(path10.join(cwd, "src/index.ts")) || fs8.existsSync(path10.join(cwd, "src/index.tsx"))) {
           if (pkg.bin) return "lib";
           if (pkg.peerDependencies?.react && !pkg.dependencies?.react) return "plugin";
           return "lib";
@@ -735,18 +976,18 @@ var init_corekit = __esm({
         }
         try {
           const cliRoot = await getCliRoot();
-          const cliVersionFile = path5.join(cliRoot, ".chatbi-version");
-          if (fs4.existsSync(cliVersionFile)) {
-            const version = (await fs4.readFile(cliVersionFile, "utf-8")).trim();
+          const cliVersionFile = path10.join(cliRoot, ".chatbi-version");
+          if (fs8.existsSync(cliVersionFile)) {
+            const version = (await fs8.readFile(cliVersionFile, "utf-8")).trim();
             if (version) return version;
           }
         } catch (e) {
         }
-        const currentLinkPath = path5.join(Sandbox.getVersionRoot(), "current");
-        if (fs4.existsSync(currentLinkPath)) {
+        const currentLinkPath = path10.join(Sandbox.getVersionRoot(), "current");
+        if (fs8.existsSync(currentLinkPath)) {
           try {
-            const realPath = await fs4.realpath(currentLinkPath);
-            return path5.basename(realPath);
+            const realPath = await fs8.realpath(currentLinkPath);
+            return path10.basename(realPath);
           } catch (e) {
           }
         }
@@ -758,8 +999,8 @@ var init_corekit = __esm({
        */
       static async listVersions() {
         const versionsDir = Sandbox.getVersionRoot();
-        if (!fs4.existsSync(versionsDir)) return [];
-        const dirs = await fg2("*", {
+        if (!fs8.existsSync(versionsDir)) return [];
+        const dirs = await fg3("*", {
           cwd: versionsDir,
           onlyDirectories: true,
           deep: 1
@@ -770,18 +1011,18 @@ var init_corekit = __esm({
        * 自动发现项目中的插件
        */
       static async discoverPlugins(rootDir) {
-        const pluginsDir = path5.join(rootDir, "plugins");
-        if (!fs4.existsSync(pluginsDir)) return [];
-        const pkgFiles = await fg2("*/package.json", { cwd: pluginsDir, absolute: true });
+        const pluginsDir = path10.join(rootDir, "plugins");
+        if (!fs8.existsSync(pluginsDir)) return [];
+        const pkgFiles = await fg3("*/package.json", { cwd: pluginsDir, absolute: true });
         const plugins = [];
         for (const pkgPath of pkgFiles) {
           try {
-            const pkg = await fs4.readJson(pkgPath);
-            const pluginPath = path5.dirname(pkgPath);
+            const pkg = await fs8.readJson(pkgPath);
+            const pluginPath = path10.dirname(pkgPath);
             plugins.push({
-              name: pkg.name || path5.basename(pluginPath),
+              name: pkg.name || path10.basename(pluginPath),
               path: pluginPath,
-              id: path5.basename(pluginPath)
+              id: path10.basename(pluginPath)
             });
           } catch (e) {
           }
@@ -795,19 +1036,19 @@ var init_corekit = __esm({
         const mode = await this.detectMode(cwd);
         const version = await this.resolveVersion(cwd);
         printBox(
-          `${pc3.cyan(pc3.bold("\u{1F680} ChatBI Dev Server"))}
+          `${pc4.cyan(pc4.bold("\u{1F680} ChatBI Dev Server"))}
 
-${pc3.gray("Mode:   ")} ${pc3.yellow(mode)}
-${pc3.gray("Kernel: ")} ${pc3.green(version)}
-${pc3.gray("Root:   ")} ${pc3.white(cwd)}`,
+${pc4.gray("Mode:   ")} ${pc4.yellow(mode)}
+${pc4.gray("Kernel: ")} ${pc4.green(version)}
+${pc4.gray("Root:   ")} ${pc4.white(cwd)}`,
           "Dev Server"
         );
         const spinner = createSpinner("\u6B63\u5728\u51C6\u5907\u6C99\u7BB1\u73AF\u5883...").start();
         try {
           await Sandbox.prepare(version);
-          spinner.text = pc3.cyan("\u6B63\u5728\u6CE8\u5165\u865A\u62DF\u4E0A\u4E0B\u6587...");
+          spinner.text = pc4.cyan("\u6B63\u5728\u6CE8\u5165\u865A\u62DF\u4E0A\u4E0B\u6587...");
           await Sandbox.injectContext(cwd, version);
-          spinner.succeed(pc3.green("\u73AF\u5883\u5C31\u7EEA"));
+          spinner.succeed(pc4.green("\u73AF\u5883\u5C31\u7EEA"));
           if (mode === "plugin") {
             await this.startPluginDevServer(cwd, version, options.port);
           } else if (mode === "app") {
@@ -816,22 +1057,22 @@ ${pc3.gray("Root:   ")} ${pc3.white(cwd)}`,
             await this.startMonorepoDevServer(cwd, version, options.port);
           }
         } catch (e) {
-          spinner.fail(pc3.red(`\u542F\u52A8\u5931\u8D25: ${e.message}`));
+          spinner.fail(pc4.red(`\u542F\u52A8\u5931\u8D25: ${e.message}`));
         }
       }
       /**
        * 启动 Monorepo 开发服务器
        */
       static async startMonorepoDevServer(rootDir, version, customPort) {
-        const appsDir = path5.join(rootDir, "apps");
-        if (!fs4.existsSync(appsDir)) {
+        const appsDir = path10.join(rootDir, "apps");
+        if (!fs8.existsSync(appsDir)) {
           logger.warn("\u5F53\u524D Monorepo \u4E0B\u672A\u627E\u5230 apps/ \u76EE\u5F55");
           return;
         }
-        const pkgFiles = await fg2("*/package.json", { cwd: appsDir, absolute: true });
+        const pkgFiles = await fg3("*/package.json", { cwd: appsDir, absolute: true });
         const apps = pkgFiles.map((pkgPath) => ({
-          name: path5.basename(path5.dirname(pkgPath)),
-          path: path5.dirname(pkgPath)
+          name: path10.basename(path10.dirname(pkgPath)),
+          path: path10.dirname(pkgPath)
         }));
         if (apps.length === 0) {
           logger.warn("\u5F53\u524D Monorepo \u4E0B\u672A\u627E\u5230\u4EFB\u4F55\u5E94\u7528 (apps/)");
@@ -858,14 +1099,14 @@ ${pc3.gray("Root:   ")} ${pc3.white(cwd)}`,
         const shellPort = customPort || 5173;
         const sandboxRoot = Sandbox.getRoot();
         const versionPath = Sandbox.getVersionPath(version);
-        const sandboxNodeModules = path5.join(versionPath, "node_modules");
+        const sandboxNodeModules = path10.join(versionPath, "node_modules");
         const shellDir = await Sandbox.ensureShell(version);
         const coreAlias = Sandbox.getCoreAlias(version);
-        const tailwindPath = path5.join(sandboxNodeModules, "tailwindcss");
-        const autoprefixerPath = path5.join(sandboxNodeModules, "autoprefixer");
-        let pluginEntry = path5.join(pluginDir, "src/index.tsx");
-        if (!fs4.existsSync(pluginEntry)) {
-          pluginEntry = path5.join(pluginDir, "src/index.ts");
+        const tailwindPath = path10.join(sandboxNodeModules, "tailwindcss");
+        const autoprefixerPath = path10.join(sandboxNodeModules, "autoprefixer");
+        let pluginEntry = path10.join(pluginDir, "src/index.tsx");
+        if (!fs8.existsSync(pluginEntry)) {
+          pluginEntry = path10.join(pluginDir, "src/index.ts");
         }
         const define = {
           "process.env.CHATBI_PLUGIN_PATH": JSON.stringify(pluginDir)
@@ -879,12 +1120,12 @@ ${pc3.gray("Root:   ")} ${pc3.white(cwd)}`,
               postcss: {
                 plugins: [
                   __require(tailwindPath)({
-                    presets: [__require(path5.join(sandboxNodeModules, "@chatbi-v/tailwind-config"))],
+                    presets: [__require(path10.join(sandboxNodeModules, "@chatbi-v/tailwind-config"))],
                     darkMode: "class",
                     content: [
-                      path5.join(shellDir, "index.html"),
-                      path5.join(shellDir, "src/**/*.{ts,tsx}"),
-                      path5.join(pluginDir, "src/**/*.{ts,tsx}")
+                      path10.join(shellDir, "index.html"),
+                      path10.join(shellDir, "src/**/*.{ts,tsx}"),
+                      path10.join(pluginDir, "src/**/*.{ts,tsx}")
                     ]
                   }),
                   __require(autoprefixerPath)
@@ -894,25 +1135,33 @@ ${pc3.gray("Root:   ")} ${pc3.white(cwd)}`,
             server: {
               port: shellPort,
               host: true,
+              watch: {
+                // 关键：排除沙箱和软链目录，防止 Vite 挂起
+                ignored: [
+                  "**/.chatbi/**",
+                  "**/node_modules/**",
+                  Sandbox.getRoot()
+                ]
+              },
               fs: {
                 allow: [
                   sandboxRoot,
                   pluginDir,
-                  path5.resolve(pluginDir, "../../")
+                  path10.resolve(pluginDir, "../../")
                 ]
               }
             },
             resolve: {
               alias: {
                 ...coreAlias,
-                "react": path5.join(sandboxNodeModules, "react"),
-                "react-dom": path5.join(sandboxNodeModules, "react-dom"),
-                "@": path5.join(shellDir, "src"),
+                "react": path10.join(sandboxNodeModules, "react"),
+                "react-dom": path10.join(sandboxNodeModules, "react-dom"),
+                "@": path10.join(shellDir, "src"),
                 // 关键：将虚拟模块指向用户插件
                 "virtual:user-plugin": pluginEntry,
                 // 防止 glob 报错，提供空的映射
-                "@chatbi-plugins": path5.join(shellDir, "empty"),
-                "@chatbi-apps": path5.join(shellDir, "empty")
+                "@chatbi-plugins": path10.join(shellDir, "empty"),
+                "@chatbi-apps": path10.join(shellDir, "empty")
               }
             },
             define
@@ -920,9 +1169,9 @@ ${pc3.gray("Root:   ")} ${pc3.white(cwd)}`,
           await server.listen();
           const localUrl = `http://localhost:${shellPort}/`;
           printBox(
-            `${pc3.green(pc3.bold("\u2705 \u6258\u7BA1\u5F0F Shell \u5DF2\u542F\u52A8"))}
+            `${pc4.green(pc4.bold("\u2705 \u6258\u7BA1\u5F0F Shell \u5DF2\u542F\u52A8"))}
 
-${pc3.white("Local: ")} ${pc3.cyan(pc3.underline(localUrl))}`,
+${pc4.white("Local: ")} ${pc4.cyan(pc4.underline(localUrl))}`,
             "Shell Success"
           );
         } catch (e) {
@@ -935,7 +1184,7 @@ ${pc3.white("Local: ")} ${pc3.cyan(pc3.underline(localUrl))}`,
       static async startAppDevServer(appDir, version, customPort) {
         logger.info("\u6B63\u5728\u542F\u52A8\u5E94\u7528...");
         const versionPath = Sandbox.getVersionPath(version);
-        const sandboxNodeModules = path5.join(versionPath, "node_modules");
+        const sandboxNodeModules = path10.join(versionPath, "node_modules");
         const coreAlias = Sandbox.getCoreAlias(version);
         const { createServer, loadConfigFromFile } = await import("vite");
         try {
@@ -949,14 +1198,22 @@ ${pc3.white("Local: ")} ${pc3.cyan(pc3.underline(localUrl))}`,
               alias: {
                 ...coreAlias,
                 // 补充常用的基础依赖映射，防止用户 vite.config.ts 中的插件找不到依赖
-                "react": path5.join(sandboxNodeModules, "react"),
-                "react-dom": path5.join(sandboxNodeModules, "react-dom"),
-                "@vitejs/plugin-react": path5.join(sandboxNodeModules, "@vitejs/plugin-react")
+                "react": path10.join(sandboxNodeModules, "react"),
+                "react-dom": path10.join(sandboxNodeModules, "react-dom"),
+                "@vitejs/plugin-react": path10.join(sandboxNodeModules, "@vitejs/plugin-react")
               }
             },
             server: {
               port: customPort || 3e3,
               host: true,
+              watch: {
+                // 关键：排除沙箱和软链目录，防止 Vite 挂起
+                ignored: [
+                  "**/.chatbi/**",
+                  "**/node_modules/**",
+                  Sandbox.getRoot()
+                ]
+              },
               fs: {
                 allow: [
                   Sandbox.getRoot(),
@@ -970,9 +1227,9 @@ ${pc3.white("Local: ")} ${pc3.cyan(pc3.underline(localUrl))}`,
           await server.listen();
           const localUrl = `http://localhost:${server.config.server.port}/`;
           printBox(
-            `${pc3.green(pc3.bold("\u2705 \u5E94\u7528\u5DF2\u6210\u529F\u542F\u52A8"))}
+            `${pc4.green(pc4.bold("\u2705 \u5E94\u7528\u5DF2\u6210\u529F\u542F\u52A8"))}
 
-${pc3.white("Local: ")} ${pc3.cyan(pc3.underline(localUrl))}`,
+${pc4.white("Local: ")} ${pc4.cyan(pc4.underline(localUrl))}`,
             "App Success"
           );
         } catch (e) {
@@ -989,18 +1246,18 @@ __export(build_exports, {
   build: () => build
 });
 import { execa as execa2 } from "execa";
-import fs5 from "fs-extra";
-import path6 from "path";
-import pc4 from "picocolors";
+import fs9 from "fs-extra";
+import path11 from "path";
+import pc5 from "picocolors";
 import { build as tsupBuild } from "tsup";
 async function build(options) {
   const cwd = process.cwd();
-  const pkgPath = path6.join(cwd, "package.json");
-  if (!fs5.existsSync(pkgPath)) {
+  const pkgPath = path11.join(cwd, "package.json");
+  if (!fs9.existsSync(pkgPath)) {
     logger.error(`\u5728 ${cwd} \u4E2D\u672A\u627E\u5230 package.json`);
     return;
   }
-  const pkg = await fs5.readJson(pkgPath);
+  const pkg = await fs9.readJson(pkgPath);
   if (options.force) {
     const spinnerClean = createSpinner("\u6B63\u5728\u6E05\u7406\u7F13\u5B58\u73AF\u5883...").start();
     try {
@@ -1012,24 +1269,24 @@ async function build(options) {
     }
   }
   const version = await CoreKit.resolveVersion(cwd);
-  logger.info(`\u6B63\u5728\u6784\u5EFA\u9879\u76EE: ${pc4.bold(pkg.name || "unnamed")} (\u5185\u6838\u7248\u672C: ${version})
+  logger.info(`\u6B63\u5728\u6784\u5EFA\u9879\u76EE: ${pc5.bold(pkg.name || "unnamed")} (\u5185\u6838\u7248\u672C: ${version})
 `);
   const spinner = createSpinner("\u6B63\u5728\u51C6\u5907\u6784\u5EFA\u73AF\u5883...").start();
   spinner.text = "\u6B63\u5728\u540C\u6B65\u6C99\u7BB1\u5185\u6838...";
   await Sandbox.prepare(version, options.force);
-  if (pkg.workspaces || fs5.existsSync(path6.join(cwd, "pnpm-workspace.yaml"))) {
+  if (pkg.workspaces || fs9.existsSync(path11.join(cwd, "pnpm-workspace.yaml"))) {
     spinner.text = "\u68C0\u6D4B\u5230 Monorepo\uFF0C\u6B63\u5728\u521D\u59CB\u5316\u6839\u76EE\u5F55\u4E0A\u4E0B\u6587...";
     await Sandbox.injectContext(cwd, version);
     spinner.text = "\u6B63\u5728\u540C\u6B65\u5B50\u5305\u4E0A\u4E0B\u6587...";
     const subDirs = ["apps", "plugins", "packages"];
     for (const dir of subDirs) {
-      const dirPath = path6.join(cwd, dir);
-      if (fs5.existsSync(dirPath)) {
-        const entries = await fs5.readdir(dirPath, { withFileTypes: true });
+      const dirPath = path11.join(cwd, dir);
+      if (fs9.existsSync(dirPath)) {
+        const entries = await fs9.readdir(dirPath, { withFileTypes: true });
         for (const entry2 of entries) {
           if (entry2.isDirectory()) {
-            const subPkgPath = path6.join(dirPath, entry2.name);
-            if (fs5.existsSync(path6.join(subPkgPath, "package.json"))) {
+            const subPkgPath = path11.join(dirPath, entry2.name);
+            if (fs9.existsSync(path11.join(subPkgPath, "package.json"))) {
               await Sandbox.injectContext(subPkgPath, version);
             }
           }
@@ -1043,7 +1300,7 @@ async function build(options) {
   if (pkg.scripts && pkg.scripts.build && !process.env.CHATBI_CLI_INTERNAL) {
     const buildScript = pkg.scripts.build;
     if (!buildScript.includes("chatbi-cli build") && !buildScript.includes("chatbi build")) {
-      logger.info(`\u68C0\u6D4B\u5230\u81EA\u5B9A\u4E49 build \u811A\u672C\uFF0C\u6B63\u5728\u6267\u884C: ${pc4.cyan("npm run build")}`);
+      logger.info(`\u68C0\u6D4B\u5230\u81EA\u5B9A\u4E49 build \u811A\u672C\uFF0C\u6B63\u5728\u6267\u884C: ${pc5.cyan("npm run build")}`);
       const args = ["run", "build"];
       if (options.watch) {
         args.push("--", "--watch");
@@ -1067,7 +1324,7 @@ async function build(options) {
     const coreAlias = Sandbox.getCoreAlias(version);
     await viteBuild({
       root: cwd,
-      configFile: fs5.existsSync(path6.join(cwd, "vite.config.ts")) ? void 0 : false,
+      configFile: fs9.existsSync(path11.join(cwd, "vite.config.ts")) ? void 0 : false,
       resolve: {
         alias: {
           ...coreAlias
@@ -1091,45 +1348,32 @@ async function build(options) {
     });
     if (!options.watch) {
       printBox(
-        pc4.green(pc4.bold("\u2728 \u5E94\u7528\u6784\u5EFA\u6210\u529F!")) + "\n\n" + pc4.white("\u4EA7\u7269\u76EE\u5F55: ") + pc4.cyan("dist"),
+        pc5.green(pc5.bold("\u2728 \u5E94\u7528\u6784\u5EFA\u6210\u529F!")) + "\n\n" + pc5.white("\u4EA7\u7269\u76EE\u5F55: ") + pc5.cyan("dist"),
         "Build Success"
       );
     }
     return;
   }
   let entry = ["src/index.ts"];
-  if (fs5.existsSync(path6.join(cwd, "src/index.tsx"))) {
+  if (fs9.existsSync(path11.join(cwd, "src/index.tsx"))) {
     entry = ["src/index.tsx"];
-  } else if (!fs5.existsSync(path6.join(cwd, "src/index.ts"))) {
+  } else if (!fs9.existsSync(path11.join(cwd, "src/index.ts"))) {
     logger.error("\u672A\u627E\u5230\u5165\u53E3\u6587\u4EF6\u3002\u671F\u671B src/index.ts \u6216 src/index.tsx");
     return;
   }
   const isPlugin = mode === "plugin";
+  const userConfig = await ConfigManager.loadTsupConfig(cwd);
+  if (Object.keys(userConfig).length > 0) {
+    logger.info(`\u5DF2\u52A0\u8F7D\u672C\u5730\u6784\u5EFA\u914D\u7F6E`);
+  }
   if (!options.watch) {
-    await fs5.remove(path6.join(cwd, "dist"));
-    const tsbuildinfo = path6.join(cwd, "tsconfig.tsbuildinfo");
-    if (fs5.existsSync(tsbuildinfo)) {
-      await fs5.remove(tsbuildinfo);
+    await fs9.remove(path11.join(cwd, "dist"));
+    const tsbuildinfo = path11.join(cwd, "tsconfig.tsbuildinfo");
+    if (fs9.existsSync(tsbuildinfo)) {
+      await fs9.remove(tsbuildinfo);
     }
   }
-  const external = [
-    "react",
-    "react-dom",
-    "react/jsx-runtime",
-    "react-is",
-    "antd",
-    "@ant-design/icons",
-    "@ant-design/x",
-    ...Object.keys(pkg.dependencies || {}),
-    ...Object.keys(pkg.peerDependencies || {})
-  ];
   if (isPlugin) {
-    const coreDeps = Sandbox.CORE_PACKAGES;
-    coreDeps.forEach((dep) => {
-      if (!external.includes(dep)) {
-        external.push(dep);
-      }
-    });
   }
   const commonConfig = {
     entry,
@@ -1138,16 +1382,32 @@ async function build(options) {
     sourcemap: false,
     target: "esnext",
     platform: isPlugin ? "browser" : "node",
-    external,
-    minify: !options.watch,
-    // 生产环境开启压缩混淆
+    ...userConfig,
+    // 合并用户配置
+    external: [
+      .../* @__PURE__ */ new Set([
+        "react",
+        "react-dom",
+        "react/jsx-runtime",
+        "react-is",
+        "antd",
+        "@ant-design/icons",
+        "@ant-design/x",
+        ...Object.keys(pkg.dependencies || {}),
+        ...Object.keys(pkg.peerDependencies || {}),
+        ...isPlugin ? Sandbox.CORE_PACKAGES : [],
+        ...Array.isArray(userConfig.external) ? userConfig.external : []
+      ])
+    ],
+    minify: userConfig.minify !== void 0 ? userConfig.minify : !options.watch,
+    // 优先使用用户配置
     watch: options.watch,
     silent: true,
-    esbuildOptions(options2) {
-      options2.logOverride = {
+    esbuildOptions(esbuildOpts) {
+      esbuildOpts.logOverride = {
         "empty-import-meta": "silent"
       };
-      options2.external = options2.external || [];
+      esbuildOpts.external = esbuildOpts.external || [];
       const forceExternal = [
         "react",
         "react-dom",
@@ -1157,10 +1417,13 @@ async function build(options) {
         ...Sandbox.CORE_PACKAGES
       ];
       forceExternal.forEach((dep) => {
-        if (!options2.external.includes(dep)) {
-          options2.external.push(dep);
+        if (!esbuildOpts.external.includes(dep)) {
+          esbuildOpts.external.push(dep);
         }
       });
+      if (typeof userConfig.esbuildOptions === "function") {
+        userConfig.esbuildOptions(esbuildOpts);
+      }
     }
   };
   const buildSpinner = createSpinner("\u6B63\u5728\u7F16\u8BD1\u6E90\u7801...").start();
@@ -1181,25 +1444,7 @@ async function build(options) {
       define: {
         "import.meta.env": "process.env"
       },
-      esbuildOptions(options2) {
-        options2.logOverride = {
-          "empty-import-meta": "silent"
-        };
-        options2.external = options2.external || [];
-        const forceExternal = [
-          "react",
-          "react-dom",
-          "antd",
-          "@ant-design/icons",
-          "@ant-design/x",
-          ...Sandbox.CORE_PACKAGES
-        ];
-        forceExternal.forEach((dep) => {
-          if (!options2.external.includes(dep)) {
-            options2.external.push(dep);
-          }
-        });
-      }
+      esbuildOptions: commonConfig.esbuildOptions
     });
   } else {
     buildSpinner.text = "\u6B63\u5728\u7F16\u8BD1\u6E90\u7801...";
@@ -1215,15 +1460,15 @@ async function build(options) {
   if (!options.watch) {
     const dtsSpinner = createSpinner("\u6B63\u5728\u751F\u6210\u7C7B\u578B\u5B9A\u4E49...").start();
     try {
-      const localTsc = path6.join(cwd, "node_modules/.bin/tsc");
-      const sandboxTsc = path6.join(Sandbox.getVersionPath(version), "node_modules/.bin/tsc");
+      const localTsc = path11.join(cwd, "node_modules/.bin/tsc");
+      const sandboxTsc = path11.join(Sandbox.getVersionPath(version), "node_modules/.bin/tsc");
       let tscBin = "tsc";
-      if (fs5.existsSync(localTsc)) {
+      if (fs9.existsSync(localTsc)) {
         tscBin = localTsc;
-      } else if (fs5.existsSync(sandboxTsc)) {
+      } else if (fs9.existsSync(sandboxTsc)) {
         tscBin = sandboxTsc;
       } else {
-        if (fs5.existsSync(path6.join(cwd, "pnpm-lock.yaml"))) {
+        if (fs9.existsSync(path11.join(cwd, "pnpm-lock.yaml"))) {
           await execa2("pnpm", ["exec", "tsc", "--build", "tsconfig.json"]);
           dtsSpinner.succeed("\u7C7B\u578B\u5B9A\u4E49\u751F\u6210\u5B8C\u6210");
         } else {
@@ -1239,7 +1484,7 @@ async function build(options) {
       dtsSpinner.warn("\u7C7B\u578B\u751F\u6210\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u9879\u76EE\u4E2D\u7684 tsconfig.json \u914D\u7F6E");
     }
     printBox(
-      pc4.green(pc4.bold("\u2728 \u6784\u5EFA\u5B8C\u6210!")) + "\n\n" + pc4.white("\u4EA7\u7269\u76EE\u5F55: ") + pc4.cyan("dist") + "\n" + pc4.white("\u6784\u5EFA\u6A21\u5F0F: ") + pc4.cyan(isPlugin ? "Plugin" : "Library"),
+      pc5.green(pc5.bold("\u2728 \u6784\u5EFA\u5B8C\u6210!")) + "\n\n" + pc5.white("\u4EA7\u7269\u76EE\u5F55: ") + pc5.cyan("dist") + "\n" + pc5.white("\u6784\u5EFA\u6A21\u5F0F: ") + pc5.cyan(isPlugin ? "Plugin" : "Library"),
       "Build Success"
     );
   }
@@ -1250,6 +1495,7 @@ var init_build = __esm({
     init_esm_shims();
     init_sandbox();
     init_corekit();
+    init_config();
     init_utils();
   }
 });
@@ -1259,17 +1505,17 @@ var sync_exports = {};
 __export(sync_exports, {
   sync: () => sync
 });
-import fs6 from "fs-extra";
-import path7 from "path";
-import pc5 from "picocolors";
+import fs10 from "fs-extra";
+import path12 from "path";
+import pc6 from "picocolors";
 async function sync(options = {}) {
   const cwd = options.cwd || process.cwd();
-  const pkgPath = path7.join(cwd, "package.json");
-  if (!fs6.existsSync(pkgPath)) {
+  const pkgPath = path12.join(cwd, "package.json");
+  if (!fs10.existsSync(pkgPath)) {
     logger.error("\u672A\u627E\u5230 package.json\u3002\u8BF7\u5728\u9879\u76EE\u6839\u76EE\u5F55\u4E0B\u8FD0\u884C\u3002");
     return;
   }
-  const pkg = await fs6.readJson(pkgPath);
+  const pkg = await fs10.readJson(pkgPath);
   let version = options.version;
   if (!version) {
     version = await CoreKit.resolveVersion(cwd);
@@ -1284,8 +1530,8 @@ async function sync(options = {}) {
   await Sandbox.prepare(version, options.force);
   mainSpinner.text = "\u6B63\u5728\u751F\u6210\u865A\u62DF\u4E0A\u4E0B\u6587...";
   if (options.version) {
-    const versionFilePath = path7.join(cwd, ".chatbi-version");
-    await fs6.writeFile(versionFilePath, version, "utf-8");
+    const versionFilePath = path12.join(cwd, ".chatbi-version");
+    await fs10.writeFile(versionFilePath, version, "utf-8");
   }
   await Sandbox.injectContext(cwd, version);
   let modified = false;
@@ -1307,19 +1553,19 @@ async function sync(options = {}) {
   if (modified) {
     pkg.dependencies = deps;
     pkg.devDependencies = devDeps;
-    await fs6.writeJson(pkgPath, pkg, { spaces: 2 });
+    await fs10.writeJson(pkgPath, pkg, { spaces: 2 });
     mainSpinner.succeed("\u5185\u6838\u540C\u6B65\u5B8C\u6210 (\u4F9D\u8D56\u5DF2\u4F18\u5316)");
   } else {
     mainSpinner.succeed("\u5185\u6838\u540C\u6B65\u5B8C\u6210");
   }
   if (!options.silent) {
     printBox(
-      `${pc5.green(pc5.bold("\u2728 \u5185\u6838\u540C\u6B65\u6210\u529F!"))}
+      `${pc6.green(pc6.bold("\u2728 \u5185\u6838\u540C\u6B65\u6210\u529F!"))}
 
-${pc5.white("\u5F53\u524D\u7248\u672C: ")} ${pc5.cyan(version)}
-${pc5.white("\u6C99\u7BB1\u8DEF\u5F84: ")} ${pc5.gray(Sandbox.getVersionPath(version))}
+${pc6.white("\u5F53\u524D\u7248\u672C: ")} ${pc6.cyan(version)}
+${pc6.white("\u6C99\u7BB1\u8DEF\u5F84: ")} ${pc6.gray(Sandbox.getVersionPath(version))}
 
-${pc5.white("\u63D0\u793A: ")} \u9879\u76EE\u73B0\u5728\u901A\u8FC7\u865A\u62DF\u522B\u540D\u5F15\u7528\u6838\u5FC3\u5305\uFF0C\u65E0\u9700\u663E\u5F0F\u5B89\u88C5\u4F9D\u8D56\u3002`,
+${pc6.white("\u63D0\u793A: ")} \u9879\u76EE\u73B0\u5728\u901A\u8FC7\u865A\u62DF\u522B\u540D\u5F15\u7528\u6838\u5FC3\u5305\uFF0C\u65E0\u9700\u663E\u5F0F\u5B89\u88C5\u4F9D\u8D56\u3002`,
       "Sync Success"
     );
   }
@@ -1339,13 +1585,12 @@ var init_exports = {};
 __export(init_exports, {
   init: () => init
 });
-import fs7 from "fs-extra";
-import path8 from "path";
-import pc6 from "picocolors";
-import Handlebars2 from "handlebars";
+import fs11 from "fs-extra";
+import path13 from "path";
+import pc7 from "picocolors";
 import prompts2 from "prompts";
 async function init(options) {
-  let { name, template, pluginType = "business", theme = "standard", projectType, includeApp, includePlugin } = options;
+  let { name, pluginType = "business", theme = DEFAULT_CONFIG.THEME, projectType, includeApp, includePlugin, cwd } = options;
   const response = await prompts2([
     // ... (prompts remain the same)
     {
@@ -1415,32 +1660,33 @@ async function init(options) {
   const finalIncludePlugin = includePlugin !== void 0 ? includePlugin : response.includePlugin !== void 0 ? response.includePlugin : true;
   const isAppIncluded = finalIncludeApp;
   const isPluginIncluded = finalIncludePlugin;
-  const rootDir = process.cwd();
-  const targetDir = path8.resolve(rootDir, name);
-  if (fs7.existsSync(targetDir)) {
+  const rootDir = cwd || process.cwd();
+  const targetDir = path13.resolve(rootDir, name);
+  if (fs11.existsSync(targetDir)) {
     logger.error(`\u76EE\u5F55 ${name} \u5DF2\u5B58\u5728\u3002`);
     return;
   }
-  logger.info(`\u6B63\u5728\u521D\u59CB\u5316\u9879\u76EE: ${pc6.bold(name)}...`);
-  logger.info(pc6.gray(`\u7C7B\u578B: ${projectType} | \u4E3B\u9898: ${theme || "N/A"}`));
+  logger.info(`\u6B63\u5728\u521D\u59CB\u5316\u9879\u76EE: ${pc7.bold(name)}...`);
+  logger.info(pc7.gray(`\u7C7B\u578B: ${projectType} | \u4E3B\u9898: ${theme || "N/A"}`));
   console.log("");
   try {
     const myCliRoot = await getCliRoot();
-    const cliPkg = await fs7.readJson(path8.join(myCliRoot, "package.json"));
+    const cliPkg = await fs11.readJson(path13.join(myCliRoot, "package.json"));
     const cliVersion = cliPkg.version;
-    let kernelVersion = cliVersion;
-    const kernelVersionFile = path8.join(myCliRoot, ".chatbi-version");
-    if (fs7.existsSync(kernelVersionFile)) {
-      kernelVersion = (await fs7.readFile(kernelVersionFile, "utf-8")).trim();
+    const config = { coreSource: "npm" };
+    const kernelVersionFile = path13.join(myCliRoot, SANDBOX_CONFIG.LOCK_FILE);
+    if (fs11.existsSync(kernelVersionFile)) {
+      config.coreVersion = (await fs11.readFile(kernelVersionFile, "utf-8")).trim();
     }
+    const kernelVersion = await ConfigManager.resolveCoreDependency(config);
     const renderTemplate = async (templateName, destDir, extraData = {}) => {
-      const srcDir = path8.join(myCliRoot, "templates", templateName);
-      if (!fs7.existsSync(srcDir)) {
+      const srcDir = path13.join(myCliRoot, "templates", templateName);
+      if (!fs11.existsSync(srcDir)) {
         throw new Error(`\u627E\u4E0D\u5230\u6A21\u677F: ${templateName}\uFF0C\u8BF7\u68C0\u67E5\u8DEF\u5F84 ${srcDir} \u662F\u5426\u6B63\u786E\u3002`);
       }
-      await fs7.ensureDir(destDir);
+      await fs11.ensureDir(destDir);
       const templateData = {
-        name: path8.basename(destDir),
+        name: path13.basename(destDir),
         projectName: name,
         // Original project name from CLI argument
         projectTitle: name.split("-").map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join(" "),
@@ -1457,45 +1703,10 @@ async function init(options) {
         isApp: projectType === "app" || isAppIncluded,
         // Zero Dependency Mode: No explicit core path needed in package.json
         // tsconfig extends the virtual paths config
-        tsconfigPath: projectType === "monorepo" ? "../../.chatbi/tsconfig.json" : "./.chatbi/tsconfig.json",
+        tsconfigPath: projectType === "monorepo" ? `../../${SANDBOX_CONFIG.DIRS.CACHE}/tsconfig.json` : `./${SANDBOX_CONFIG.DIRS.CACHE}/tsconfig.json`,
         ...extraData
       };
-      const processFiles = async (currentSrc, currentDest) => {
-        const files = await fs7.readdir(currentSrc);
-        for (const file of files) {
-          if (file === ".DS_Store") continue;
-          const srcPath = path8.join(currentSrc, file);
-          const stats = await fs7.stat(srcPath);
-          if (stats.isDirectory()) {
-            const destPath = path8.join(currentDest, file);
-            await fs7.ensureDir(destPath);
-            await processFiles(srcPath, destPath);
-          } else if (file.endsWith(".hbs")) {
-            const content = await fs7.readFile(srcPath, "utf-8");
-            let result = content;
-            const hasHandlebarsVars = content.includes("{{");
-            if (hasHandlebarsVars) {
-              try {
-                const safeContent = content.replace(/\{\{(?!\s*([#/]?(?:if|else|each|with|unless|name|version|projectName|projectTitle|projectVersion|cliVersion|tsconfigPath|theme|isNebula|isGlass|isBusiness|isApp|isShell|pluginName|pluginPackageName|pluginVersion|pluginDisplayName|pluginDescription|pluginClassName|pluginPath|pluginFolderName|pluginType|pluginId|className))\b)/g, "\\{{");
-                const templateFn = Handlebars2.compile(safeContent);
-                result = templateFn(templateData);
-              } catch (e) {
-                result = content;
-                for (const [key, val] of Object.entries(templateData)) {
-                  const regex = new RegExp(`\\{\\{\\s*${key}\\s*\\}\\}`, "g");
-                  result = result.replace(regex, String(val));
-                }
-              }
-            }
-            const destPath = path8.join(currentDest, file.replace(/\.hbs$/, ""));
-            await fs7.outputFile(destPath, result);
-          } else {
-            const destPath = path8.join(currentDest, file);
-            await fs7.copy(srcPath, destPath);
-          }
-        }
-      };
-      await processFiles(srcDir, destDir);
+      await SandboxRenderer.renderDirectory(srcDir, destDir, templateData);
     };
     const spinner = createSpinner("\u6B63\u5728\u751F\u6210\u9879\u76EE\u7ED3\u6784...").start();
     if (projectType === "monorepo") {
@@ -1503,12 +1714,12 @@ async function init(options) {
       await renderTemplate("monorepo", targetDir, { name });
       if (isAppIncluded) {
         spinner.text = "\u6B63\u5728\u751F\u6210 Host App...";
-        const appDir = path8.join(targetDir, "apps", "main");
+        const appDir = path13.join(targetDir, "apps", "main");
         await renderTemplate("app", appDir, { name: "@chatbi-v/main" });
       }
       if (isPluginIncluded) {
         spinner.text = "\u6B63\u5728\u751F\u6210 Demo Plugin...";
-        const pluginDir = path8.join(targetDir, "plugins", "plugin-demo");
+        const pluginDir = path13.join(targetDir, "plugins", "plugin-demo");
         await renderTemplate("plugin", pluginDir, {
           name: "@chatbi-v/plugin-demo",
           pluginId: "demo",
@@ -1550,15 +1761,15 @@ async function init(options) {
     const cliConfig = {
       coreVersion: kernelVersion
     };
-    await fs7.writeJson(path8.join(targetDir, "chatbi.config.json"), cliConfig, { spaces: 2 });
+    await fs11.writeJson(path13.join(targetDir, "chatbi.config.json"), cliConfig, { spaces: 2 });
     configSpinner.succeed("\u9879\u76EE\u914D\u7F6E\u751F\u6210\u5B8C\u6210");
     printBox(
-      `${pc6.green(pc6.bold("\u2728 \u9879\u76EE\u5DF2\u6210\u529F\u521B\u5EFA!"))}
+      `${pc7.green(pc7.bold("\u2728 \u9879\u76EE\u5DF2\u6210\u529F\u521B\u5EFA!"))}
 
-${pc6.white("\u63A5\u4E0B\u6765\u4F60\u53EF\u4EE5:")}
-${pc6.cyan(`  cd ${name}`)}
-${pc6.cyan("  pnpm install")}
-${pc6.cyan("  pnpm dev")}`,
+${pc7.white("\u63A5\u4E0B\u6765\u4F60\u53EF\u4EE5:")}
+${pc7.cyan(`  cd ${name}`)}
+${pc7.cyan("  pnpm install")}
+${pc7.cyan("  pnpm dev")}`,
       "Success"
     );
   } catch (error) {
@@ -1572,6 +1783,9 @@ var init_init = __esm({
     init_esm_shims();
     init_utils();
     init_sync();
+    init_constants();
+    init_config();
+    init_SandboxRenderer();
   }
 });
 
@@ -1580,34 +1794,34 @@ var fetch_exports = {};
 __export(fetch_exports, {
   fetch: () => fetch
 });
-import path13 from "path";
-import pc12 from "picocolors";
+import path18 from "path";
+import pc13 from "picocolors";
 import { execa as execa4 } from "execa";
 async function fetch(version, options = {}) {
-  const fetchSpinner = createSpinner(`\u6B63\u5728\u83B7\u53D6\u5185\u6838\u7248\u672C ${pc12.cyan(version)}...`).start();
+  const fetchSpinner = createSpinner(`\u6B63\u5728\u83B7\u53D6\u5185\u6838\u7248\u672C ${pc13.cyan(version)}...`).start();
   const versionPath = await Sandbox.prepare(version, true);
-  fetchSpinner.succeed(`\u5185\u6838\u7248\u672C ${pc12.cyan(version)} \u83B7\u53D6\u6210\u529F`);
+  fetchSpinner.succeed(`\u5185\u6838\u7248\u672C ${pc13.cyan(version)} \u83B7\u53D6\u6210\u529F`);
   if (options.pack) {
     const packSpinner = createSpinner("\u6B63\u5728\u6253\u5305\u79BB\u7EBF\u8D44\u6E90...").start();
     const tgzName = `chatbi-core-${version}.tgz`;
-    const tgzPath = path13.resolve(process.cwd(), tgzName);
+    const tgzPath = path18.resolve(process.cwd(), tgzName);
     await execa4("tar", [
       "-czf",
       tgzPath,
       "-C",
-      path13.dirname(versionPath),
-      path13.basename(versionPath)
+      path18.dirname(versionPath),
+      path18.basename(versionPath)
     ]);
     packSpinner.succeed("\u79BB\u7EBF\u8D44\u6E90\u6253\u5305\u5B8C\u6210");
     printBox(
-      `${pc12.green(pc12.bold("\u2728 \u79BB\u7EBF\u5305\u5DF2\u751F\u6210!"))}
+      `${pc13.green(pc13.bold("\u2728 \u79BB\u7EBF\u5305\u5DF2\u751F\u6210!"))}
 
-${pc12.white("\u6587\u4EF6\u8DEF\u5F84: ")} ${pc12.cyan(tgzPath)}
-${pc12.white("\u5B89\u88C5\u547D\u4EE4: ")} ${pc12.gray(`chatbi install ${tgzName}`)}`,
+${pc13.white("\u6587\u4EF6\u8DEF\u5F84: ")} ${pc13.cyan(tgzPath)}
+${pc13.white("\u5B89\u88C5\u547D\u4EE4: ")} ${pc13.gray(`chatbi install ${tgzName}`)}`,
       "Pack Success"
     );
   } else {
-    logger.success(`\u5185\u6838\u7248\u672C ${pc12.cyan(version)} \u5DF2\u51C6\u5907\u5C31\u7EEA\u3002`);
+    logger.success(`\u5185\u6838\u7248\u672C ${pc13.cyan(version)} \u5DF2\u51C6\u5907\u5C31\u7EEA\u3002`);
   }
 }
 var init_fetch = __esm({
@@ -1624,24 +1838,24 @@ var bench_exports = {};
 __export(bench_exports, {
   bench: () => bench
 });
-import pc14 from "picocolors";
-import fs13 from "fs-extra";
-import path15 from "path";
+import pc15 from "picocolors";
+import fs17 from "fs-extra";
+import path20 from "path";
 import os2 from "os";
 async function bench() {
   logger.info("\u6B63\u5728\u542F\u52A8 CLI \u6027\u80FD\u57FA\u51C6\u6D4B\u8BD5...");
   const results = [];
-  const tmpDir = path15.join(os2.tmpdir(), `chatbi-bench-${Date.now()}`);
-  await fs13.ensureDir(tmpDir);
+  const tmpDir = path20.join(os2.tmpdir(), `chatbi-bench-${Date.now()}`);
+  await fs17.ensureDir(tmpDir);
   try {
     const initSpinner = createSpinner("\u6B63\u5728\u6D4B\u8BD5: \u521D\u59CB\u5316\u63D2\u4EF6\u9879\u76EE (init)...").start();
     const startInit = Date.now();
     const { init: init2 } = await Promise.resolve().then(() => (init_init(), init_exports));
-    const testProjDir = path15.join(tmpDir, "bench-proj");
+    const testProjDir = path20.join(tmpDir, "bench-proj");
     await init2({ name: "bench-proj", projectType: "plugin", cwd: tmpDir });
     const endInit = Date.now();
     const initTime = (endInit - startInit) / 1e3;
-    initSpinner.succeed(`\u521D\u59CB\u5316\u5B8C\u6210: ${pc14.cyan(initTime.toFixed(2) + "s")}`);
+    initSpinner.succeed(`\u521D\u59CB\u5316\u5B8C\u6210: ${pc15.cyan(initTime.toFixed(2) + "s")}`);
     results.push({
       scene: "\u521D\u59CB\u5316\u63D2\u4EF6\u9879\u76EE (init)",
       target: "\u2264 5.0 s",
@@ -1653,7 +1867,7 @@ async function bench() {
     await sync2({ cwd: testProjDir });
     const endSync = Date.now();
     const syncTime = (endSync - startSync) / 1e3;
-    syncSpinner.succeed(`\u540C\u6B65\u5B8C\u6210: ${pc14.cyan(syncTime.toFixed(2) + "s")}`);
+    syncSpinner.succeed(`\u540C\u6B65\u5B8C\u6210: ${pc15.cyan(syncTime.toFixed(2) + "s")}`);
     results.push({
       scene: "\u6C99\u7BB1\u73AF\u5883\u540C\u6B65 (sync)",
       target: "\u2264 2.0 s",
@@ -1668,20 +1882,20 @@ async function bench() {
     process.chdir(originalCwd);
     const endBuild = Date.now();
     const buildTime = (endBuild - startBuild) / 1e3;
-    buildSpinner.succeed(`\u6784\u5EFA\u5B8C\u6210: ${pc14.cyan(buildTime.toFixed(2) + "s")}`);
+    buildSpinner.succeed(`\u6784\u5EFA\u5B8C\u6210: ${pc15.cyan(buildTime.toFixed(2) + "s")}`);
     results.push({
       scene: "\u63D2\u4EF6\u9879\u76EE\u6784\u5EFA (build)",
       target: "\u2264 10.0 s",
       actual: `${buildTime.toFixed(2)} s`
     });
     printBox(
-      `${pc14.green(pc14.bold("\u2728 \u57FA\u51C6\u6D4B\u8BD5\u5B8C\u6210!"))}
+      `${pc15.green(pc15.bold("\u2728 \u57FA\u51C6\u6D4B\u8BD5\u5B8C\u6210!"))}
 
-` + results.map((r) => `${pc14.white(r.scene.padEnd(20))}: ${pc14.cyan(r.actual)} (\u76EE\u6807 ${r.target})`).join("\n"),
+` + results.map((r) => `${pc15.white(r.scene.padEnd(20))}: ${pc15.cyan(r.actual)} (\u76EE\u6807 ${r.target})`).join("\n"),
       "Benchmark Results"
     );
   } finally {
-    await fs13.remove(tmpDir);
+    await fs17.remove(tmpDir);
   }
 }
 var init_bench = __esm({
@@ -1696,7 +1910,7 @@ var init_bench = __esm({
 init_esm_shims();
 init_build();
 import cac from "cac";
-import pc15 from "picocolors";
+import pc16 from "picocolors";
 import figlet from "figlet";
 import gradient from "gradient-string";
 import boxen2 from "boxen";
@@ -1716,20 +1930,21 @@ init_init();
 init_esm_shims();
 init_utils();
 init_config();
-import fs8 from "fs-extra";
-import path9 from "path";
-import pc7 from "picocolors";
+init_constants();
+init_SandboxRenderer();
+import fs12 from "fs-extra";
+import path14 from "path";
+import pc8 from "picocolors";
 import prompts3 from "prompts";
-import Handlebars3 from "handlebars";
 async function add(options) {
   let { name, type, displayName, description } = options;
   const cwd = process.cwd();
-  const pkgPath = path9.join(cwd, "package.json");
-  if (!fs8.existsSync(pkgPath)) {
+  const pkgPath = path14.join(cwd, "package.json");
+  if (!fs12.existsSync(pkgPath)) {
     logger.error("\u672A\u627E\u5230 package.json\u3002\u8BF7\u5728 ChatBI-V \u9879\u76EE\u6839\u76EE\u5F55\u4E0B\u8FD0\u884C\u6B64\u547D\u4EE4\u3002");
     return;
   }
-  const pkg = await fs8.readJson(pkgPath);
+  const pkg = await fs12.readJson(pkgPath);
   const isMonorepo = pkg.workspaces && (pkg.workspaces.includes("plugins/*") || pkg.workspaces.packages?.includes("plugins/*"));
   if (!isMonorepo) {
     logger.error("\u5F53\u524D\u4E0D\u662F Monorepo \u9879\u76EE\uFF0C\u65E0\u6CD5\u6DFB\u52A0\u63D2\u4EF6 (\u8BF7\u5728\u5305\u542B plugins/ \u5DE5\u4F5C\u7A7A\u95F4\u7684\u9879\u76EE\u4E2D\u8FD0\u884C)");
@@ -1780,31 +1995,22 @@ async function add(options) {
     cleanName = cleanName.replace(/-plugin$/, "");
   }
   const folderName = cleanName.startsWith("plugin-") ? cleanName : `plugin-${cleanName}`;
-  const pluginDir = path9.resolve(cwd, "plugins", folderName);
-  if (fs8.existsSync(pluginDir)) {
+  const pluginDir = path14.resolve(cwd, "plugins", folderName);
+  if (fs12.existsSync(pluginDir)) {
     logger.error(`\u63D2\u4EF6\u76EE\u5F55 ${folderName} \u5DF2\u5B58\u5728\u3002`);
     return;
   }
-  const spinner = createSpinner(`\u6B63\u5728\u6DFB\u52A0\u65B0\u63D2\u4EF6: ${pc7.bold(name)}...`).start();
+  const spinner = createSpinner(`\u6B63\u5728\u6DFB\u52A0\u65B0\u63D2\u4EF6: ${pc8.bold(name)}...`).start();
   const myCliRoot = await getCliRoot();
-  const templateDir = path9.join(myCliRoot, "templates/plugin");
-  if (!fs8.existsSync(templateDir)) {
+  const templateDir = path14.join(myCliRoot, "templates/plugin");
+  if (!fs12.existsSync(templateDir)) {
     spinner.fail("\u627E\u4E0D\u5230\u63D2\u4EF6\u6A21\u677F");
     throw new Error(`\u627E\u4E0D\u5230\u63D2\u4EF6\u6A21\u677F: ${templateDir}`);
   }
   const targetDir = pluginDir;
   spinner.text = "\u6B63\u5728\u52A0\u8F7D\u914D\u7F6E...";
   const config = await ConfigManager.loadConfig(cwd);
-  const coreSource = config.coreSource || "local";
-  let corePath = "file:../../.chatbi/core";
-  if (coreSource === "npm") {
-    if (!config.coreVersion) {
-      const cliPkg = await fs8.readJson(path9.join(myCliRoot, "package.json"));
-      corePath = cliPkg.version;
-    } else {
-      corePath = config.coreVersion;
-    }
-  }
+  const corePath = await ConfigManager.resolveCoreDependency(config, pluginDir);
   const data = {
     // 兼容旧模板
     name: `@chatbi-v/${folderName}`,
@@ -1823,55 +2029,20 @@ async function add(options) {
     pluginPath: folderName,
     pluginFolderName: folderName,
     // Fix: 注入 tsconfigPath，确保 tsconfig.json 能正确 extend
-    tsconfigPath: "../../.chatbi/tsconfig.json"
-  };
-  const renderFile = async (src, dest) => {
-    const content = await fs8.readFile(src, "utf-8");
-    let result = content;
-    const hasHandlebarsVars = content.includes("{{");
-    if (hasHandlebarsVars) {
-      try {
-        const safeContent = content.replace(/\{\{(?!\s*([#/]?(?:if|else|each|with|unless|name|version|projectName|projectTitle|projectVersion|cliVersion|tsconfigPath|theme|isNebula|isGlass|isBusiness|isApp|isShell|pluginName|pluginPackageName|pluginVersion|pluginDisplayName|pluginDescription|pluginClassName|pluginPath|pluginFolderName|pluginType|pluginId|className))\b)/g, "\\{{");
-        const templateFn = Handlebars3.compile(safeContent);
-        result = templateFn(data);
-      } catch (e) {
-        result = content;
-        for (const [key, val] of Object.entries(data)) {
-          const regex = new RegExp(`\\{\\{\\s*${key}\\s*\\}\\}`, "g");
-          result = result.replace(regex, String(val));
-        }
-      }
-    }
-    await fs8.outputFile(dest.replace(".hbs", ""), result);
-  };
-  const processTemplates = async (currentSrc, currentDest) => {
-    const files = await fs8.readdir(currentSrc);
-    for (const file of files) {
-      const srcPath = path9.join(currentSrc, file);
-      const destPath = path9.join(currentDest, file);
-      const stats = await fs8.stat(srcPath);
-      if (stats.isDirectory()) {
-        await fs8.ensureDir(destPath);
-        await processTemplates(srcPath, destPath);
-      } else if (file.endsWith(".hbs")) {
-        await renderFile(srcPath, destPath);
-      } else {
-        await fs8.copy(srcPath, destPath);
-      }
-    }
+    tsconfigPath: `../../${SANDBOX_CONFIG.DIRS.CACHE}/tsconfig.json`
   };
   spinner.text = "\u6B63\u5728\u751F\u6210\u63D2\u4EF6\u6587\u4EF6...";
-  await processTemplates(templateDir, targetDir);
-  spinner.succeed(`\u63D2\u4EF6 ${pc7.bold(name)} \u6DFB\u52A0\u6210\u529F\uFF01`);
+  await SandboxRenderer.renderDirectory(templateDir, targetDir, data);
+  spinner.succeed(`\u63D2\u4EF6 ${pc8.bold(name)} \u6DFB\u52A0\u6210\u529F\uFF01`);
   printBox(
-    `${pc7.green(pc7.bold("\u2728 \u63D2\u4EF6\u521B\u5EFA\u6210\u529F!"))}
+    `${pc8.green(pc8.bold("\u2728 \u63D2\u4EF6\u521B\u5EFA\u6210\u529F!"))}
 
-${pc7.white("\u9879\u76EE\u8DEF\u5F84: ")} ${pc7.cyan(`plugins/${folderName}`)}
-${pc7.white("\u63D2\u4EF6 ID:   ")} ${pc7.cyan(cleanName)}
-${pc7.white("\u63D2\u4EF6\u7C7B\u578B: ")} ${pc7.cyan(type)}
+${pc8.white("\u9879\u76EE\u8DEF\u5F84: ")} ${pc8.cyan(`plugins/${folderName}`)}
+${pc8.white("\u63D2\u4EF6 ID:   ")} ${pc8.cyan(cleanName)}
+${pc8.white("\u63D2\u4EF6\u7C7B\u578B: ")} ${pc8.cyan(type)}
 
-${pc7.white("\u63A5\u4E0B\u6765\u4F60\u53EF\u4EE5:")}
-${pc7.cyan("  pnpm dev")}  \u542F\u52A8\u5F00\u53D1\u73AF\u5883\u67E5\u770B\u6548\u679C`,
+${pc8.white("\u63A5\u4E0B\u6765\u4F60\u53EF\u4EE5:")}
+${pc8.cyan("  pnpm dev")}  \u542F\u52A8\u5F00\u53D1\u73AF\u5883\u67E5\u770B\u6548\u679C`,
     "Plugin Created"
   );
 }
@@ -1879,16 +2050,16 @@ ${pc7.cyan("  pnpm dev")}  \u542F\u52A8\u5F00\u53D1\u73AF\u5883\u67E5\u770B\u654
 // src/commands/gl.ts
 init_esm_shims();
 init_utils();
-import fs9 from "fs-extra";
-import path10 from "path";
-import pc8 from "picocolors";
+import fs13 from "fs-extra";
+import path15 from "path";
+import pc9 from "picocolors";
 import prompts4 from "prompts";
 import { execa as execa3 } from "execa";
 async function gl(options) {
   const { type: initialType, prompt: initialPrompt } = options;
   const cwd = process.cwd();
-  const pkgPath = path10.join(cwd, "package.json");
-  if (!fs9.existsSync(pkgPath)) {
+  const pkgPath = path15.join(cwd, "package.json");
+  if (!fs13.existsSync(pkgPath)) {
     logger.error("\u672A\u627E\u5230 package.json\u3002\u8BF7\u5728 ChatBI-V \u9879\u76EE\u6839\u76EE\u5F55\u4E0B\u8FD0\u884C\u6B64\u547D\u4EE4\u3002");
     return;
   }
@@ -1927,7 +2098,7 @@ async function gl(options) {
     logger.error("\u9700\u6C42\u63CF\u8FF0\u4E0D\u80FD\u4E3A\u7A7A\u3002");
     return;
   }
-  logger.info(`\u6B63\u5728\u547C\u53EB AI \u5F15\u64CE [\u6A21\u5F0F: ${pc8.bold(genType)}]...`);
+  logger.info(`\u6B63\u5728\u547C\u53EB AI \u5F15\u64CE [\u6A21\u5F0F: ${pc9.bold(genType)}]...`);
   const toolsContext = `
 [Available Tools & Capabilities]
 - Tool: plugin -> For creating new feature modules. Requires: name, type (business|system).
@@ -1990,7 +2161,7 @@ If not, use the SLOT_REQUIRED format.`.trim();
           }
         }
         if (slots.length > 0) {
-          logger.info(pc8.yellow("\n\u{1F4DD} AI \u9700\u8981\u66F4\u591A\u4FE1\u606F\u4EE5\u7EE7\u7EED:"));
+          logger.info(pc9.yellow("\n\u{1F4DD} AI \u9700\u8981\u66F4\u591A\u4FE1\u606F\u4EE5\u7EE7\u7EED:"));
           const answers = await prompts4(slots, {
             onCancel: () => process.exit(0)
           });
@@ -2012,7 +2183,7 @@ Please proceed with generation based on these answers.`;
       spinner.stop();
       if (error.code === "ENOENT") {
         logger.error("\u672A\u5728\u7CFB\u7EDF\u4E2D\u627E\u5230 `gemini-cli` \u547D\u4EE4\u3002");
-        logger.info(pc8.yellow("\u8BF7\u786E\u4FDD\u5DF2\u5B89\u88C5 gemini-cli \u5E76\u5C06\u5176\u6DFB\u52A0\u5230\u7CFB\u7EDF PATH \u4E2D\u3002"));
+        logger.info(pc9.yellow("\u8BF7\u786E\u4FDD\u5DF2\u5B89\u88C5 gemini-cli \u5E76\u5C06\u5176\u6DFB\u52A0\u5230\u7CFB\u7EDF PATH \u4E2D\u3002"));
       } else {
         logger.error(`AI \u751F\u6210\u8FC7\u7A0B\u4E2D\u51FA\u9519: ${error.message}`);
       }
@@ -2029,16 +2200,16 @@ init_esm_shims();
 init_utils();
 init_sandbox();
 init_corekit();
-import fs10 from "fs-extra";
-import path11 from "path";
-import pc9 from "picocolors";
+import fs14 from "fs-extra";
+import path16 from "path";
+import pc10 from "picocolors";
 import glob from "fast-glob";
 async function doctor(options = {}) {
   logger.info("\u6B63\u5728\u8BCA\u65AD\u9879\u76EE\u5065\u5EB7\u72B6\u51B5...\n");
   const cwd = process.cwd();
   let hasIssues = false;
   const issues = [];
-  logger.info(pc9.bold("Step 1: \u68C0\u67E5\u57FA\u7840\u73AF\u5883..."));
+  logger.info(pc10.bold("Step 1: \u68C0\u67E5\u57FA\u7840\u73AF\u5883..."));
   const nodeVersion = process.version;
   if (parseInt(nodeVersion.slice(1).split(".")[0]) < 18) {
     logger.error(`Node.js \u7248\u672C\u592A\u4F4E: ${nodeVersion} (\u8981\u6C42 >=18)`);
@@ -2054,41 +2225,41 @@ async function doctor(options = {}) {
   } catch (e) {
     logger.warn("\u672A\u68C0\u6D4B\u5230 pnpm\uFF0C\u5EFA\u8BAE\u5B89\u88C5\u4EE5\u83B7\u5F97\u6700\u4F73\u4F53\u9A8C");
   }
-  logger.info(pc9.bold("\nStep 2: \u68C0\u67E5\u5185\u6838\u6C99\u7BB1\u73AF\u5883..."));
+  logger.info(pc10.bold("\nStep 2: \u68C0\u67E5\u5185\u6838\u6C99\u7BB1\u73AF\u5883..."));
   const version = await CoreKit.resolveVersion(cwd);
   const versionPath = Sandbox.getVersionPath(version);
-  if (!fs10.existsSync(versionPath)) {
+  if (!fs14.existsSync(versionPath)) {
     logger.error(`\u5185\u6838\u6C99\u7BB1\u7248\u672C ${version} \u5C1A\u672A\u5B89\u88C5`);
-    console.log(pc9.gray(`   \u5EFA\u8BAE\u8FD0\u884C 'chatbi sync' \u6216 'chatbi use ${version}' \u8FDB\u884C\u5B89\u88C5\u3002`));
+    console.log(pc10.gray(`   \u5EFA\u8BAE\u8FD0\u884C 'chatbi sync' \u6216 'chatbi use ${version}' \u8FDB\u884C\u5B89\u88C5\u3002`));
     hasIssues = true;
     issues.push(`\u5185\u6838\u6C99\u7BB1\u672A\u5B89\u88C5 (${version})`);
   } else {
     logger.success(`\u5185\u6838\u6C99\u7BB1\u5C31\u7EEA (\u7248\u672C: ${version})`);
-    const sandboxNm = path11.join(versionPath, "node_modules");
-    if (!fs10.existsSync(sandboxNm)) {
+    const sandboxNm = path16.join(versionPath, "node_modules");
+    if (!fs14.existsSync(sandboxNm)) {
       logger.warn("\u6C99\u7BB1\u4F9D\u8D56\u672A\u5B89\u88C5\uFF0C\u5C06\u5BFC\u81F4\u6784\u5EFA\u5931\u8D25");
       hasIssues = true;
       issues.push("\u6C99\u7BB1\u4F9D\u8D56\u7F3A\u5931");
     }
     const missingDeps = [];
     for (const dep of Sandbox.CORE_PACKAGES) {
-      if (!fs10.existsSync(path11.join(sandboxNm, dep))) {
+      if (!fs14.existsSync(path16.join(sandboxNm, dep))) {
         missingDeps.push(dep);
       }
     }
     if (missingDeps.length > 0) {
     }
   }
-  logger.info(pc9.bold("\nStep 3: \u68C0\u67E5\u865A\u62DF\u4F9D\u8D56\u6620\u5C04..."));
-  const chatbiDir = path11.join(cwd, ".chatbi");
-  if (!fs10.existsSync(chatbiDir)) {
+  logger.info(pc10.bold("\nStep 3: \u68C0\u67E5\u865A\u62DF\u4F9D\u8D56\u6620\u5C04..."));
+  const chatbiDir = path16.join(cwd, ".chatbi");
+  if (!fs14.existsSync(chatbiDir)) {
     logger.warn("\u672A\u53D1\u73B0\u865A\u62DF\u4F9D\u8D56\u914D\u7F6E (.chatbi \u76EE\u5F55)");
     hasIssues = true;
     issues.push("\u7F3A\u5931 .chatbi \u76EE\u5F55");
   } else {
-    const pathsJson = path11.join(chatbiDir, "tsconfig.paths.json");
-    const aliasJson = path11.join(chatbiDir, "vite.alias.json");
-    if (!fs10.existsSync(pathsJson) || !fs10.existsSync(aliasJson)) {
+    const pathsJson = path16.join(chatbiDir, "tsconfig.paths.json");
+    const aliasJson = path16.join(chatbiDir, "vite.alias.json");
+    if (!fs14.existsSync(pathsJson) || !fs14.existsSync(aliasJson)) {
       logger.warn("\u865A\u62DF\u4F9D\u8D56\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B8C\u6574");
       hasIssues = true;
       issues.push("\u865A\u62DF\u4F9D\u8D56\u914D\u7F6E\u4E0D\u5B8C\u6574");
@@ -2096,10 +2267,10 @@ async function doctor(options = {}) {
       logger.success("\u865A\u62DF\u4F9D\u8D56\u914D\u7F6E\u5DF2\u751F\u6210");
     }
   }
-  const tsConfigPath = path11.join(cwd, "tsconfig.json");
-  if (fs10.existsSync(tsConfigPath)) {
+  const tsConfigPath = path16.join(cwd, "tsconfig.json");
+  if (fs14.existsSync(tsConfigPath)) {
     try {
-      const tsConfig = await fs10.readJson(tsConfigPath);
+      const tsConfig = await fs14.readJson(tsConfigPath);
       const extendsPath = tsConfig.extends;
       const expectedPaths = ["./.chatbi/tsconfig.paths.json", ".chatbi/tsconfig.paths.json"];
       let hasExtend = false;
@@ -2119,14 +2290,14 @@ async function doctor(options = {}) {
       logger.error("\u89E3\u6790 tsconfig.json \u5931\u8D25");
     }
   }
-  const viteConfigPath = path11.join(cwd, "vite.config.ts");
-  if (fs10.existsSync(viteConfigPath)) {
-    const content = await fs10.readFile(viteConfigPath, "utf-8");
+  const viteConfigPath = path16.join(cwd, "vite.config.ts");
+  if (fs14.existsSync(viteConfigPath)) {
+    const content = await fs14.readFile(viteConfigPath, "utf-8");
     if (!content.includes("vite.alias.json")) {
       logger.warn("vite.config.ts \u53EF\u80FD\u672A\u52A0\u8F7D\u865A\u62DF\u522B\u540D\u914D\u7F6E");
     }
   }
-  logger.info(pc9.bold("\nStep 4: \u626B\u63CF\u4EE3\u7801\u89C4\u5219..."));
+  logger.info(pc10.bold("\nStep 4: \u626B\u63CF\u4EE3\u7801\u89C4\u5219..."));
   const rules = [
     {
       id: "plugin-lifecycle-init",
@@ -2146,7 +2317,7 @@ async function doctor(options = {}) {
   if (files.length > 0) {
     const scanSpinner = createSpinner(`\u6B63\u5728\u626B\u63CF ${files.length} \u4E2A\u6587\u4EF6...`).start();
     for (const file of files) {
-      const content = await fs10.readFile(file, "utf-8");
+      const content = await fs14.readFile(file, "utf-8");
       for (const rule of rules) {
         if (rule.pattern.test(content)) {
           codeIssues.push({
@@ -2162,7 +2333,7 @@ async function doctor(options = {}) {
       scanSpinner.fail(`\u53D1\u73B0 ${codeIssues.length} \u4E2A\u4EE3\u7801\u89C4\u8303\u95EE\u9898`);
       hasIssues = true;
       codeIssues.forEach((issue) => {
-        const relativePath = path11.relative(cwd, issue.file);
+        const relativePath = path16.relative(cwd, issue.file);
         issues.push(`\u4EE3\u7801\u89C4\u8303 [${issue.ruleId}]: ${relativePath}`);
       });
     } else {
@@ -2171,26 +2342,26 @@ async function doctor(options = {}) {
   }
   if (!hasIssues) {
     printBox(
-      pc9.green(pc9.bold("\u2728 \u8BCA\u65AD\u5B8C\u6210\uFF1A\u9879\u76EE\u4E00\u5207\u6B63\u5E38\uFF01")),
+      pc10.green(pc10.bold("\u2728 \u8BCA\u65AD\u5B8C\u6210\uFF1A\u9879\u76EE\u4E00\u5207\u6B63\u5E38\uFF01")),
       "Doctor Report"
     );
   } else {
-    const issueList = issues.map((i) => pc9.red(`\u2022 ${i}`)).join("\n");
+    const issueList = issues.map((i) => pc10.red(`\u2022 ${i}`)).join("\n");
     printBox(
-      `${pc9.yellow(pc9.bold("\u26A0\uFE0F \u8BCA\u65AD\u5B8C\u6210\uFF1A\u53D1\u73B0\u4EE5\u4E0B\u95EE\u9898"))}
+      `${pc10.yellow(pc10.bold("\u26A0\uFE0F \u8BCA\u65AD\u5B8C\u6210\uFF1A\u53D1\u73B0\u4EE5\u4E0B\u95EE\u9898"))}
 
 ${issueList}
 
-${pc9.cyan("\u5EFA\u8BAE\u6839\u636E\u63D0\u793A\u8FDB\u884C\u4FEE\u590D")}`,
+${pc10.cyan("\u5EFA\u8BAE\u6839\u636E\u63D0\u793A\u8FDB\u884C\u4FEE\u590D")}`,
       "Doctor Report"
     );
     if (options.fix) {
       if (codeIssues.length > 0) {
         const fixSpinner = createSpinner("\u6B63\u5728\u4FEE\u590D\u4EE3\u7801\u89C4\u8303\u95EE\u9898...").start();
         for (const issue of codeIssues) {
-          const content = await fs10.readFile(issue.file, "utf-8");
+          const content = await fs14.readFile(issue.file, "utf-8");
           const newContent = issue.rule.fix(content);
-          await fs10.writeFile(issue.file, newContent);
+          await fs14.writeFile(issue.file, newContent);
         }
         fixSpinner.succeed("\u4EE3\u7801\u4FEE\u590D\u5B8C\u6210");
       }
@@ -2206,20 +2377,20 @@ ${pc9.cyan("\u5EFA\u8BAE\u6839\u636E\u63D0\u793A\u8FDB\u884C\u4FEE\u590D")}`,
 init_esm_shims();
 init_corekit();
 init_utils();
-import pc10 from "picocolors";
+import pc11 from "picocolors";
 async function discover() {
   const cwd = process.cwd();
   const spinner = createSpinner("\u6B63\u5728\u626B\u63CF\u9879\u76EE\u4E2D\u7684\u63D2\u4EF6...").start();
   const plugins = await CoreKit.discoverPlugins(cwd);
   if (plugins.length === 0) {
     spinner.warn("\u672A\u53D1\u73B0\u4EFB\u4F55\u63D2\u4EF6");
-    logger.info(pc10.gray("\u8BF7\u786E\u4FDD\u63D2\u4EF6\u4F4D\u4E8E plugins/ \u76EE\u5F55\u4E0B\uFF0C\u4E14\u5305\u542B package.json\u3002"));
+    logger.info(pc11.gray("\u8BF7\u786E\u4FDD\u63D2\u4EF6\u4F4D\u4E8E plugins/ \u76EE\u5F55\u4E0B\uFF0C\u4E14\u5305\u542B package.json\u3002"));
   } else {
-    spinner.succeed(`\u53D1\u73B0\u4E86 ${pc10.cyan(plugins.length)} \u4E2A\u63D2\u4EF6`);
-    const pluginList = plugins.map((p) => `- ${pc10.bold(p.name)} ${pc10.gray(`(${p.id})`)}
-  ${pc10.gray(p.path)}`).join("\n\n");
+    spinner.succeed(`\u53D1\u73B0\u4E86 ${pc11.cyan(plugins.length)} \u4E2A\u63D2\u4EF6`);
+    const pluginList = plugins.map((p) => `- ${pc11.bold(p.name)} ${pc11.gray(`(${p.id})`)}
+  ${pc11.gray(p.path)}`).join("\n\n");
     printBox(
-      `${pc10.green(pc10.bold("\u2728 \u63D2\u4EF6\u626B\u63CF\u7ED3\u679C"))}
+      `${pc11.green(pc11.bold("\u2728 \u63D2\u4EF6\u626B\u63CF\u7ED3\u679C"))}
 
 ${pluginList}`,
       "Plugin Discovery"
@@ -2232,7 +2403,7 @@ init_esm_shims();
 init_corekit();
 init_sandbox();
 init_utils();
-import pc11 from "picocolors";
+import pc12 from "picocolors";
 async function ls() {
   const versions = await CoreKit.listVersions();
   const currentVersion = await CoreKit.resolveVersion(process.cwd());
@@ -2246,22 +2417,22 @@ async function ls() {
       const isProjectCurrent = v === currentVersion;
       let prefix = "  ";
       if (isProjectCurrent) {
-        prefix = pc11.green(" *");
+        prefix = pc12.green(" *");
       } else if (isGlobalCurrent) {
-        prefix = pc11.blue(" >");
+        prefix = pc12.blue(" >");
       }
       let suffix = "";
       if (isProjectCurrent && isGlobalCurrent) {
-        suffix = pc11.gray(" (\u5F53\u524D\u9879\u76EE & \u5168\u5C40)");
+        suffix = pc12.gray(" (\u5F53\u524D\u9879\u76EE & \u5168\u5C40)");
       } else if (isProjectCurrent) {
-        suffix = pc11.gray(" (\u5F53\u524D\u9879\u76EE)");
+        suffix = pc12.gray(" (\u5F53\u524D\u9879\u76EE)");
       } else if (isGlobalCurrent) {
-        suffix = pc11.gray(" (\u5168\u5C40)");
+        suffix = pc12.gray(" (\u5168\u5C40)");
       }
-      return `${prefix} ${pc11.white(v)}${suffix}`;
+      return `${prefix} ${pc12.white(v)}${suffix}`;
     }).join("\n");
     printBox(
-      list + pc11.gray("\n\n\u63D0\u793A: * \u5F53\u524D\u9879\u76EE\u4F7F\u7528, > \u5168\u5C40\u9ED8\u8BA4\u4F7F\u7528"),
+      list + pc12.gray("\n\n\u63D0\u793A: * \u5F53\u524D\u9879\u76EE\u4F7F\u7528, > \u5168\u5C40\u9ED8\u8BA4\u4F7F\u7528"),
       "Kernel Versions"
     );
   }
@@ -2274,8 +2445,8 @@ init_sandbox();
 init_corekit();
 init_sync();
 init_utils();
-import fs11 from "fs-extra";
-import path12 from "path";
+import fs15 from "fs-extra";
+import path17 from "path";
 async function use(version, options = {}) {
   const versions = await CoreKit.listVersions();
   if (!versions.includes(version)) {
@@ -2287,8 +2458,8 @@ async function use(version, options = {}) {
     logger.success(`\u5DF2\u5207\u6362\u5168\u5C40\u5185\u6838\u7248\u672C\u81F3: ${version}`);
   } else {
     const cwd = process.cwd();
-    const versionFilePath = path12.join(cwd, ".chatbi-version");
-    await fs11.writeFile(versionFilePath, version, "utf-8");
+    const versionFilePath = path17.join(cwd, ".chatbi-version");
+    await fs15.writeFile(versionFilePath, version, "utf-8");
     logger.success(`\u5DF2\u5207\u6362\u5F53\u524D\u9879\u76EE\u5185\u6838\u7248\u672C\u4E3A: ${version}`);
   }
   await sync({ version, force: false });
@@ -2301,16 +2472,16 @@ init_fetch();
 init_esm_shims();
 init_sandbox();
 init_utils();
-import fs12 from "fs-extra";
-import path14 from "path";
-import pc13 from "picocolors";
+import fs16 from "fs-extra";
+import path19 from "path";
+import pc14 from "picocolors";
 import { execa as execa5 } from "execa";
 async function install(target) {
-  if (target.endsWith(".tgz") && fs12.existsSync(target)) {
-    const spinner = createSpinner(`\u6B63\u5728\u5B89\u88C5\u672C\u5730\u79BB\u7EBF\u5305: ${pc13.bold(target)}...`).start();
+  if (target.endsWith(".tgz") && fs16.existsSync(target)) {
+    const spinner = createSpinner(`\u6B63\u5728\u5B89\u88C5\u672C\u5730\u79BB\u7EBF\u5305: ${pc14.bold(target)}...`).start();
     try {
-      const tgzPath = path14.resolve(target);
-      const match = path14.basename(target).match(/chatbi-core-(.+)\.tgz/);
+      const tgzPath = path19.resolve(target);
+      const match = path19.basename(target).match(/chatbi-core-(.+)\.tgz/);
       let version = "unknown";
       if (match) {
         version = match[1];
@@ -2320,7 +2491,7 @@ async function install(target) {
         version = `local-${Date.now()}`;
       }
       const versionRoot = Sandbox.getVersionRoot();
-      await fs12.ensureDir(versionRoot);
+      await fs16.ensureDir(versionRoot);
       spinner.text = "\u6B63\u5728\u89E3\u538B\u6587\u4EF6...";
       await execa5("tar", ["-xzf", tgzPath, "-C", versionRoot]);
       spinner.succeed(`\u672C\u5730\u5305\u5DF2\u5B89\u88C5\u81F3\u6C99\u7BB1: ${version}`);
@@ -2328,7 +2499,7 @@ async function install(target) {
       await Sandbox.prepare(version);
       spinner.succeed("\u5185\u6838\u73AF\u5883\u5C31\u7EEA");
       printBox(
-        pc13.green(pc13.bold("\u2728 \u672C\u5730\u5185\u6838\u5B89\u88C5\u6210\u529F!")) + "\n\n" + pc13.white("\u7248\u672C: ") + pc13.cyan(version) + "\n" + pc13.white("\u8DEF\u5F84: ") + pc13.gray(Sandbox.getVersionPath(version)),
+        pc14.green(pc14.bold("\u2728 \u672C\u5730\u5185\u6838\u5B89\u88C5\u6210\u529F!")) + "\n\n" + pc14.white("\u7248\u672C: ") + pc14.cyan(version) + "\n" + pc14.white("\u8DEF\u5F84: ") + pc14.gray(Sandbox.getVersionPath(version)),
         "Install Success"
       );
     } catch (e) {
@@ -2341,10 +2512,18 @@ async function install(target) {
   }
 }
 
+// src/commands/clean.ts
+init_esm_shims();
+init_sandbox();
+async function clean(options) {
+  const cwd = process.cwd();
+  await Sandbox.clean(cwd, options.deep);
+}
+
 // package.json
 var package_default = {
   name: "@chatbi-v/cli",
-  version: "2.0.4",
+  version: "2.0.5",
   description: "Standardized CLI tooling for ChatBI Monorepo",
   type: "module",
   main: "dist/index.js",
@@ -2403,7 +2582,7 @@ var showHeader = () => {
   const title = figlet.textSync("ChatBI-V CLI", { font: "Standard" });
   console.log(gradient.pastel.multiline(title));
   console.log(
-    boxen2(pc15.cyan(`ChatBI-V \u7EDF\u4E00\u5F00\u53D1\u5DE5\u5177 v${package_default.version}`), {
+    boxen2(pc16.cyan(`ChatBI-V \u7EDF\u4E00\u5F00\u53D1\u5DE5\u5177 v${package_default.version}`), {
       padding: 0,
       margin: { top: 1, bottom: 1 },
       borderStyle: "round",
@@ -2461,13 +2640,14 @@ cli.command("list", "\u5217\u51FA\u6240\u6709\u5DF2\u5B89\u88C5\u7684\u5185\u683
 cli.command("use <version>", "\u5207\u6362\u5F53\u524D\u9879\u76EE\u4F7F\u7528\u7684\u5185\u6838\u7248\u672C").alias("u").option("--global", "\u5207\u6362\u5168\u5C40\u9ED8\u8BA4\u5185\u6838\u7248\u672C").action(wrapAction(use, "use"));
 cli.command("gl", "\u4F7F\u7528 AI \u811A\u624B\u67B6\u751F\u6210\u4EE3\u7801\u6216\u6587\u6863").option("-t, --type <type>", "\u751F\u6210\u7C7B\u578B (plugin|util|doc|component)").option("-p, --prompt <prompt>", "AI \u9700\u6C42\u63CF\u8FF0").action(wrapAction(gl, "gl"));
 cli.command("discover", "\u626B\u63CF\u5E76\u53D1\u73B0\u5F53\u524D\u9879\u76EE\u4E2D\u7684\u63D2\u4EF6").action(wrapAction(discover, "discover"));
+cli.command("clean", "\u6E05\u7406 CLI \u4EA7\u751F\u7684\u7F13\u5B58\u76EE\u5F55").alias("cl").option("--deep", "\u6DF1\u5EA6\u6E05\u7406 (\u5305\u542B\u6240\u6709\u5B50\u5305\u7684 .chatbi \u76EE\u5F55\u53CA\u5168\u5C40\u6C99\u7BB1\u6839\u76EE\u5F55)").action(wrapAction(clean, "clean"));
 cli.command("bench", "\u8FD0\u884C CLI \u6027\u80FD\u57FA\u51C6\u6D4B\u8BD5").action(wrapAction(async () => {
   const { bench: bench2 } = await Promise.resolve().then(() => (init_bench(), bench_exports));
   await bench2();
 }, "bench"));
 cli.help((sections) => {
   showHeader();
-  sections[0].body = pc15.white("ChatBI-V \u5F00\u53D1\u8005\u547D\u4EE4\u884C\u5DE5\u5177\uFF0C\u52A9\u529B\u5FEB\u901F\u5F00\u53D1\u548C\u6784\u5EFA\u63D2\u4EF6\u3002");
+  sections[0].body = pc16.white("ChatBI-V \u5F00\u53D1\u8005\u547D\u4EE4\u884C\u5DE5\u5177\uFF0C\u52A9\u529B\u5FEB\u901F\u5F00\u53D1\u548C\u6784\u5EFA\u63D2\u4EF6\u3002");
 });
 cli.version(package_default.version);
 if (process.argv.length <= 2) {