@chatbi-v/cli 3.1.1 → 3.1.2

package/dist/index.js

@@ -27,7 +27,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@chatbi-v/cli",
-      version: "3.1.0",
+      version: "3.1.2",
       description: "Standardized CLI tooling for ChatBI Monorepo",
       type: "module",
       main: "dist/index.js",
@@ -290,7 +290,7 @@ import ora from "ora";
 import path3 from "path";
 import pc from "picocolors";
 import { fileURLToPath as fileURLToPath2 } from "url";
-var _require, _filename, _dirname, config, UPDATE_CHECK_INTERVAL, CACHE_DIR, CACHE_FILE, isDebug, setDebugMode, logger, createSpinner, printBox, findPackageRoot, getCliRoot, checkForUpdates, printUpdateNotification;
+var _require, _filename, _dirname, config, UPDATE_CHECK_INTERVAL, CACHE_DIR, CACHE_FILE, isDebug, setDebugMode, logger2, createSpinner, printBox, findPackageRoot, getCliRoot, checkForUpdates, printUpdateNotification;
 var init_utils = __esm({
   "src/utils.ts"() {
     "use strict";
@@ -307,7 +307,7 @@ var init_utils = __esm({
     setDebugMode = (debug) => {
       isDebug = debug;
     };
-    logger = {
+    logger2 = {
       info: (msg) => console.log(pc.cyan(`\u2139 ${msg}`)),
       success: (msg) => console.log(pc.green(`\u2714 ${msg}`)),
       warn: (msg) => console.log(pc.yellow(`\u26A0 ${msg}`)),
@@ -366,15 +366,18 @@ var init_utils = __esm({
     getCliRoot = async () => {
       let myCliRoot = "";
       let checkDir = _dirname;
-      while (checkDir !== path3.parse(checkDir).root) {
-        if (fs.existsSync(path3.join(checkDir, "package.json"))) {
-          const pkg = await fs.readJson(path3.join(checkDir, "package.json"));
-          if (pkg.name === "@chatbi-v/cli") {
-            myCliRoot = checkDir;
-            break;
+      try {
+        while (checkDir !== path3.parse(checkDir).root) {
+          if (fs.existsSync(path3.join(checkDir, "package.json"))) {
+            const pkg = await fs.readJson(path3.join(checkDir, "package.json"));
+            if (pkg.name === "@chatbi-v/cli") {
+              myCliRoot = checkDir;
+              break;
+            }
           }
+          checkDir = path3.dirname(checkDir);
         }
-        checkDir = path3.dirname(checkDir);
+      } catch {
       }
       if (!myCliRoot) {
         myCliRoot = findPackageRoot("@chatbi-v/cli") || "";
@@ -385,15 +388,18 @@ var init_utils = __esm({
       try {
         await fs.ensureDir(CACHE_DIR);
         let cache = { lastCheck: 0, latestVersion: currentVersion };
-        if (fs.existsSync(CACHE_FILE)) {
+        try {
           cache = await fs.readJson(CACHE_FILE);
+        } catch {
         }
         const now = Date.now();
         if (now - cache.lastCheck > UPDATE_CHECK_INTERVAL) {
-          const subprocess = execa("npm", ["view", "@chatbi-v/cli", "version"]);
+          const subprocess = execa("npm", ["view", "@chatbi-v/cli", "version"], {
+            reject: false
+          });
           subprocess.unref();
           subprocess.then(async ({ stdout }) => {
-            const latest = stdout.trim();
+            const latest = stdout?.trim() || "";
             await fs.writeJson(CACHE_FILE, {
               lastCheck: now,
               latestVersion: latest
@@ -486,38 +492,35 @@ var init_config2 = __esm({
        */
       static async loadConfig(cwd = process.cwd()) {
         if (!fs2.existsSync(cwd)) {
-          logger.warn(`\u9879\u76EE\u76EE\u5F55\u4E0D\u5B58\u5728: ${cwd}\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u914D\u7F6E`);
+          logger2.warn(`\u9879\u76EE\u76EE\u5F55\u4E0D\u5B58\u5728: ${cwd}\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u914D\u7F6E`);
           return {};
         }
         const config4 = {};
         const versionFilePath = path4.join(cwd, SANDBOX_CONFIG.LOCK_FILE);
-        if (fs2.existsSync(versionFilePath)) {
-          try {
-            const version = (await fs2.readFile(versionFilePath, "utf-8")).trim();
-            if (version) {
-              config4.coreVersion = version;
-            }
-          } catch {
+        try {
+          const version = (await fs2.readFile(versionFilePath, "utf-8")).trim();
+          if (version) {
+            config4.coreVersion = version;
           }
+        } catch (e) {
+          logger2.debug(`\u8BFB\u53D6 .chatbi-version \u5931\u8D25: ${e.message}`);
         }
         const jiti = createJiti(cwd);
         let projectConfig = {};
         for (const file of this.CONFIG_FILES) {
           const configPath = path4.join(cwd, file);
-          if (fs2.existsSync(configPath)) {
-            try {
-              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 fs2.readJson(configPath);
-              }
-              break;
-            } catch {
-              logger.error(`\u8BFB\u53D6\u914D\u7F6E\u6587\u4EF6 ${file} \u5931\u8D25`);
+          try {
+            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 fs2.readJson(configPath);
             }
+            break;
+          } catch (e) {
+            logger2.error(`\u8BFB\u53D6\u914D\u7F6E\u6587\u4EF6 ${file} \u5931\u8D25: ${e.message}`);
           }
         }
         const envConfig = {};
@@ -571,30 +574,27 @@ var init_config2 = __esm({
         const jiti = createJiti(cwd);
         for (const file of TSUP_CONFIG_FILES) {
           const configPath = path4.join(cwd, file);
-          if (fs2.existsSync(configPath)) {
-            try {
-              if (file.endsWith(".json")) {
-                return await fs2.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}`);
+          try {
+            if (file.endsWith(".json")) {
+              return await fs2.readJson(configPath);
+            } else {
+              const mod = await jiti.import(configPath, {
+                default: true
+              });
+              return mod.default || mod || {};
             }
+          } catch (e) {
+            logger2.warn(`\u52A0\u8F7D tsup \u914D\u7F6E\u6587\u4EF6 ${file} \u5931\u8D25: ${e.message}`);
           }
         }
         const pkgPath = path4.join(cwd, "package.json");
-        if (fs2.existsSync(pkgPath)) {
-          try {
-            const pkg = await fs2.readJson(pkgPath);
-            if (pkg.tsup) {
-              return pkg.tsup;
-            }
-          } catch {
+        try {
+          const pkg = await fs2.readJson(pkgPath);
+          if (pkg.tsup) {
+            return pkg.tsup;
           }
+        } catch (e) {
+          logger2.debug(`\u8BFB\u53D6 package.json \u5931\u8D25: ${e.message}`);
         }
         return {};
       }
@@ -612,6 +612,7 @@ var init_CacheValidator = __esm({
   "src/sandbox/CacheValidator.ts"() {
     "use strict";
     init_esm_shims();
+    init_utils();
     MANIFEST_FILE = ".sandbox-manifest.json";
     CacheValidator = class {
       constructor(versionPath) {
@@ -638,7 +639,8 @@ var init_CacheValidator = __esm({
         try {
           const content = await fs3.readFile(filePath);
           return `sha256:${crypto.createHash("sha256").update(content).digest("hex")}`;
-        } catch {
+        } catch (e) {
+          logger2.debug(`\u8BA1\u7B97\u6587\u4EF6 Hash \u5931\u8D25: ${e.message}`);
           return "";
         }
       }
@@ -649,25 +651,26 @@ var init_CacheValidator = __esm({
         const packages = {};
         try {
           const nodeModulesPath = this.getNodeModulesPath();
-          if (!fs3.existsSync(nodeModulesPath)) {
+          let entries;
+          try {
+            entries = await fs3.readdir(nodeModulesPath, {
+              withFileTypes: true
+            });
+          } catch {
             return "";
           }
-          const entries = await fs3.readdir(nodeModulesPath, {
-            withFileTypes: true
-          });
           for (const entry of entries) {
             if (entry.isDirectory() && !entry.name.startsWith(".")) {
-              const pkgJsonPath = path5.join(
+              const pkgJsonPath2 = path5.join(
                 nodeModulesPath,
                 entry.name,
                 "package.json"
               );
-              if (fs3.existsSync(pkgJsonPath)) {
-                try {
-                  const pkg = await fs3.readJson(pkgJsonPath);
-                  packages[entry.name] = `${pkg.name}@${pkg.version}`;
-                } catch {
-                }
+              try {
+                const pkg = await fs3.readJson(pkgJsonPath2);
+                packages[entry.name] = `${pkg.name}@${pkg.version}`;
+              } catch {
+                logger2.debug(`\u5FFD\u7565\u65E0\u6548 package.json: ${pkgJsonPath2}`);
               }
             }
           }
@@ -682,19 +685,30 @@ var init_CacheValidator = __esm({
        */
       async generatePackageIntegrity(pkgPath) {
         try {
-          const pkgJsonPath = path5.join(pkgPath, "package.json");
-          if (fs3.existsSync(pkgJsonPath)) {
-            const content = await fs3.readFile(pkgJsonPath);
+          const pkgJsonPath2 = path5.join(pkgPath, "package.json");
+          try {
+            const content = await fs3.readFile(pkgJsonPath2);
             return `sha256:${crypto.createHash("sha256").update(content).digest("hex")}`;
+          } catch {
+            logger2.debug(`package.json \u4E0D\u5B58\u5728\uFF0C\u4F7F\u7528\u76EE\u5F55\u5185\u5BB9: ${pkgPath}`);
+          }
+          let files;
+          try {
+            files = await fs3.readdir(pkgPath);
+          } catch {
+            return "";
           }
-          const files = await fs3.readdir(pkgPath);
           const combinedHash = crypto.createHash("sha256");
           for (const file of files.slice(0, 10)) {
             const filePath = path5.join(pkgPath, file);
-            const stats = await fs3.stat(filePath);
-            if (stats.isFile()) {
-              const content = await fs3.readFile(filePath);
-              combinedHash.update(content);
+            try {
+              const stats = await fs3.stat(filePath);
+              if (stats.isFile()) {
+                const content = await fs3.readFile(filePath);
+                combinedHash.update(content);
+              }
+            } catch (e) {
+              logger2.debug(`\u5904\u7406\u6587\u4EF6\u5931\u8D25: ${file}: ${e.message}`);
             }
           }
           return `sha256:${combinedHash.digest("hex")}`;
@@ -710,13 +724,11 @@ var init_CacheValidator = __esm({
           return this.manifest;
         }
         const manifestPath = this.getManifestPath();
-        if (!fs3.existsSync(manifestPath)) {
-          return null;
-        }
         try {
           this.manifest = await fs3.readJson(manifestPath);
           return this.manifest;
-        } catch {
+        } catch (e) {
+          logger2.debug(`\u52A0\u8F7D manifest \u5931\u8D25: ${e.message}`);
           return null;
         }
       }
@@ -887,7 +899,12 @@ var init_CacheValidator = __esm({
         const criticalPkgs = Object.keys(manifest.packages);
         for (const pkg of criticalPkgs) {
           const pkgPath = path5.join(this.getNodeModulesPath(), pkg);
-          if (!fs3.existsSync(pkgPath)) {
+          try {
+            const stats = await fs3.stat(pkgPath);
+            if (!stats.isDirectory()) {
+              return false;
+            }
+          } catch {
             return false;
           }
         }
@@ -919,8 +936,10 @@ var init_CacheValidator = __esm({
        */
       async clearManifest() {
         const manifestPath = this.getManifestPath();
-        if (fs3.existsSync(manifestPath)) {
+        try {
           await fs3.remove(manifestPath);
+        } catch (e) {
+          logger2.debug(`\u5220\u9664\u7F13\u5B58\u5931\u8D25: ${e.message}`);
         }
         this.manifest = null;
       }
@@ -996,13 +1015,15 @@ var init_SandboxPath = __esm({
         while (current !== path6.parse(current).root) {
           const pkgPath = path6.join(current, "package.json");
           const pnpmWorkspacePath = path6.join(current, "pnpm-workspace.yaml");
-          if (fs4.existsSync(pnpmWorkspacePath)) return current;
-          if (fs4.existsSync(pkgPath)) {
-            try {
-              const pkg = await fs4.readJson(pkgPath);
-              if (pkg.workspaces) return current;
-            } catch {
-            }
+          try {
+            const content = await fs4.readFile(pnpmWorkspacePath, "utf-8");
+            if (content.includes("packages:")) return current;
+          } catch {
+          }
+          try {
+            const pkg = await fs4.readJson(pkgPath);
+            if (pkg.workspaces) return current;
+          } catch {
           }
           current = path6.dirname(current);
         }
@@ -1161,12 +1182,12 @@ var init_SandboxPlatform = __esm({
         let result = await attemptStrategy(strategy);
         if (!result.success && strategy !== "copy") {
           if (verbose) {
-            logger.warn(`[SandboxPlatform] ${strategy} \u7B56\u7565\u5931\u8D25: ${result.error}`);
+            logger2.warn(`[SandboxPlatform] ${strategy} \u7B56\u7565\u5931\u8D25: ${result.error}`);
           }
           if (strategy === "symlink" && caps.supportsJunctions && type === "dir") {
             result = await attemptStrategy("junction");
             if (!result.success && verbose) {
-              logger.warn(`[SandboxPlatform] junction \u7B56\u7565\u4E5F\u5931\u8D25: ${result.error}`);
+              logger2.warn(`[SandboxPlatform] junction \u7B56\u7565\u4E5F\u5931\u8D25: ${result.error}`);
             }
           }
           if (!result.success) {
@@ -1174,14 +1195,14 @@ var init_SandboxPlatform = __esm({
           }
         }
         if (verbose && !result.success) {
-          logger.error(
+          logger2.error(
             `[SandboxPlatform] \u65E0\u6CD5\u521B\u5EFA\u865A\u62DF node_modules: ${result.error}`
           );
           if (result.suggestion) {
-            logger.info(`   \u89E3\u51B3\u65B9\u6848: ${result.suggestion}`);
+            logger2.info(`   \u89E3\u51B3\u65B9\u6848: ${result.suggestion}`);
           }
         } else if (verbose && result.success && result.suggestion) {
-          logger.warn(`[SandboxPlatform] ${result.suggestion}`);
+          logger2.warn(`[SandboxPlatform] ${result.suggestion}`);
         }
         return result;
       }
@@ -1261,6 +1282,7 @@ var init_SandboxContext = __esm({
     "use strict";
     init_esm_shims();
     init_constants();
+    init_utils();
     init_SandboxPath();
     init_SandboxPlatform();
     SandboxContext = class {
@@ -1284,8 +1306,10 @@ var init_SandboxContext = __esm({
         await fs6.ensureDir(chatbiDir);
         if (projectRoot !== targetRoot) {
           const localChatbiDir = path8.join(projectRoot, SANDBOX_CONFIG.DIRS.CACHE);
-          if (fs6.existsSync(localChatbiDir)) {
+          try {
             await fs6.remove(localChatbiDir);
+          } catch (e) {
+            logger2.debug(`\u5220\u9664 .chatbi \u5931\u8D25: ${e.message}`);
           }
           await this.fixTsConfigExtends(projectRoot, targetRoot);
           await this.ensureGitignore(targetRoot);
@@ -1303,11 +1327,13 @@ var init_SandboxContext = __esm({
         await fs6.ensureDir(vscodeDir);
         const settingsPath = path8.join(vscodeDir, "settings.json");
         let settings = {};
-        if (fs6.existsSync(settingsPath)) {
-          try {
-            settings = await fs6.readJson(settingsPath);
-          } catch {
+        try {
+          const loaded = await fs6.readJson(settingsPath);
+          if (loaded && typeof loaded === "object") {
+            settings = loaded;
           }
+        } catch (e) {
+          logger2.debug(`\u52A0\u8F7D settings.json \u5931\u8D25: ${e.message}`);
         }
         const sandboxPath = SandboxPath.getVersionPath(version);
         const tsdkPath = path8.join(sandboxPath, "node_modules/typescript/lib");
@@ -1321,30 +1347,33 @@ var init_SandboxContext = __esm({
        */
       static async fixTsConfigExtends(projectRoot, workspaceRoot) {
         const tsConfigPath = path8.join(projectRoot, "tsconfig.json");
-        if (!fs6.existsSync(tsConfigPath)) return;
+        let tsConfig;
         try {
-          const tsConfig = await fs6.readJson(tsConfigPath);
-          let extendsTarget = path8.relative(
-            projectRoot,
-            path8.join(workspaceRoot, ".chatbi/tsconfig.json")
-          );
-          if (!extendsTarget.startsWith(".")) extendsTarget = `./${extendsTarget}`;
-          const hasExtend = (p) => p.includes(".chatbi/tsconfig.json") || p.includes(".chatbi/tsconfig.paths.json");
-          if (Array.isArray(tsConfig.extends)) {
-            if (!tsConfig.extends.some((p) => hasExtend(p))) {
-              tsConfig.extends.push(extendsTarget);
-              await fs6.writeJson(tsConfigPath, tsConfig, { spaces: 2 });
-            }
-          } else if (typeof tsConfig.extends === "string") {
-            if (!hasExtend(tsConfig.extends)) {
-              tsConfig.extends = [tsConfig.extends, extendsTarget];
-              await fs6.writeJson(tsConfigPath, tsConfig, { spaces: 2 });
-            }
-          } else {
-            tsConfig.extends = extendsTarget;
+          tsConfig = await fs6.readJson(tsConfigPath);
+        } catch (e) {
+          logger2.debug(`\u52A0\u8F7D tsconfig.json \u5931\u8D25: ${e.message}`);
+          return;
+        }
+        if (!tsConfig || typeof tsConfig !== "object") return;
+        let extendsTarget = path8.relative(
+          projectRoot,
+          path8.join(workspaceRoot, ".chatbi/tsconfig.json")
+        );
+        if (!extendsTarget.startsWith(".")) extendsTarget = `./${extendsTarget}`;
+        const hasExtend = (p) => p.includes(".chatbi/tsconfig.json") || p.includes(".chatbi/tsconfig.paths.json");
+        if (Array.isArray(tsConfig.extends)) {
+          if (!tsConfig.extends.some((p) => hasExtend(p))) {
+            tsConfig.extends.push(extendsTarget);
             await fs6.writeJson(tsConfigPath, tsConfig, { spaces: 2 });
           }
-        } catch {
+        } else if (typeof tsConfig.extends === "string") {
+          if (!hasExtend(tsConfig.extends)) {
+            tsConfig.extends = [tsConfig.extends, extendsTarget];
+            await fs6.writeJson(tsConfigPath, tsConfig, { spaces: 2 });
+          }
+        } else {
+          tsConfig.extends = extendsTarget;
+          await fs6.writeJson(tsConfigPath, tsConfig, { spaces: 2 });
         }
       }
       /**
@@ -1352,17 +1381,20 @@ var init_SandboxContext = __esm({
        */
       static async ensureGitignore(root) {
         const gitignorePath = path8.join(root, ".gitignore");
-        if (fs6.existsSync(gitignorePath)) {
-          let content = await fs6.readFile(gitignorePath, "utf-8");
-          if (!content.includes(SANDBOX_CONFIG.DIRS.CACHE)) {
-            await fs6.appendFile(
-              gitignorePath,
-              `
+        let content = "";
+        try {
+          content = await fs6.readFile(gitignorePath, "utf-8");
+        } catch (e) {
+          logger2.debug(`\u52A0\u8F7D .gitignore \u5931\u8D25: ${e.message}`);
+        }
+        if (typeof content === "string" && !content.includes(SANDBOX_CONFIG.DIRS.CACHE)) {
+          await fs6.appendFile(
+            gitignorePath,
+            `
 # ChatBI
 ${SANDBOX_CONFIG.DIRS.CACHE}
 `
-            );
-          }
+          );
         }
       }
       /**
@@ -1394,27 +1426,27 @@ ${SANDBOX_CONFIG.DIRS.CACHE}
           sandboxNodeModules,
           "@chatbi-v/config/base.json"
         );
-        const tsConfig = {
-          extends: baseConfigPath,
-          compilerOptions: {
-            baseUrl: ".",
-            // 使用 node 还是 bundler ?
-            // 现代项目推荐 bundler，但为了兼容性，特别是为了让 IDE 能够像 Node 一样查找依赖
-            moduleResolution: "bundler",
-            skipLibCheck: true,
-            // 显式指定 typeRoots，确保 IDE 优先查找沙箱的 types
-            typeRoots: ["./node_modules/@types", "./node_modules"],
-            preserveSymlinks: true,
-            paths: {
-              ...corePaths,
-              // 修改: 适配 Monorepo 根目录结构
-              // 在根目录时，src 应该指向具体的 apps/xxx/src 或 packages/xxx/src
-              // 但这里主要用于沙箱环境的类型解析，"@/*" 的映射可能需要在具体项目的 tsconfig 中覆盖
-              "@/*": ["./src/*"]
-              // "*": ["./node_modules/*"] // 已经在上面添加了 corePaths['*']
+        let tsConfig;
+        try {
+          await fs6.readJson(baseConfigPath);
+          tsConfig = {
+            extends: baseConfigPath,
+            compilerOptions: {
+              baseUrl: ".",
+              moduleResolution: "bundler",
+              skipLibCheck: true,
+              typeRoots: ["./node_modules/@types", "./node_modules"],
+              preserveSymlinks: true,
+              paths: {
+                ...corePaths,
+                "@/*": ["./src/*"]
+              }
             }
-          }
-        };
+          };
+        } catch (e) {
+          logger2.debug(`base.json \u52A0\u8F7D\u5931\u8D25\uFF0C\u4F7F\u7528\u964D\u7EA7\u914D\u7F6E: ${e.message}`);
+          tsConfig = this.getDefaultTsConfig(corePaths);
+        }
         await fs6.writeJson(path8.join(chatbiDir, "tsconfig.json"), tsConfig, {
           spaces: 2
         });
@@ -1424,7 +1456,8 @@ ${SANDBOX_CONFIG.DIRS.CACHE}
           { spaces: 2 }
         );
         const virtualNodeModules = path8.join(chatbiDir, "node_modules");
-        if (fs6.existsSync(sandboxNodeModules)) {
+        try {
+          await fs6.access(sandboxNodeModules);
           const result = await SandboxPlatform.safeSymlink({
             source: sandboxNodeModules,
             target: virtualNodeModules,
@@ -1437,8 +1470,28 @@ ${SANDBOX_CONFIG.DIRS.CACHE}
 \u5EFA\u8BAE: ${result.suggestion || "\u8FD0\u884C chatbi sandbox update --force \u91CD\u5EFA\u6C99\u7BB1"}`
             );
           }
+        } catch (e) {
+          logger2.debug(`sandboxNodeModules \u4E0D\u5B58\u5728: ${e.message}`);
         }
       }
+      /**
+       * Bug-6 Fix: 生成默认 tsconfig 配置（当 base.json 不可用时）
+       */
+      static getDefaultTsConfig(corePaths) {
+        return {
+          compilerOptions: {
+            baseUrl: ".",
+            moduleResolution: "bundler",
+            skipLibCheck: true,
+            typeRoots: ["./node_modules/@types", "./node_modules"],
+            preserveSymlinks: true,
+            paths: {
+              ...corePaths,
+              "@/*": ["./src/*"]
+            }
+          }
+        };
+      }
     };
   }
 });
@@ -1470,43 +1523,56 @@ var init_WorkspaceResolver = __esm({
               reject: false
             }
           );
-          try {
-            const pnpmPackages = JSON.parse(stdout);
-            if (Array.isArray(pnpmPackages)) {
-              for (const pkg of pnpmPackages) {
-                if (pkg.name && pkg.path) {
-                  packages[pkg.name] = pkg.path;
+          if (!stdout || typeof stdout !== "string" || stdout.trim() === "") {
+            logger2.warn("pnpm \u89E3\u6790\u8FD4\u56DE\u7A7A\u7ED3\u679C\uFF0C\u5C1D\u8BD5\u964D\u7EA7\u65B9\u6848...");
+          } else {
+            try {
+              const pnpmPackages = JSON.parse(stdout);
+              if (Array.isArray(pnpmPackages)) {
+                for (const pkg of pnpmPackages) {
+                  if (pkg.name && pkg.path) {
+                    packages[pkg.name] = pkg.path;
+                  }
+                }
+                if (Object.keys(packages).length > 0) {
+                  return packages;
                 }
               }
-              if (Object.keys(packages).length > 0) {
-                return packages;
-              }
+            } catch {
             }
-          } catch {
           }
         } catch (e) {
-          logger.warn(`pnpm \u89E3\u6790\u5931\u8D25: ${e.message}\uFF0C\u5C1D\u8BD5\u964D\u7EA7\u65B9\u6848...`);
+          logger2.warn(`pnpm \u89E3\u6790\u5931\u8D25: ${e.message}\uFF0C\u5C1D\u8BD5\u964D\u7EA7\u65B9\u6848...`);
         }
+        let patterns = ["packages/*"];
+        const workspaceYamlPath = path9.join(workspaceRoot, "pnpm-workspace.yaml");
+        let foundWorkspaceYaml = false;
         try {
-          const workspaceYamlPath = path9.join(workspaceRoot, "pnpm-workspace.yaml");
-          let patterns = ["packages/*"];
-          if (fs7.existsSync(workspaceYamlPath)) {
-            const content = await fs7.readFile(workspaceYamlPath, "utf-8");
-            const match = content.match(/packages:\s*([\s\S]*?)(?:\n\S|$)/);
-            if (match && match[1]) {
-              const lines = match[1].split("\n").map((l) => l.trim()).filter((l) => l.startsWith("-")).map((l) => l.replace(/^-\s*['"]?|['"]?$/g, ""));
-              if (lines.length > 0) patterns = lines;
-            }
-          } else {
-            const pkgJsonPath = path9.join(workspaceRoot, "package.json");
-            if (fs7.existsSync(pkgJsonPath)) {
-              const pkg = await fs7.readJson(pkgJsonPath);
-              if (Array.isArray(pkg.workspaces)) {
-                patterns = pkg.workspaces;
-              }
+          const content = await fs7.readFile(workspaceYamlPath, "utf-8");
+          foundWorkspaceYaml = true;
+          const match = content.match(/packages:\s*([\s\S]*?)(?:\n\S|$)/);
+          if (match && match[1]) {
+            const lines = match[1].split("\n").map((l) => l.trim()).filter((l) => l.startsWith("-")).map((l) => l.replace(/^-\s*['"]?|['"]?$/g, ""));
+            if (lines.length > 0) patterns = lines;
+          }
+        } catch (e) {
+          logger2.debug(`\u8BFB\u53D6 workspace.yaml \u5931\u8D25: ${e.message}`);
+        }
+        if (!foundWorkspaceYaml) {
+          const pkgJsonPath2 = path9.join(workspaceRoot, "package.json");
+          try {
+            const pkg = await fs7.readJson(pkgJsonPath2);
+            if (Array.isArray(pkg.workspaces)) {
+              patterns = pkg.workspaces;
             }
+          } catch (e) {
+            logger2.debug(
+              `\u8BFB\u53D6 package.json \u5931\u8D25: ${pkgJsonPath2}: ${e.message}`
+            );
           }
-          const globPatterns = patterns.map((p) => path9.join(p, "package.json"));
+        }
+        const globPatterns = patterns.map((p) => path9.join(p, "package.json"));
+        try {
           const { default: fg3 } = await import("fast-glob");
           const pkgJsonFiles = await fg3(globPatterns, {
             cwd: workspaceRoot,
@@ -1519,11 +1585,12 @@ var init_WorkspaceResolver = __esm({
               if (pkg.name) {
                 packages[pkg.name] = path9.dirname(file);
               }
-            } catch {
+            } catch (e) {
+              logger2.debug(`\u626B\u63CF\u5305\u5931\u8D25: ${file}: ${e.message}`);
             }
           }
         } catch (e) {
-          logger.warn(`\u5DE5\u4F5C\u533A\u626B\u63CF\u5931\u8D25: ${e.message}`);
+          logger2.warn(`\u5DE5\u4F5C\u533A\u626B\u63CF\u5931\u8D25: ${e.message}`);
         }
         return packages;
       }
@@ -1582,12 +1649,31 @@ var init_SandboxPkgManager = __esm({
             try {
               const stats = await fs8.lstat(targetLinkPath).catch(() => null);
               if (stats) await fs8.remove(targetLinkPath);
-            } catch {
+            } catch (e) {
+              logger2.debug(
+                `\u521B\u5EFA\u8F6F\u94FE\u63A5\u5931\u8D25: ${targetLinkPath}: ${e.message}`
+              );
+            }
+            try {
+              await fs8.symlink(pkgPath, targetLinkPath, "dir");
+            } catch (e) {
+              console.warn(
+                pc4.yellow(
+                  `  \u26A0\uFE0F  \u521B\u5EFA\u8F6F\u94FE\u63A5\u5931\u8D25: ${targetLinkPath} -> ${pkgPath}: ${e.message}`
+                )
+              );
             }
-            await fs8.symlink(pkgPath, targetLinkPath, "dir");
           }
           const sandboxPkgJsonPath = path10.join(versionPath, "package.json");
-          const sandboxPkgJson = await fs8.readJson(sandboxPkgJsonPath);
+          let sandboxPkgJson;
+          try {
+            sandboxPkgJson = await fs8.readJson(sandboxPkgJsonPath);
+          } catch (e) {
+            console.warn(
+              pc4.yellow(`  \u26A0\uFE0F  \u8BFB\u53D6\u6C99\u7BB1 package.json \u5931\u8D25: ${e.message}`)
+            );
+            return false;
+          }
           const sections = ["dependencies", "devDependencies"];
           let modified = false;
           for (const section of sections) {
@@ -1609,26 +1695,28 @@ var init_SandboxPkgManager = __esm({
             await fs8.writeJson(sandboxPkgJsonPath, sandboxPkgJson, { spaces: 2 });
           }
           const shellPkgJsonPath = path10.join(versionPath, "shell", "package.json");
-          if (fs8.existsSync(shellPkgJsonPath)) {
-            const shellPkgJson = await fs8.readJson(shellPkgJsonPath);
+          try {
+            const shellPkgJson2 = await fs8.readJson(shellPkgJsonPath);
             let shellModified = false;
             const allPackagesToLink = { ...localPackages };
             if (allLocalPackages["@chatbi-v/cli"]) {
               allPackagesToLink["@chatbi-v/cli"] = allLocalPackages["@chatbi-v/cli"];
             }
             for (const section of sections) {
-              if (shellPkgJson[section]) {
+              if (shellPkgJson2[section]) {
                 for (const [name, pkgPath] of Object.entries(allPackagesToLink)) {
-                  if (shellPkgJson[section][name]) {
-                    shellPkgJson[section][name] = `link:${pkgPath}`;
+                  if (shellPkgJson2[section][name]) {
+                    shellPkgJson2[section][name] = `link:${pkgPath}`;
                     shellModified = true;
                   }
                 }
               }
             }
             if (shellModified) {
-              await fs8.writeJson(shellPkgJsonPath, shellPkgJson, { spaces: 2 });
+              await fs8.writeJson(shellPkgJsonPath, shellPkgJson2, { spaces: 2 });
             }
+          } catch {
+            logger2.debug(`shell package.json \u4E0D\u5B58\u5728: ${shellPkgJson}`);
           }
           return true;
         } catch (e) {
@@ -1762,11 +1850,12 @@ var init_SandboxRenderer = __esm({
             }
           }
         }
-        if (fs9.existsSync(destPath)) {
+        try {
           const existingContent = await fs9.readFile(destPath, "utf-8");
           if (existingContent === outputContent) {
             return;
           }
+        } catch {
         }
         await fs9.outputFile(destPath, outputContent);
       }
@@ -1818,8 +1907,10 @@ var init_sandbox = __esm({
       /** 清理指定版本的沙箱物理文件 */
       static async cleanVersion(version) {
         const versionPath = this.getVersionPath(version);
-        if (fs10.existsSync(versionPath)) {
+        try {
           await fs10.remove(versionPath);
+        } catch (e) {
+          logger2.debug(`\u6E05\u7406\u7248\u672C\u76EE\u5F55\u5931\u8D25: ${e.message}`);
         }
       }
       /**
@@ -1868,23 +1959,24 @@ var init_sandbox = __esm({
             for (const dir of distDirs) {
               const stats = await fs10.lstat(dir).catch(() => null);
               if (stats) {
-                const hasPkg = fs10.existsSync(
-                  path12.join(path12.dirname(dir), "package.json")
-                );
-                if (hasPkg) {
+                try {
+                  await fs10.access(path12.join(path12.dirname(dir), "package.json"));
                   targetDirs.push(dir);
+                } catch {
                 }
               }
             }
             const globalRoot = this.getRoot();
-            if (fs10.existsSync(globalRoot)) {
+            try {
+              await fs10.access(globalRoot);
               targetDirs.push(globalRoot);
+            } catch {
             }
           }
           if (dryRun) {
             spinner.stop();
             if (targetDirs.length === 0) {
-              logger.info(pc5.green("\u2728 \u6CA1\u6709\u53D1\u73B0\u9700\u8981\u6E05\u7406\u7684\u7F13\u5B58\u76EE\u5F55"));
+              logger2.info(pc5.green("\u2728 \u6CA1\u6709\u53D1\u73B0\u9700\u8981\u6E05\u7406\u7684\u7F13\u5B58\u76EE\u5F55"));
             } else {
               printBox(
                 `${pc5.yellow("\u5373\u5C06\u6E05\u7406\u4EE5\u4E0B\u76EE\u5F55\uFF1A")}
@@ -1919,8 +2011,10 @@ var init_sandbox = __esm({
             return versionPath;
           }
         }
-        if (fs10.existsSync(versionPath)) {
+        try {
           await fs10.remove(path12.join(versionPath, "node_modules"));
+        } catch (e) {
+          logger2.debug(`\u5220\u9664 node_modules \u5931\u8D25: ${e.message}`);
         }
         await fs10.ensureDir(versionPath);
         const spinner = createSpinner(
@@ -1962,7 +2056,7 @@ var init_sandbox = __esm({
               spinner.warn(
                 pc5.yellow(`\u6C99\u7BB1\u521D\u59CB\u5316\u53D1\u751F\u7F51\u7EDC/\u7248\u672C\u9519\u8BEF (\u6D4B\u8BD5\u73AF\u5883\u5DF2\u5FFD\u7565)`)
               );
-              logger.warn(`\u5FFD\u7565\u7684\u5B89\u88C5\u9519\u8BEF: ${installErr.message.split("\n")[0]}`);
+              logger2.warn(`\u5FFD\u7565\u7684\u5B89\u88C5\u9519\u8BEF: ${installErr.message.split("\n")[0]}`);
             } else {
               throw installErr;
             }
@@ -1982,37 +2076,51 @@ var init_sandbox = __esm({
       static async ensureShell(version, force = false) {
         const versionPath = this.getVersionPath(version);
         const shellDestDir = path12.join(versionPath, "shell");
-        if (!force && fs10.existsSync(path12.join(shellDestDir, "tsconfig.paths.json"))) {
-          return shellDestDir;
+        if (!force) {
+          try {
+            await fs10.access(path12.join(shellDestDir, "tsconfig.paths.json"));
+            return shellDestDir;
+          } catch (e) {
+            logger2.debug(`globalRoot \u68C0\u67E5: ${e.message}`);
+          }
         }
         const cliRoot = await getCliRoot();
-        const cliPkg = await fs10.readJson(path12.join(cliRoot, "package.json"));
-        const cliVersion = cliPkg.version;
+        let cliVersion = "0.0.0";
+        try {
+          const cliPkg = await fs10.readJson(path12.join(cliRoot, "package.json"));
+          cliVersion = cliPkg.version;
+        } catch {
+          logger2.warn(`\u65E0\u6CD5\u8BFB\u53D6 CLI \u7248\u672C\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u503C: ${cliVersion}`);
+        }
         const shellTemplateDir = path12.join(cliRoot, "templates/app");
-        if (fs10.existsSync(shellTemplateDir)) {
-          await fs10.remove(shellDestDir);
-          const templateData = {
-            name: "chatbi-shell",
-            version,
-            cliVersion,
-            theme: DEFAULT_CONFIG.THEME,
-            isShell: true,
-            isBusiness: true,
-            tsconfigPath: "./tsconfig.paths.json"
-          };
-          await SandboxRenderer.renderDirectory(
-            shellTemplateDir,
-            shellDestDir,
-            templateData
-          );
-          await fs10.writeJson(
-            path12.join(shellDestDir, "tsconfig.paths.json"),
-            {
-              compilerOptions: { baseUrl: ".", paths: { "@/*": ["./src/*"] } }
-            },
-            { spaces: 2 }
-          );
+        try {
+          await fs10.access(shellTemplateDir);
+        } catch {
+          logger2.warn(`Shell \u6A21\u677F\u76EE\u5F55\u4E0D\u5B58\u5728: ${shellTemplateDir}`);
+          return shellDestDir;
         }
+        await fs10.remove(shellDestDir);
+        const templateData = {
+          name: "chatbi-shell",
+          version,
+          cliVersion,
+          theme: DEFAULT_CONFIG.THEME,
+          isShell: true,
+          isBusiness: true,
+          tsconfigPath: "./tsconfig.paths.json"
+        };
+        await SandboxRenderer.renderDirectory(
+          shellTemplateDir,
+          shellDestDir,
+          templateData
+        );
+        await fs10.writeJson(
+          path12.join(shellDestDir, "tsconfig.paths.json"),
+          {
+            compilerOptions: { baseUrl: ".", paths: { "@/*": ["./src/*"] } }
+          },
+          { spaces: 2 }
+        );
         return shellDestDir;
       }
       /** 注入项目虚拟上下文 */
@@ -2032,7 +2140,14 @@ var init_sandbox = __esm({
           this.CORE_PACKAGES.map((pkg) => {
             const packageRoot = path12.join(sandboxNodeModules, pkg);
             const sourceRoot = path12.join(packageRoot, "src");
-            return [pkg, fs10.existsSync(sourceRoot) ? sourceRoot : packageRoot];
+            try {
+              const stats = fs10.statSync(sourceRoot);
+              if (stats.isDirectory()) {
+                return [pkg, sourceRoot];
+              }
+            } catch {
+            }
+            return [pkg, packageRoot];
           })
         );
       }
@@ -2041,8 +2156,15 @@ var init_sandbox = __esm({
         const versionRoot = this.getVersionRoot();
         const currentLink = path12.join(versionRoot, SANDBOX_CONFIG.DIRS.CURRENT);
         const targetPath = this.getVersionPath(version);
-        if (!fs10.existsSync(targetPath)) throw new Error(`\u7248\u672C ${version} \u4E0D\u5B58\u5728`);
-        if (fs10.existsSync(currentLink)) await fs10.remove(currentLink);
+        try {
+          await fs10.access(targetPath);
+        } catch {
+          throw new Error(`\u7248\u672C ${version} \u4E0D\u5B58\u5728`);
+        }
+        try {
+          await fs10.remove(currentLink);
+        } catch {
+        }
         await fs10.ensureSymlink(targetPath, currentLink, "dir");
       }
       /** 解析版本号 */
@@ -2052,8 +2174,10 @@ var init_sandbox = __esm({
             this.getVersionRoot(),
             SANDBOX_CONFIG.DIRS.CURRENT
           );
-          if (fs10.existsSync(currentLink)) {
-            return path12.basename(await fs10.readlink(currentLink));
+          try {
+            const realPath = await fs10.readlink(currentLink);
+            return path12.basename(realPath);
+          } catch {
           }
           const versions = await this.listVersions();
           return versions[0] || "1.0.0";
@@ -2063,9 +2187,12 @@ var init_sandbox = __esm({
       /** 列出所有已安装版本 */
       static async listVersions() {
         const versionRoot = this.getVersionRoot();
-        if (!fs10.existsSync(versionRoot)) return [];
-        const dirs = await fs10.readdir(versionRoot);
-        return dirs.filter((d) => d !== SANDBOX_CONFIG.DIRS.CURRENT && !d.startsWith(".")).sort().reverse();
+        try {
+          const dirs = await fs10.readdir(versionRoot);
+          return dirs.filter((d) => d !== SANDBOX_CONFIG.DIRS.CURRENT && !d.startsWith(".")).sort().reverse();
+        } catch {
+          return [];
+        }
       }
       /** 可视化展示沙箱状态 */
       static async visualizeStatus(cwd) {
@@ -2105,7 +2232,7 @@ var init_corekit = __esm({
     CoreKit = class {
       static async getWorkspacePatterns(rootDir) {
         const workspaceYamlPath = path13.join(rootDir, "pnpm-workspace.yaml");
-        if (fs11.existsSync(workspaceYamlPath)) {
+        try {
           const content = await fs11.readFile(workspaceYamlPath, "utf-8");
           const match = content.match(/packages:\s*([\s\S]*?)(?:\n\S|$)/);
           if (match && match[1]) {
@@ -2114,17 +2241,18 @@ var init_corekit = __esm({
               return patterns;
             }
           }
+        } catch {
         }
         const pkgPath = path13.join(rootDir, "package.json");
-        if (!fs11.existsSync(pkgPath)) {
-          return [];
-        }
-        const pkg = await fs11.readJson(pkgPath);
-        if (Array.isArray(pkg.workspaces)) {
-          return pkg.workspaces;
-        }
-        if (Array.isArray(pkg.workspaces?.packages)) {
-          return pkg.workspaces.packages;
+        try {
+          const pkg = await fs11.readJson(pkgPath);
+          if (Array.isArray(pkg.workspaces)) {
+            return pkg.workspaces;
+          }
+          if (Array.isArray(pkg.workspaces?.packages)) {
+            return pkg.workspaces.packages;
+          }
+        } catch {
         }
         return [];
       }
@@ -2138,21 +2266,39 @@ var init_corekit = __esm({
       }
       static async getPluginPackagesDir(rootDir) {
         const pluginPatterns = await this.getPluginWorkspacePatterns(rootDir);
-        const preferredPattern = pluginPatterns.find(
-          (pattern) => pattern.startsWith("packages/plugins/")
-        ) || pluginPatterns.find((pattern) => pattern.startsWith("plugins/")) || pluginPatterns[0];
-        if (!preferredPattern) {
-          return null;
+        const sortedPatterns = [
+          ...pluginPatterns.filter(
+            (pattern) => pattern.startsWith("packages/plugins/")
+          ),
+          ...pluginPatterns.filter((pattern) => pattern.startsWith("plugins/")),
+          ...pluginPatterns.filter(
+            (pattern) => !pattern.startsWith("packages/plugins/") && !pattern.startsWith("plugins/")
+          )
+        ];
+        for (const pattern of sortedPatterns) {
+          const dir = path13.resolve(rootDir, pattern.replace(/\/\*$/, ""));
+          if (fs11.existsSync(dir)) {
+            return dir;
+          }
         }
-        return path13.resolve(rootDir, preferredPattern.replace(/\/\*$/, ""));
+        return null;
       }
       static async getAppPackagesDir(rootDir) {
         const appPatterns = await this.getAppWorkspacePatterns(rootDir);
-        const preferredPattern = appPatterns.find((pattern) => pattern.startsWith("packages/apps/")) || appPatterns.find((pattern) => pattern.startsWith("apps/")) || appPatterns[0];
-        if (!preferredPattern) {
-          return null;
+        const sortedPatterns = [
+          ...appPatterns.filter((pattern) => pattern.startsWith("packages/apps/")),
+          ...appPatterns.filter((pattern) => pattern.startsWith("apps/")),
+          ...appPatterns.filter(
+            (pattern) => !pattern.startsWith("packages/apps/") && !pattern.startsWith("apps/")
+          )
+        ];
+        for (const pattern of sortedPatterns) {
+          const dir = path13.resolve(rootDir, pattern.replace(/\/\*$/, ""));
+          if (fs11.existsSync(dir)) {
+            return dir;
+          }
         }
-        return path13.resolve(rootDir, preferredPattern.replace(/\/\*$/, ""));
+        return null;
       }
       static async resolvePluginDirectory(rootDir, pluginName) {
         const plugins = await this.discoverPlugins(rootDir);
@@ -2203,19 +2349,15 @@ var init_corekit = __esm({
         try {
           const cliRoot = await getCliRoot();
           const cliVersionFile = path13.join(cliRoot, ".chatbi-version");
-          if (fs11.existsSync(cliVersionFile)) {
-            const version = (await fs11.readFile(cliVersionFile, "utf-8")).trim();
-            if (version) return version;
-          }
+          const version = (await fs11.readFile(cliVersionFile, "utf-8")).trim();
+          if (version) return version;
         } catch {
         }
         const currentLinkPath = path13.join(Sandbox.getVersionRoot(), "current");
-        if (fs11.existsSync(currentLinkPath)) {
-          try {
-            const realPath = await fs11.realpath(currentLinkPath);
-            return path13.basename(realPath);
-          } catch {
-          }
+        try {
+          const realPath = await fs11.realpath(currentLinkPath);
+          return path13.basename(realPath);
+        } catch {
         }
         const versions = await this.listVersions();
         return versions[0] || "latest";
@@ -2302,7 +2444,7 @@ ${pc6.gray("Root:   ")} ${pc6.white(cwd)}`,
       static async startMonorepoDevServer(rootDir, version, customPort) {
         const appsDir = await this.getAppPackagesDir(rootDir) || path13.join(rootDir, "apps");
         if (!fs11.existsSync(appsDir)) {
-          logger.warn(
+          logger2.warn(
             `\u5F53\u524D Monorepo \u4E0B\u672A\u627E\u5230\u5E94\u7528\u76EE\u5F55: ${path13.relative(rootDir, appsDir) || "apps"}`
           );
           return;
@@ -2316,7 +2458,7 @@ ${pc6.gray("Root:   ")} ${pc6.white(cwd)}`,
           path: path13.dirname(pkgPath)
         }));
         if (apps.length === 0) {
-          logger.warn("\u5F53\u524D Monorepo \u4E0B\u672A\u627E\u5230\u4EFB\u4F55\u5E94\u7528 (apps/)");
+          logger2.info("\u5F53\u524D Monorepo \u4E0B\u672A\u627E\u5230\u4EFB\u4F55\u5E94\u7528 (apps/)");
           return;
         }
         const { default: prompts7 } = await import("prompts");
@@ -2331,7 +2473,7 @@ ${pc6.gray("Root:   ")} ${pc6.white(cwd)}`,
           initial: 0
         });
         if (!response.appPath) {
-          logger.info("\u5DF2\u53D6\u6D88");
+          logger2.info("\u5DF2\u53D6\u6D88");
           return;
         }
         await this.startAppDevServer(response.appPath, version, customPort, true);
@@ -2340,7 +2482,7 @@ ${pc6.gray("Root:   ")} ${pc6.white(cwd)}`,
        * 启动插件开发服务器 (Hosted Mode)
        */
       static async startPluginDevServer(pluginDir, version, customPort) {
-        logger.info("\u6B63\u5728\u542F\u52A8\u6258\u7BA1\u5F0F Shell...");
+        logger2.info("\u6B63\u5728\u542F\u52A8\u6258\u7BA1\u5F0F Shell...");
         const shellPort = customPort || 5173;
         const sandboxRoot = Sandbox.getRoot();
         const versionPath = Sandbox.getVersionPath(version);
@@ -2353,6 +2495,12 @@ ${pc6.gray("Root:   ")} ${pc6.white(cwd)}`,
         if (!fs11.existsSync(pluginEntry)) {
           pluginEntry = path13.join(pluginDir, "src/index.ts");
         }
+        if (!fs11.existsSync(pluginEntry)) {
+          throw new Error(
+            `\u63D2\u4EF6\u5165\u53E3\u6587\u4EF6\u4E0D\u5B58\u5728: ${pluginDir}/src/index.{ts,tsx}
+\u8BF7\u786E\u4FDD\u63D2\u4EF6\u76EE\u5F55\u5305\u542B src/index.ts \u6216 src/index.tsx`
+          );
+        }
         const define = {
           "process.env.CHATBI_PLUGIN_PATH": JSON.stringify(pluginDir)
         };
@@ -2418,14 +2566,14 @@ ${pc6.white("Local: ")} ${pc6.cyan(pc6.underline(localUrl))}`,
             "Shell Success"
           );
         } catch (e) {
-          logger.error("Shell \u670D\u52A1\u5668\u542F\u52A8\u5931\u8D25", e);
+          logger2.error("Shell \u670D\u52A1\u5668\u542F\u52A8\u5931\u8D25", e);
         }
       }
       /**
        * 启动应用开发服务器 (Integrated Mode)
        */
       static async startAppDevServer(appDir, version, customPort, isMonorepo = false) {
-        logger.info("\u6B63\u5728\u542F\u52A8\u5E94\u7528...");
+        logger2.info("\u6B63\u5728\u542F\u52A8\u5E94\u7528...");
         const versionPath = Sandbox.getVersionPath(version);
         const sandboxNodeModules = path13.join(versionPath, "node_modules");
         const cliRoot = await getCliRoot();
@@ -2444,7 +2592,7 @@ ${pc6.white("Local: ")} ${pc6.cyan(pc6.underline(localUrl))}`,
               void 0,
               appDir
             ).catch((e) => {
-              logger.warn(`\u52A0\u8F7D vite.config.ts \u5931\u8D25: ${e.message}`);
+              logger2.warn(`\u52A0\u8F7D vite.config.ts \u5931\u8D25: ${e.message}`);
               return null;
             });
           }
@@ -2497,7 +2645,7 @@ ${pc6.white("Local: ")} ${pc6.cyan(pc6.underline(localUrl))}`,
             "App Success"
           );
         } catch (e) {
-          logger.error("\u5E94\u7528\u542F\u52A8\u5931\u8D25", e);
+          logger2.error("\u5E94\u7528\u542F\u52A8\u5931\u8D25", e);
         }
       }
     };
@@ -2533,11 +2681,13 @@ import pc7 from "picocolors";
 async function build(options) {
   const cwd = process.cwd();
   const pkgPath = path14.join(cwd, "package.json");
-  if (!fs12.existsSync(pkgPath)) {
-    logger.error(`\u5728 ${cwd} \u4E2D\u672A\u627E\u5230 package.json`);
+  let pkg = {};
+  try {
+    pkg = await fs12.readJson(pkgPath);
+  } catch {
+    logger2.error(`\u5728 ${cwd} \u4E2D\u672A\u627E\u5230\u6216\u65E0\u6CD5\u8BFB\u53D6 package.json`);
     return;
   }
-  const pkg = await fs12.readJson(pkgPath);
   if (options.force) {
     const spinnerClean = createSpinner("\u6B63\u5728\u6E05\u7406\u7F13\u5B58\u73AF\u5883...").start();
     try {
@@ -2545,11 +2695,11 @@ async function build(options) {
       spinnerClean.succeed("\u7F13\u5B58\u73AF\u5883\u6E05\u7406\u5B8C\u6210");
     } catch {
       spinnerClean.fail("\u7F13\u5B58\u6E05\u7406\u5931\u8D25");
-      logger.error("\u6E05\u7406\u8FC7\u7A0B\u4E2D\u53D1\u751F\u9519\u8BEF");
+      logger2.error("\u6E05\u7406\u8FC7\u7A0B\u4E2D\u53D1\u751F\u9519\u8BEF");
     }
   }
   const version = await CoreKit.resolveVersion(cwd);
-  logger.info(
+  logger2.info(
     `\u6B63\u5728\u6784\u5EFA\u9879\u76EE: ${pc7.bold(pkg.name || "unnamed")} (\u5185\u6838\u7248\u672C: ${version})
 `
   );
@@ -2582,28 +2732,41 @@ 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(
+      logger2.info(
         `\u68C0\u6D4B\u5230\u81EA\u5B9A\u4E49 build \u811A\u672C\uFF0C\u6B63\u5728\u6267\u884C: ${pc7.cyan("npm run build")}`
       );
       const args = ["run", "build"];
       if (options.watch) {
         args.push("--", "--watch");
       }
-      await execa4("npm", args, {
+      const npmResult = await execa4("npm", args, {
         stdio: "inherit",
-        env: { ...process.env, CHATBI_CLI_INTERNAL: "true" }
+        env: { ...process.env, CHATBI_CLI_INTERNAL: "true" },
+        reject: false
       });
+      if (npmResult.failed) {
+        logger2.error(`npm run build \u6267\u884C\u5931\u8D25: exitCode=${npmResult.exitCode}`);
+        return;
+      }
       return;
     }
   }
   const mode = await CoreKit.detectMode(cwd);
   if (mode === "monorepo") {
-    logger.info("\u68C0\u6D4B\u5230 Monorepo \u9879\u76EE\uFF0C\u6B63\u5728\u9012\u5F52\u6784\u5EFA\u5B50\u5305...");
-    await execa4("pnpm", ["-r", "build"], { stdio: "inherit", cwd });
+    logger2.info("\u68C0\u6D4B\u5230 Monorepo \u9879\u76EE\uFF0C\u6B63\u5728\u9012\u5F52\u6784\u5EFA\u5B50\u5305...");
+    const pnpmResult = await execa4("pnpm", ["-r", "build"], {
+      stdio: "inherit",
+      cwd,
+      reject: false
+    });
+    if (pnpmResult.failed) {
+      logger2.error(`pnpm -r build \u6267\u884C\u5931\u8D25: exitCode=${pnpmResult.exitCode}`);
+      return;
+    }
     return;
   }
   if (mode === "app") {
-    logger.info("\u6B63\u5728\u6784\u5EFA\u5E94\u7528 (Vite)...");
+    logger2.info("\u6B63\u5728\u6784\u5EFA\u5E94\u7528 (Vite)...");
     const { build: viteBuild } = await import("vite");
     const coreAlias = Sandbox.getCoreAlias(version);
     await viteBuild({
@@ -2637,22 +2800,30 @@ async function build(options) {
   }
   const { build: tsupBuild } = await import("tsup");
   let entry = ["src/index.ts"];
-  if (fs12.existsSync(path14.join(cwd, "src/index.tsx"))) {
+  const tsxPath = path14.join(cwd, "src/index.tsx");
+  const tsPath = path14.join(cwd, "src/index.ts");
+  try {
+    await fs12.access(tsxPath);
     entry = ["src/index.tsx"];
-  } else if (!fs12.existsSync(path14.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;
+  } catch {
+    try {
+      await fs12.access(tsPath);
+    } catch {
+      logger2.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`);
+    logger2.info(`\u5DF2\u52A0\u8F7D\u672C\u5730\u6784\u5EFA\u914D\u7F6E`);
   }
   if (!options.watch) {
     await fs12.remove(path14.join(cwd, "dist"));
     const tsbuildinfo = path14.join(cwd, "tsconfig.tsbuildinfo");
-    if (fs12.existsSync(tsbuildinfo)) {
+    try {
       await fs12.remove(tsbuildinfo);
+    } catch {
     }
   }
   if (isPlugin) {
@@ -2755,22 +2926,46 @@ async function build(options) {
       } else if (fs12.existsSync(sandboxTsc)) {
         tscBin = sandboxTsc;
       } else {
+        let dtsFailed = false;
         if (fs12.existsSync(path14.join(cwd, "pnpm-lock.yaml"))) {
-          await execa4("pnpm", ["exec", "tsc", "--build", "tsconfig.json"]);
-          dtsSpinner.succeed("\u7C7B\u578B\u5B9A\u4E49\u751F\u6210\u5B8C\u6210");
+          const pnpmResult = await execa4(
+            "pnpm",
+            ["exec", "tsc", "--build", "tsconfig.json"],
+            { reject: false }
+          );
+          if (pnpmResult.failed) {
+            dtsFailed = true;
+            logger2.error(
+              `pnpm exec tsc \u6267\u884C\u5931\u8D25: exitCode=${pnpmResult.exitCode}`
+            );
+          } else {
+            dtsSpinner.succeed("\u7C7B\u578B\u5B9A\u4E49\u751F\u6210\u5B8C\u6210");
+          }
         } else {
-          await execa4("npx", [
-            "-p",
-            "typescript",
-            "tsc",
-            "--build",
-            "tsconfig.json"
-          ]);
-          dtsSpinner.succeed("\u7C7B\u578B\u5B9A\u4E49\u751F\u6210\u5B8C\u6210");
+          const npxResult = await execa4(
+            "npx",
+            ["-p", "typescript", "tsc", "--build", "tsconfig.json"],
+            { reject: false }
+          );
+          if (npxResult.failed) {
+            dtsFailed = true;
+            logger2.error(`npx tsc \u6267\u884C\u5931\u8D25: exitCode=${npxResult.exitCode}`);
+          } else {
+            dtsSpinner.succeed("\u7C7B\u578B\u5B9A\u4E49\u751F\u6210\u5B8C\u6210");
+          }
+        }
+        if (dtsFailed) {
+          throw new Error("DTS generation failed");
         }
       }
       if (tscBin !== "tsc") {
-        await execa4(tscBin, ["--build", "tsconfig.json"]);
+        const tscResult = await execa4(tscBin, ["--build", "tsconfig.json"], {
+          reject: false
+        });
+        if (tscResult.failed) {
+          dtsSpinner.warn(`\u7C7B\u578B\u751F\u6210\u5931\u8D25: exitCode=${tscResult.exitCode}`);
+          throw new Error("DTS generation failed");
+        }
         dtsSpinner.succeed("\u7C7B\u578B\u5B9A\u4E49\u751F\u6210\u5B8C\u6210");
       }
     } catch {
@@ -2802,6 +2997,10 @@ import { execa as execa5 } from "execa";
 import path15 from "path";
 import pc8 from "picocolors";
 async function fetch(version, options = {}) {
+  if (!version || typeof version !== "string" || version.trim() === "") {
+    logger2.error("\u7248\u672C\u53F7\u4E0D\u80FD\u4E3A\u7A7A\u6216\u65E0\u6548");
+    return;
+  }
   const fetchSpinner = createSpinner(
     `\u6B63\u5728\u83B7\u53D6\u5185\u6838\u7248\u672C ${pc8.cyan(version)}...`
   ).start();
@@ -2811,13 +3010,24 @@ async function fetch(version, options = {}) {
     const packSpinner = createSpinner("\u6B63\u5728\u6253\u5305\u79BB\u7EBF\u8D44\u6E90...").start();
     const tgzName = `chatbi-core-${version}.tgz`;
     const tgzPath = path15.resolve(process.cwd(), tgzName);
-    await execa5("tar", [
-      "-czf",
-      tgzPath,
-      "-C",
-      path15.dirname(versionPath),
-      path15.basename(versionPath)
-    ]);
+    const { failed, exitCode, stderr } = await execa5(
+      "tar",
+      [
+        "-czf",
+        tgzPath,
+        "-C",
+        path15.dirname(versionPath),
+        path15.basename(versionPath)
+      ],
+      { reject: false }
+    );
+    if (failed) {
+      packSpinner.fail(
+        `\u79BB\u7EBF\u8D44\u6E90\u6253\u5305\u5931\u8D25: exitCode=${exitCode}, stderr=${stderr || "unknown"}`
+      );
+      logger2.error(`tar \u547D\u4EE4\u6267\u884C\u5931\u8D25\uFF0C\u8BF7\u786E\u4FDD\u7CFB\u7EDF\u5DF2\u5B89\u88C5 tar`);
+      return;
+    }
     packSpinner.succeed("\u79BB\u7EBF\u8D44\u6E90\u6253\u5305\u5B8C\u6210");
     printBox(
       `${pc8.green(pc8.bold("\u2728 \u79BB\u7EBF\u5305\u5DF2\u751F\u6210!"))}
@@ -2827,7 +3037,7 @@ ${pc8.white("\u5B89\u88C5\u547D\u4EE4: ")} ${pc8.gray(`chatbi install ${tgzName}
       "Pack Success"
     );
   } else {
-    logger.success(`\u5185\u6838\u7248\u672C ${pc8.cyan(version)} \u5DF2\u51C6\u5907\u5C31\u7EEA\u3002`);
+    logger2.success(`\u5185\u6838\u7248\u672C ${pc8.cyan(version)} \u5DF2\u51C6\u5907\u5C31\u7EEA\u3002`);
   }
 }
 var init_fetch = __esm({
@@ -2849,36 +3059,56 @@ import fs13 from "fs-extra";
 import path16 from "path";
 import pc9 from "picocolors";
 async function install(target) {
-  if (target.endsWith(".tgz") && fs13.existsSync(target)) {
-    const spinner = createSpinner(
-      `\u6B63\u5728\u5B89\u88C5\u672C\u5730\u79BB\u7EBF\u5305: ${pc9.bold(target)}...`
-    ).start();
+  if (target.endsWith(".tgz")) {
+    let fileAccessible = false;
     try {
-      const tgzPath = path16.resolve(target);
-      const match = path16.basename(target).match(/chatbi-core-(.+)\.tgz/);
-      let version = "unknown";
-      if (match) {
-        version = match[1];
-      }
-      if (version === "unknown") {
-        spinner.warn("\u65E0\u6CD5\u4ECE\u6587\u4EF6\u540D\u8BC6\u522B\u7248\u672C\uFF0C\u5C06\u4F7F\u7528\u5F53\u524D\u65F6\u95F4\u6233\u4F5C\u4E3A\u7248\u672C\u53F7");
-        version = `local-${Date.now()}`;
-      }
-      const versionRoot = Sandbox.getVersionRoot();
-      await fs13.ensureDir(versionRoot);
-      spinner.text = "\u6B63\u5728\u89E3\u538B\u6587\u4EF6...";
-      await execa6("tar", ["-xzf", tgzPath, "-C", versionRoot]);
-      spinner.succeed(`\u672C\u5730\u5305\u5DF2\u5B89\u88C5\u81F3\u6C99\u7BB1: ${version}`);
-      spinner.text = "\u6B63\u5728\u51C6\u5907\u5185\u6838\u73AF\u5883...";
-      await Sandbox.prepare(version);
-      spinner.succeed("\u5185\u6838\u73AF\u5883\u5C31\u7EEA");
-      printBox(
-        pc9.green(pc9.bold("\u2728 \u672C\u5730\u5185\u6838\u5B89\u88C5\u6210\u529F!")) + "\n\n" + pc9.white("\u7248\u672C: ") + pc9.cyan(version) + "\n" + pc9.white("\u8DEF\u5F84: ") + pc9.gray(Sandbox.getVersionPath(version)),
-        "Install Success"
-      );
-    } catch (e) {
-      spinner.fail("\u5B89\u88C5\u5931\u8D25");
-      throw e;
+      await fs13.access(target);
+      fileAccessible = true;
+    } catch {
+    }
+    if (!fileAccessible) {
+      logger.error(`\u672C\u5730\u6587\u4EF6\u4E0D\u5B58\u5728\u6216\u4E0D\u53EF\u8BBF\u95EE: ${target}`);
+    } else {
+      const spinner = createSpinner(
+        `\u6B63\u5728\u5B89\u88C5\u672C\u5730\u79BB\u7EBF\u5305: ${pc9.bold(target)}...`
+      ).start();
+      try {
+        const tgzPath = path16.resolve(target);
+        const match = path16.basename(target).match(/chatbi-core-(.+)\.tgz/);
+        let version = "unknown";
+        if (match) {
+          version = match[1];
+        }
+        if (version === "unknown") {
+          spinner.warn("\u65E0\u6CD5\u4ECE\u6587\u4EF6\u540D\u8BC6\u522B\u7248\u672C\uFF0C\u5C06\u4F7F\u7528\u5F53\u524D\u65F6\u95F4\u6233\u4F5C\u4E3A\u7248\u672C\u53F7");
+          version = `local-${Date.now()}`;
+        }
+        const versionRoot = Sandbox.getVersionRoot();
+        await fs13.ensureDir(versionRoot);
+        spinner.text = "\u6B63\u5728\u89E3\u538B\u6587\u4EF6...";
+        const { failed, exitCode, stderr } = await execa6(
+          "tar",
+          ["-xzf", tgzPath, "-C", versionRoot],
+          { reject: false }
+        );
+        if (failed) {
+          spinner.fail(`\u89E3\u538B\u5931\u8D25: exitCode=${exitCode}`);
+          logger.error(`tar \u547D\u4EE4\u6267\u884C\u5931\u8D25: ${stderr || tgzPath}`);
+          throw new Error(`Failed to extract ${tgzPath}: exitCode=${exitCode}`);
+        }
+        spinner.succeed(`\u672C\u5730\u5305\u5DF2\u5B89\u88C5\u81F3\u6C99\u7BB1: ${version}`);
+        spinner.text = "\u6B63\u5728\u51C6\u5907\u5185\u6838\u73AF\u5883...";
+        await Sandbox.prepare(version);
+        spinner.succeed("\u5185\u6838\u73AF\u5883\u5C31\u7EEA");
+        printBox(
+          pc9.green(pc9.bold("\u2728 \u672C\u5730\u5185\u6838\u5B89\u88C5\u6210\u529F!")) + "\n\n" + pc9.white("\u7248\u672C: ") + pc9.cyan(version) + "\n" + pc9.white("\u8DEF\u5F84: ") + pc9.gray(Sandbox.getVersionPath(version)),
+          "Install Success"
+        );
+        return;
+      } catch (e) {
+        spinner.fail("\u5B89\u88C5\u5931\u8D25");
+        throw e;
+      }
     }
   } else {
     const { fetch: fetch2 } = await Promise.resolve().then(() => (init_fetch(), fetch_exports));
@@ -2981,11 +3211,13 @@ import pc10 from "picocolors";
 async function sync(options = {}) {
   const cwd = options.cwd || process.cwd();
   const pkgPath = path17.join(cwd, "package.json");
-  if (!fs14.existsSync(pkgPath)) {
-    logger.error("\u672A\u627E\u5230 package.json\u3002\u8BF7\u5728\u9879\u76EE\u6839\u76EE\u5F55\u4E0B\u8FD0\u884C\u3002");
+  let pkg = {};
+  try {
+    pkg = await fs14.readJson(pkgPath);
+  } catch {
+    logger2.error("\u672A\u627E\u5230 package.json\u3002\u8BF7\u5728\u9879\u76EE\u6839\u76EE\u5F55\u4E0B\u8FD0\u884C\u3002");
     return;
   }
-  const pkg = await fs14.readJson(pkgPath);
   let version = options.version;
   if (!version) {
     version = await CoreKit.resolveVersion(cwd);
@@ -3152,7 +3384,7 @@ async function init(options) {
     ],
     {
       onCancel: () => {
-        logger.warn("\u5DF2\u53D6\u6D88\u521D\u59CB\u5316");
+        logger2.warn("\u5DF2\u53D6\u6D88\u521D\u59CB\u5316");
         process.exit(0);
       }
     }
@@ -3167,7 +3399,14 @@ async function init(options) {
   const isPluginIncluded = finalIncludePlugin;
   const rootDir = cwd || process.cwd();
   const targetDir = path18.resolve(rootDir, name);
-  if (fs15.existsSync(targetDir)) {
+  let targetDirExists = false;
+  try {
+    const stats = await fs15.stat(targetDir);
+    targetDirExists = stats.isDirectory();
+  } catch {
+    targetDirExists = false;
+  }
+  if (targetDirExists) {
     if (force) {
       await fs15.remove(targetDir);
     } else {
@@ -3190,7 +3429,7 @@ async function init(options) {
         ]
       });
       if (action === "cancel" || !action) {
-        logger.warn("\u5DF2\u53D6\u6D88\u521D\u59CB\u5316");
+        logger2.warn("\u5DF2\u53D6\u6D88\u521D\u59CB\u5316");
         return;
       }
       if (action === "overwrite") {
@@ -3201,20 +3440,25 @@ async function init(options) {
           initial: false
         });
         if (!confirm) {
-          logger.warn("\u5DF2\u53D6\u6D88\u8986\u76D6");
+          logger2.warn("\u5DF2\u53D6\u6D88\u8986\u76D6");
           return;
         }
         await fs15.remove(targetDir);
       }
     }
   }
-  logger.info(`\u6B63\u5728\u521D\u59CB\u5316\u9879\u76EE: ${pc11.bold(name)}...`);
-  logger.info(pc11.gray(`\u7C7B\u578B: ${projectType} | \u4E3B\u9898: ${theme || "N/A"}`));
-  logger.info("");
+  logger2.info(`\u6B63\u5728\u521D\u59CB\u5316\u9879\u76EE: ${pc11.bold(name)}...`);
+  logger2.info(pc11.gray(`\u7C7B\u578B: ${projectType} | \u4E3B\u9898: ${theme || "N/A"}`));
+  logger2.info("");
   try {
     const myCliRoot = await getCliRoot();
-    const cliPkg = await fs15.readJson(path18.join(myCliRoot, "package.json"));
-    const cliVersion = cliPkg.version;
+    let cliVersion = "0.0.0";
+    try {
+      const cliPkg = await fs15.readJson(path18.join(myCliRoot, "package.json"));
+      cliVersion = cliPkg.version;
+    } catch {
+      logger2.warn(`\u65E0\u6CD5\u8BFB\u53D6 CLI \u7248\u672C\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u503C: ${cliVersion}`);
+    }
     const config4 = { coreSource: "npm" };
     const kernelVersionFile = path18.join(myCliRoot, SANDBOX_CONFIG.LOCK_FILE);
     if (fs15.existsSync(kernelVersionFile)) {
@@ -3301,11 +3545,11 @@ async function init(options) {
       );
     }
     spinner.succeed(pc11.green(`\u9879\u76EE ${name} \u521D\u59CB\u5316\u5B8C\u6210\uFF01`));
-    logger.info("");
-    logger.info(pc11.cyan("\u6B63\u5728\u521D\u59CB\u5316\u5185\u6838\u73AF\u5883..."));
+    logger2.info("");
+    logger2.info(pc11.cyan("\u6B63\u5728\u521D\u59CB\u5316\u5185\u6838\u73AF\u5883..."));
     const projectCwd = targetDir;
     await sync({ force: true, cwd: projectCwd });
-    logger.info("");
+    logger2.info("");
     printBox(
       `${pc11.green("\u{1F389} \u9879\u76EE\u51C6\u5907\u5C31\u7EEA\uFF01")}
 
@@ -3314,7 +3558,7 @@ chatbi dev`,
       "Happy Coding"
     );
   } catch (e) {
-    logger.error(`\u521D\u59CB\u5316\u5931\u8D25: ${e.message}`);
+    logger2.error(`\u521D\u59CB\u5316\u5931\u8D25: ${e.message}`);
   }
 }
 var init_init = __esm({
@@ -3344,14 +3588,20 @@ async function add(options) {
   const cwd = process.cwd();
   const pkgPath = path19.join(cwd, "package.json");
   if (!fs16.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");
+    logger2.error("\u672A\u627E\u5230 package.json\u3002\u8BF7\u5728 ChatBI-V \u9879\u76EE\u6839\u76EE\u5F55\u4E0B\u8FD0\u884C\u6B64\u547D\u4EE4\u3002");
+    return;
+  }
+  let pkg = {};
+  try {
+    pkg = await fs16.readJson(pkgPath);
+  } catch {
+    logger2.error(`\u8BFB\u53D6 package.json \u5931\u8D25: ${pkgPath}`);
     return;
   }
-  const pkg = await fs16.readJson(pkgPath);
   const pluginPackagesDir = await CoreKit.getPluginPackagesDir(cwd);
   const isMonorepo = Boolean(pluginPackagesDir);
   if (!isMonorepo) {
-    logger.error(
+    logger2.error(
       "\u5F53\u524D\u4E0D\u662F Monorepo \u9879\u76EE\uFF0C\u65E0\u6CD5\u6DFB\u52A0\u63D2\u4EF6 (\u8BF7\u5728\u5305\u542B\u63D2\u4EF6\u5DE5\u4F5C\u7A7A\u95F4\u7684\u9879\u76EE\u4E2D\u8FD0\u884C)"
     );
     process.exit(1);
@@ -3398,7 +3648,7 @@ async function add(options) {
     ],
     {
       onCancel: () => {
-        logger.warn("\u5DF2\u53D6\u6D88\u6DFB\u52A0\u63D2\u4EF6");
+        logger2.warn("\u5DF2\u53D6\u6D88\u6DFB\u52A0\u63D2\u4EF6");
         process.exit(0);
       }
     }
@@ -3413,9 +3663,11 @@ async function add(options) {
   }
   const folderName = cleanName.startsWith("plugin-") ? cleanName : `plugin-${cleanName}`;
   const pluginDir = path19.resolve(pluginPackagesDir, folderName);
-  if (fs16.existsSync(pluginDir)) {
-    logger.error(`\u63D2\u4EF6\u76EE\u5F55 ${folderName} \u5DF2\u5B58\u5728\u3002`);
+  try {
+    await fs16.access(pluginDir);
+    logger2.error(`\u63D2\u4EF6\u76EE\u5F55 ${folderName} \u5DF2\u5B58\u5728\u3002`);
     return;
+  } catch {
   }
   const spinner = createSpinner(`\u6B63\u5728\u6DFB\u52A0\u65B0\u63D2\u4EF6: ${pc12.bold(name)}...`).start();
   const targetDir = pluginDir;
@@ -3451,8 +3703,8 @@ async function add(options) {
   }
   if (process.env.NODE_ENV === "test") {
     spinner.succeed(`\u63D2\u4EF6 ${pc12.bold(name)} \u6DFB\u52A0\u6210\u529F\uFF01`);
-    logger.success(`\u63D2\u4EF6 ${pc12.bold(name)} \u6DFB\u52A0\u6210\u529F\uFF01`);
-    logger.success("\u2728 \u63D2\u4EF6\u521B\u5EFA\u6210\u529F!");
+    logger2.success(`\u63D2\u4EF6 ${pc12.bold(name)} \u6DFB\u52A0\u6210\u529F\uFF01`);
+    logger2.success("\u2728 \u63D2\u4EF6\u521B\u5EFA\u6210\u529F!");
     return;
   }
   if (!templateDir || !fs16.existsSync(templateDir)) {
@@ -4033,58 +4285,72 @@ import fs18 from "fs-extra";
 import path21 from "path";
 import pc14 from "picocolors";
 async function doctor(options = {}) {
-  logger.info("\u6B63\u5728\u8BCA\u65AD\u9879\u76EE\u5065\u5EB7\u72B6\u51B5...\n");
+  logger2.info("\u6B63\u5728\u8BCA\u65AD\u9879\u76EE\u5065\u5EB7\u72B6\u51B5...\n");
   const cwd = process.cwd();
   let hasIssues = false;
   const issues = [];
-  logger.info(pc14.bold("Step 1: \u68C0\u67E5\u57FA\u7840\u73AF\u5883..."));
+  logger2.info(pc14.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)`);
+    logger2.error(`Node.js \u7248\u672C\u592A\u4F4E: ${nodeVersion} (\u8981\u6C42 >=18)`);
     hasIssues = true;
     issues.push(`Node.js \u7248\u672C\u8FC7\u4F4E (${nodeVersion})`);
   } else {
-    logger.success(`Node.js \u7248\u672C: ${nodeVersion}`);
+    logger2.success(`Node.js \u7248\u672C: ${nodeVersion}`);
   }
   try {
     const { execa: execa8 } = await import("execa");
-    const { stdout: pnpmVer } = await execa8("pnpm", ["-v"]);
-    logger.success(`pnpm \u7248\u672C: ${pnpmVer}`);
-  } catch {
-    logger.warn("\u672A\u68C0\u6D4B\u5230 pnpm\uFF0C\u5EFA\u8BAE\u5B89\u88C5\u4EE5\u83B7\u5F97\u6700\u4F73\u4F53\u9A8C");
+    const { failed, stdout: pnpmVer } = await execa8("pnpm", ["-v"], {
+      reject: false
+    });
+    if (failed) {
+      logger2.warn("\u672A\u68C0\u6D4B\u5230 pnpm\uFF0C\u5EFA\u8BAE\u5B89\u88C5\u4EE5\u83B7\u5F97\u6700\u4F73\u4F53\u9A8C");
+    } else {
+      logger2.success(`pnpm \u7248\u672C: ${pnpmVer}`);
+    }
+  } catch (e) {
+    logger2.warn(
+      `\u672A\u68C0\u6D4B\u5230 pnpm\uFF0C\u5EFA\u8BAE\u5B89\u88C5\u4EE5\u83B7\u5F97\u6700\u4F73\u4F53\u9A8C: ${e.message}`
+    );
   }
-  if (fs18.existsSync(path21.join(cwd, ".git"))) {
-    try {
-      const { execa: execa8 } = await import("execa");
-      const { stdout } = await execa8("git", ["status", "--porcelain"], { cwd });
-      if (stdout.trim()) {
-        logger.warn("Git \u5DE5\u4F5C\u533A\u4E0D\u5E72\u51C0\uFF0C\u5EFA\u8BAE\u5728\u63D0\u4EA4\u540E\u8FDB\u884C\u64CD\u4F5C");
-      } else {
-        logger.success("Git \u5DE5\u4F5C\u533A\u5E72\u51C0");
-      }
-    } catch {
+  try {
+    const gitDirPath = path21.join(cwd, ".git");
+    await fs18.access(gitDirPath);
+    const { execa: execa8 } = await import("execa");
+    const { failed, stdout } = await execa8("git", ["status", "--porcelain"], {
+      cwd,
+      reject: false
+    });
+    if (failed) {
+      logger2.warn("Git \u4E0D\u53EF\u7528\u6216\u5DE5\u4F5C\u533A\u635F\u574F");
+    } else if (stdout.trim()) {
+      logger2.warn("Git \u5DE5\u4F5C\u533A\u4E0D\u5E72\u51C0\uFF0C\u5EFA\u8BAE\u5728\u63D0\u4EA4\u540E\u8FDB\u884C\u64CD\u4F5C");
+    } else {
+      logger2.success("Git \u5DE5\u4F5C\u533A\u5E72\u51C0");
     }
+  } catch (e) {
+    logger2.debug(`Git \u68C0\u67E5\u8DF3\u8FC7: ${e.message}`);
   }
-  logger.info(pc14.bold("\nStep 2: \u68C0\u67E5\u5185\u6838\u6C99\u7BB1\u73AF\u5883..."));
+  logger2.info(pc14.bold("\nStep 2: \u68C0\u67E5\u5185\u6838\u6C99\u7BB1\u73AF\u5883..."));
   const version = await CoreKit.resolveVersion(cwd);
   const versionPath = Sandbox.getVersionPath(version);
   if (!fs18.existsSync(versionPath)) {
-    logger.error(`\u5185\u6838\u6C99\u7BB1\u7248\u672C ${version} \u5C1A\u672A\u5B89\u88C5`);
-    logger.info(
+    logger2.error(`\u5185\u6838\u6C99\u7BB1\u7248\u672C ${version} \u5C1A\u672A\u5B89\u88C5`);
+    logger2.info(
       pc14.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})`);
+    logger2.success(`\u5185\u6838\u6C99\u7BB1\u5C31\u7EEA (\u7248\u672C: ${version})`);
     const sandboxNm = path21.join(versionPath, "node_modules");
     if (!fs18.existsSync(sandboxNm)) {
-      logger.warn("\u6C99\u7BB1\u4F9D\u8D56\u672A\u5B89\u88C5\uFF0C\u5C06\u5BFC\u81F4\u6784\u5EFA\u5931\u8D25");
+      logger2.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");
     }
   }
-  logger.info(pc14.bold("\nStep 2.5: \u6DF1\u5EA6\u6C99\u7BB1\u8BCA\u65AD..."));
+  logger2.info(pc14.bold("\nStep 2.5: \u6DF1\u5EA6\u6C99\u7BB1\u8BCA\u65AD..."));
   try {
     const sandboxDiagnostics = new SandboxDiagnostics(version, cwd);
     const diagResult = await sandboxDiagnostics.runAllDiagnostics();
@@ -4093,48 +4359,48 @@ async function doctor(options = {}) {
       (i) => i.severity === "warning"
     );
     if (diagResult.passed) {
-      logger.success("\u6C99\u7BB1\u6DF1\u5EA6\u8BCA\u65AD\u901A\u8FC7");
+      logger2.success("\u6C99\u7BB1\u6DF1\u5EA6\u8BCA\u65AD\u901A\u8FC7");
     } else {
-      logger.warn(`\u6C99\u7BB1\u6DF1\u5EA6\u8BCA\u65AD\u53D1\u73B0\u95EE\u9898 ${diagResult.errorCount} \u4E2A`);
+      logger2.warn(`\u6C99\u7BB1\u6DF1\u5EA6\u8BCA\u65AD\u53D1\u73B0\u95EE\u9898 ${diagResult.errorCount} \u4E2A`);
       for (const item of errorItems.slice(0, 3)) {
-        logger.error(`  \u2022 ${item.title}`);
+        logger2.error(`  \u2022 ${item.title}`);
         issues.push(`\u6C99\u7BB1: ${item.title}`);
       }
       if (errorItems.length > 3) {
-        logger.info(pc14.gray(`  ... \u8FD8\u6709 ${errorItems.length - 3} \u4E2A\u95EE\u9898`));
-        logger.info(pc14.gray(`  \u8FD0\u884C 'chatbi sandbox diagnose' \u67E5\u770B\u8BE6\u7EC6\u4FE1\u606F`));
+        logger2.info(pc14.gray(`  ... \u8FD8\u6709 ${errorItems.length - 3} \u4E2A\u95EE\u9898`));
+        logger2.info(pc14.gray(`  \u8FD0\u884C 'chatbi sandbox diagnose' \u67E5\u770B\u8BE6\u7EC6\u4FE1\u606F`));
       }
     }
     for (const item of warningItems.slice(0, 2)) {
-      logger.warn(`  \u2022 ${item.title}`);
+      logger2.warn(`  \u2022 ${item.title}`);
     }
     if (warningItems.length > 2) {
-      logger.info(pc14.gray(`  ... \u8FD8\u6709 ${warningItems.length - 2} \u4E2A\u8B66\u544A`));
+      logger2.info(pc14.gray(`  ... \u8FD8\u6709 ${warningItems.length - 2} \u4E2A\u8B66\u544A`));
     }
   } catch (e) {
-    logger.warn(`\u6C99\u7BB1\u6DF1\u5EA6\u8BCA\u65AD\u5931\u8D25: ${e.message}`);
+    logger2.warn(`\u6C99\u7BB1\u6DF1\u5EA6\u8BCA\u65AD\u5931\u8D25: ${e.message}`);
   }
-  logger.info(pc14.bold("\nStep 3: \u68C0\u67E5\u865A\u62DF\u4F9D\u8D56\u6620\u5C04..."));
+  logger2.info(pc14.bold("\nStep 3: \u68C0\u67E5\u865A\u62DF\u4F9D\u8D56\u6620\u5C04..."));
   const workspaceRoot = await SandboxPath.getWorkspaceRoot(cwd);
   const chatbiDir = path21.join(workspaceRoot, ".chatbi");
   const isMonorepoSub = cwd !== workspaceRoot;
   if (isMonorepoSub) {
-    logger.info(
+    logger2.info(
       pc14.gray(`\u5F53\u524D\u4F4D\u4E8E\u5B50\u5305\uFF0C\u68C0\u67E5 Monorepo \u6839\u76EE\u5F55\u914D\u7F6E: ${workspaceRoot}`)
     );
   }
   if (!fs18.existsSync(chatbiDir)) {
-    logger.warn("\u672A\u53D1\u73B0\u865A\u62DF\u4F9D\u8D56\u914D\u7F6E (.chatbi \u76EE\u5F55)");
+    logger2.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 = path21.join(chatbiDir, "tsconfig.paths.json");
     if (!fs18.existsSync(pathsJson)) {
-      logger.warn("\u865A\u62DF\u4F9D\u8D56\u914D\u7F6E\u6587\u4EF6\u4E0D\u5B8C\u6574");
+      logger2.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");
     } else {
-      logger.success("\u865A\u62DF\u4F9D\u8D56\u914D\u7F6E\u5DF2\u751F\u6210");
+      logger2.success("\u865A\u62DF\u4F9D\u8D56\u914D\u7F6E\u5DF2\u751F\u6210");
     }
   }
   const tsConfigPath = path21.join(cwd, "tsconfig.json");
@@ -4163,15 +4429,17 @@ async function doctor(options = {}) {
         );
       }
       if (!hasExtend) {
-        logger.warn("tsconfig.json \u672A\u7EE7\u627F\u865A\u62DF\u4F9D\u8D56\u914D\u7F6E");
+        logger2.warn("tsconfig.json \u672A\u7EE7\u627F\u865A\u62DF\u4F9D\u8D56\u914D\u7F6E");
         hasIssues = true;
         issues.push("tsconfig.json \u914D\u7F6E\u7F3A\u5931");
         missingTsExtend = true;
       } else {
-        logger.success("tsconfig.json \u914D\u7F6E\u6B63\u5E38");
+        logger2.success("tsconfig.json \u914D\u7F6E\u6B63\u5E38");
       }
-    } catch {
-      logger.error("\u89E3\u6790 tsconfig.json \u5931\u8D25");
+    } catch (e) {
+      logger2.error(
+        `\u89E3\u6790 tsconfig.json \u5931\u8D25 (${tsConfigPath}): ${e.message}`
+      );
     }
   }
   const viteConfigPath = path21.join(cwd, "vite.config.ts");
@@ -4180,7 +4448,7 @@ async function doctor(options = {}) {
     if (!content.includes("vite.alias.json") && !content.includes("CoreKit")) {
     }
   }
-  logger.info(pc14.bold("\nStep 4: \u626B\u63CF\u4EE3\u7801\u89C4\u5219..."));
+  logger2.info(pc14.bold("\nStep 4: \u626B\u63CF\u4EE3\u7801\u89C4\u5219..."));
   const rules = [
     {
       id: "plugin-lifecycle-init",
@@ -4261,6 +4529,10 @@ ${pc14.cyan("\u5EFA\u8BAE\u6839\u636E\u63D0\u793A\u8FDB\u884C\u4FEE\u590D")}`,
         ).start();
         try {
           const tsConfig = await fs18.readJson(tsConfigPath);
+          if (!tsConfig || typeof tsConfig !== "object") {
+            logger2.warn("tsconfig.json \u683C\u5F0F\u65E0\u6548");
+            return;
+          }
           let extendsTarget = "./.chatbi/tsconfig.json";
           if (isMonorepoSub) {
             extendsTarget = path21.relative(
@@ -4312,9 +4584,9 @@ async function ls() {
   const versions = await CoreKit.listVersions();
   const currentVersion = await CoreKit.resolveVersion(process.cwd());
   const globalCurrentVersion = await CoreKit.resolveVersion();
-  logger.info("\u5DF2\u5B89\u88C5\u7684\u5185\u6838\u6C99\u7BB1\u7248\u672C:");
+  logger2.info("\u5DF2\u5B89\u88C5\u7684\u5185\u6838\u6C99\u7BB1\u7248\u672C:");
   if (versions.length === 0) {
-    logger.warn("\u5C1A\u672A\u5B89\u88C5\u4EFB\u4F55\u7248\u672C\uFF0C\u8BF7\u8FD0\u884C chatbi sync \u8FDB\u884C\u5B89\u88C5\u3002");
+    logger2.warn("\u5C1A\u672A\u5B89\u88C5\u4EFB\u4F55\u7248\u672C\uFF0C\u8BF7\u8FD0\u884C chatbi sync \u8FDB\u884C\u5B89\u88C5\u3002");
   } else {
     const list = versions.map((v) => {
       const isGlobalCurrent = v === globalCurrentVersion;
@@ -4360,19 +4632,23 @@ __export(use_exports, {
 import fs19 from "fs-extra";
 import path22 from "path";
 async function use(version, options = {}) {
+  if (!version || typeof version !== "string" || version.trim() === "") {
+    logger2.error("\u7248\u672C\u53F7\u4E0D\u80FD\u4E3A\u7A7A\u6216\u65E0\u6548");
+    return;
+  }
   const versions = await CoreKit.listVersions();
   if (!versions.includes(version)) {
-    logger.warn(`\u7248\u672C ${version} \u5C1A\u672A\u5B89\u88C5\uFF0C\u6B63\u5728\u5C1D\u8BD5\u5B89\u88C5...`);
+    logger2.warn(`\u7248\u672C ${version} \u5C1A\u672A\u5B89\u88C5\uFF0C\u6B63\u5728\u5C1D\u8BD5\u5B89\u88C5...`);
     await Sandbox.prepare(version);
   }
   if (options.global) {
     await Sandbox.useVersion(version);
-    logger.success(`\u5DF2\u5207\u6362\u5168\u5C40\u5185\u6838\u7248\u672C\u81F3: ${version}`);
+    logger2.success(`\u5DF2\u5207\u6362\u5168\u5C40\u5185\u6838\u7248\u672C\u81F3: ${version}`);
   } else {
     const cwd = process.cwd();
     const versionFilePath = path22.join(cwd, ".chatbi-version");
     await fs19.writeFile(versionFilePath, version, "utf-8");
-    logger.success(`\u5DF2\u5207\u6362\u5F53\u524D\u9879\u76EE\u5185\u6838\u7248\u672C\u4E3A: ${version}`);
+    logger2.success(`\u5DF2\u5207\u6362\u5F53\u524D\u9879\u76EE\u5185\u6838\u7248\u672C\u4E3A: ${version}`);
   }
   await sync({ version, force: false });
 }
@@ -4401,8 +4677,10 @@ async function gl(options) {
   const { type: initialType, prompt: initialPrompt } = options;
   const cwd = process.cwd();
   const pkgPath = path23.join(cwd, "package.json");
-  if (!fs20.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");
+  try {
+    await fs20.readJson(pkgPath);
+  } catch {
+    logger2.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 response = await prompts3(
@@ -4448,7 +4726,7 @@ async function gl(options) {
     ],
     {
       onCancel: () => {
-        logger.warn("\u5DF2\u53D6\u6D88 AI \u751F\u6210");
+        logger2.warn("\u5DF2\u53D6\u6D88 AI \u751F\u6210");
         process.exit(0);
       }
     }
@@ -4456,10 +4734,10 @@ async function gl(options) {
   const genType = initialType || response.genType;
   const userPrompt = initialPrompt || response.userPrompt;
   if (!userPrompt && genType !== "chat") {
-    logger.error("\u9700\u6C42\u63CF\u8FF0\u4E0D\u80FD\u4E3A\u7A7A\u3002");
+    logger2.error("\u9700\u6C42\u63CF\u8FF0\u4E0D\u80FD\u4E3A\u7A7A\u3002");
     return;
   }
-  logger.info(`\u6B63\u5728\u547C\u53EB AI \u5F15\u64CE [\u6A21\u5F0F: ${pc16.bold(genType)}]...`);
+  logger2.info(`\u6B63\u5728\u547C\u53EB AI \u5F15\u64CE [\u6A21\u5F0F: ${pc16.bold(genType)}]...`);
   const toolsContext = `
 [Available Tools & Capabilities]
 - Tool: plugin -> For creating new feature modules. Requires: name, type (business|system).
@@ -4503,57 +4781,63 @@ If not, use the SLOT_REQUIRED format.`.trim();
   let retry = true;
   while (retry) {
     spinner.start();
-    try {
-      const { stdout } = await execa7("gemini", [geminiCmd, currentPrompt], {
-        stdio: "pipe"
-      });
+    const { stdout, failed, exitCode, stderr } = await execa7(
+      "gemini",
+      [geminiCmd, currentPrompt],
+      {
+        stdio: "pipe",
+        reject: false
+      }
+    );
+    if (failed) {
       spinner.stop();
-      if (stdout.includes("SLOT_REQUIRED:")) {
-        const slots = [];
-        const lines = stdout.split("\n");
-        for (const line of lines) {
-          if (line.includes("SLOT_REQUIRED:")) {
-            const match = line.match(/SLOT_REQUIRED:\s*([^|]+)\|\s*(.+)/);
-            if (match) {
-              slots.push({
-                type: "text",
-                name: match[1].trim(),
-                message: match[2].trim()
-              });
-            }
+      if (exitCode === "ENOENT" || exitCode === 127 || exitCode === "ENOENT") {
+        logger2.error("\u672A\u5728\u7CFB\u7EDF\u4E2D\u627E\u5230 `gemini-cli` \u547D\u4EE4\u3002");
+        logger2.info(
+          pc16.yellow("\u8BF7\u786E\u4FDD\u5DF2\u5B89\u88C5 gemini-cli \u5E76\u5C06\u5176\u6DFB\u52A0\u5230\u7CFB\u7EDF PATH \u4E2D\u3002")
+        );
+      } else {
+        logger2.error(
+          `AI \u751F\u6210\u8FC7\u7A0B\u4E2D\u51FA\u9519: exitCode=${exitCode}, stderr=${stderr || stdout}`
+        );
+      }
+      return;
+    }
+    spinner.stop();
+    if (stdout.includes("SLOT_REQUIRED:")) {
+      const slots = [];
+      const lines = stdout.split("\n");
+      for (const line of lines) {
+        if (line.includes("SLOT_REQUIRED:")) {
+          const match = line.match(/SLOT_REQUIRED:\s*([^|]+)\|\s*(.+)/);
+          if (match) {
+            slots.push({
+              type: "text",
+              name: match[1].trim(),
+              message: match[2].trim()
+            });
           }
         }
-        if (slots.length > 0) {
-          logger.info(pc16.yellow("\n\u{1F4DD} AI \u9700\u8981\u66F4\u591A\u4FE1\u606F\u4EE5\u7EE7\u7EED:"));
-          const answers = await prompts3(slots, {
-            onCancel: () => process.exit(0)
-          });
-          const answerContext = Object.entries(answers).map(([k, v]) => `[${k}]: ${v}`).join("\n");
-          currentPrompt += `
+      }
+      if (slots.length > 0) {
+        logger2.info(pc16.yellow("\n\u{1F4DD} AI \u9700\u8981\u66F4\u591A\u4FE1\u606F\u4EE5\u7EE7\u7EED:"));
+        const answers = await prompts3(slots, {
+          onCancel: () => process.exit(0)
+        });
+        const answerContext = Object.entries(answers).map(([k, v]) => `[${k}]: ${v}`).join("\n");
+        currentPrompt += `
 
 [User Answers]:
 ${answerContext}
 
 Please proceed with generation based on these answers.`;
-          logger.info("\u6B63\u5728\u6839\u636E\u60A8\u7684\u53CD\u9988\u91CD\u65B0\u547C\u53EB AI...");
-          continue;
-        }
-      }
-      logger.info("\n" + stdout);
-      retry = false;
-      logger.success(`AI \u547D\u4EE4 [gemini ${geminiCmd}] \u6267\u884C\u5B8C\u6BD5!`);
-    } catch (error) {
-      spinner.stop();
-      if (error.code === "ENOENT") {
-        logger.error("\u672A\u5728\u7CFB\u7EDF\u4E2D\u627E\u5230 `gemini-cli` \u547D\u4EE4\u3002");
-        logger.info(
-          pc16.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}`);
+        logger2.info("\u6B63\u5728\u6839\u636E\u60A8\u7684\u53CD\u9988\u91CD\u65B0\u547C\u53EB AI...");
+        continue;
       }
-      throw error;
     }
+    logger2.info("\n" + stdout);
+    retry = false;
+    logger2.success(`AI \u547D\u4EE4 [gemini ${geminiCmd}] \u6267\u884C\u5B8C\u6BD5!`);
   }
 }
 var init_gl = __esm({
@@ -4576,7 +4860,7 @@ async function discover() {
   const plugins = await CoreKit.discoverPlugins(cwd);
   if (plugins.length === 0) {
     spinner.warn("\u672A\u53D1\u73B0\u4EFB\u4F55\u63D2\u4EF6");
-    logger.info(
+    logger2.info(
       pc17.gray("\u8BF7\u786E\u4FDD\u63D2\u4EF6\u5DF2\u88AB\u5DE5\u4F5C\u533A\u914D\u7F6E\u5305\u542B\uFF0C\u4E14\u76EE\u5F55\u4E2D\u5B58\u5728 package.json\u3002")
     );
   } else {
@@ -4623,7 +4907,7 @@ async function clean(options) {
       // 深度清理默认选否，普通清理默认选是
     });
     if (!confirm) {
-      logger.warn("\u5DF2\u53D6\u6D88\u6E05\u7406");
+      logger2.warn("\u5DF2\u53D6\u6D88\u6E05\u7406");
       return;
     }
   }
@@ -4648,7 +4932,7 @@ import os3 from "os";
 import path24 from "path";
 import pc18 from "picocolors";
 async function bench() {
-  logger.info("\u6B63\u5728\u542F\u52A8 CLI \u6027\u80FD\u57FA\u51C6\u6D4B\u8BD5...");
+  logger2.info("\u6B63\u5728\u542F\u52A8 CLI \u6027\u80FD\u57FA\u51C6\u6D4B\u8BD5...");
   const results = [];
   const tmpDir = path24.join(os3.tmpdir(), `chatbi-bench-${Date.now()}`);
   await fs21.ensureDir(tmpDir);
@@ -4728,14 +5012,14 @@ import { loadESLint } from "eslint";
 import fs22 from "fs-extra";
 import path25 from "path";
 async function lintTheme(options) {
-  const projectRoot = findProjectRoot(process.cwd());
+  const projectRoot = await findProjectRoot(process.cwd());
   const cwd = projectRoot;
   const target = options.target || ".";
   const files = [path25.isAbsolute(target) ? target : path25.resolve(cwd, target)];
   if (options.debug) {
-    logger.info("Starting Theme Lint...");
-    logger.info(`Target: ${target}`);
-    logger.info(`Options: ${JSON.stringify(options)}`);
+    logger2.info("Starting Theme Lint...");
+    logger2.info(`Target: ${target}`);
+    logger2.info(`Options: ${JSON.stringify(options)}`);
   }
   try {
     const ESLint = await loadESLint({ useFlatConfig: true });
@@ -4762,11 +5046,11 @@ async function lintTheme(options) {
         }
       ]
     });
-    logger.info(`Scanning files in ${target} for theme violations...`);
+    logger2.info(`Scanning files in ${target} for theme violations...`);
     const results = await eslint.lintFiles(files);
     if (options.fix) {
       await ESLint.outputFixes(results);
-      logger.success("Auto-fixes applied where possible.");
+      logger2.success("Auto-fixes applied where possible.");
     }
     const themeRuleIds = [
       "@chatbi-v/theme/no-hardcoded-colors",
@@ -4799,7 +5083,7 @@ async function lintTheme(options) {
     if (options.output) {
       await fs22.ensureDir(path25.dirname(options.output));
       await fs22.outputFile(options.output, resultText);
-      logger.success(`Report generated at ${options.output}`);
+      logger2.success(`Report generated at ${options.output}`);
     } else {
       console.log(resultText);
     }
@@ -4812,17 +5096,17 @@ async function lintTheme(options) {
       0
     );
     if (errorCount > 0) {
-      logger.error(
+      logger2.error(
         `Lint failed with ${errorCount} errors and ${warningCount} warnings.`
       );
       process.exit(1);
     } else if (warningCount > 0) {
-      logger.warn(`Lint finished with ${warningCount} warnings.`);
+      logger2.warn(`Lint finished with ${warningCount} warnings.`);
     } else {
-      logger.success("Theme lint passed!");
+      logger2.success("Theme lint passed!");
     }
   } catch (error) {
-    logger.error("An error occurred during linting:", error);
+    logger2.error("An error occurred during linting:", error);
     process.exit(1);
   }
 }
@@ -4835,7 +5119,7 @@ var init_lint_theme = __esm({
     importThemePlugin = async () => {
       try {
         const { createRequire: createRequire3 } = await import("module");
-        const projectRoot = findProjectRoot(process.cwd());
+        const projectRoot = await findProjectRoot(process.cwd());
         const pluginPath = path25.resolve(
           projectRoot,
           "node_modules/@chatbi-v/eslint-plugin-theme"
@@ -4843,15 +5127,23 @@ var init_lint_theme = __esm({
         const require2 = createRequire3(import.meta.url);
         return require2(pluginPath);
       } catch (e) {
-        logger.error("Failed to load @chatbi-v/eslint-plugin-theme", e);
+        logger2.error("Failed to load @chatbi-v/eslint-plugin-theme", e);
         throw e;
       }
     };
-    findProjectRoot = (startDir) => {
+    findProjectRoot = async (startDir) => {
       let current = startDir;
       while (current !== path25.dirname(current)) {
-        if (fs22.existsSync(path25.join(current, "package.json")) && fs22.existsSync(path25.join(current, "pnpm-workspace.yaml"))) {
+        const pkgJsonPath2 = path25.join(current, "package.json");
+        const workspaceYamlPath = path25.join(current, "pnpm-workspace.yaml");
+        try {
+          await Promise.all([
+            fs22.readFile(pkgJsonPath2, "utf-8"),
+            fs22.readFile(workspaceYamlPath, "utf-8")
+          ]);
           return current;
+        } catch (e) {
+          logger2.debug(`\u67E5\u627E\u9879\u76EE\u6839\u76EE\u5F55\u5931\u8D25: ${e.message}`);
         }
         current = path25.dirname(current);
       }
@@ -4937,9 +5229,9 @@ async function pluginCreate(options) {
     data = PluginCreateSchema.parse(validated);
   } catch (error) {
     if (error instanceof z2.ZodError) {
-      logger.error(`\u9A8C\u8BC1\u5931\u8D25: ${formatZodError(error)}`);
+      logger2.error(`\u9A8C\u8BC1\u5931\u8D25: ${formatZodError(error)}`);
     } else {
-      logger.error(`\u9A8C\u8BC1\u5931\u8D25: ${error.message}`);
+      logger2.error(`\u9A8C\u8BC1\u5931\u8D25: ${error.message}`);
     }
     return;
   }
@@ -4947,9 +5239,8 @@ async function pluginCreate(options) {
   let cliVersion = "3.1.0";
   try {
     const pkgPath = path26.join(__dirname, "../../../../package.json");
-    if (fs23.existsSync(pkgPath)) {
-      cliVersion = fs23.readJsonSync(pkgPath).version || "3.1.0";
-    }
+    const pkgContent = fs23.readJsonSync(pkgPath);
+    cliVersion = pkgContent.version || cliVersion;
   } catch {
   }
   const pluginData = {
@@ -4976,21 +5267,21 @@ async function pluginCreate(options) {
   }
   if (fs23.existsSync(targetDir)) {
     if (force) {
-      logger.info("\u5F3A\u5236\u8986\u76D6\u6A21\u5F0F\uFF0C\u6E05\u7406\u76EE\u6807\u76EE\u5F55...");
+      logger2.info("\u5F3A\u5236\u8986\u76D6\u6A21\u5F0F\uFF0C\u6E05\u7406\u76EE\u6807\u76EE\u5F55...");
       fs23.removeSync(targetDir);
     } else {
       throw new Error(`\u76EE\u6807\u76EE\u5F55\u5DF2\u5B58\u5728: ${targetDir}`);
     }
   }
-  logger.info(`
+  logger2.info(`
 ${pc19.bold("\u63D2\u4EF6\u521B\u5EFA\u9884\u89C8")}`);
-  logger.info(`\u540D\u79F0: ${pc19.cyan(pluginData.name)}`);
-  logger.info(`\u6A21\u677F: ${pc19.yellow(templateMeta.name)}`);
-  logger.info(`TypeScript: ${pc19.yellow(pluginData.typescript ? "\u662F" : "\u5426")}`);
+  logger2.info(`\u540D\u79F0: ${pc19.cyan(pluginData.name)}`);
+  logger2.info(`\u6A21\u677F: ${pc19.yellow(templateMeta.name)}`);
+  logger2.info(`TypeScript: ${pc19.yellow(pluginData.typescript ? "\u662F" : "\u5426")}`);
   const files = await listGeneratedFiles();
-  logger.info(`
+  logger2.info(`
 ${pc19.bold("\u5C06\u521B\u5EFA\u4EE5\u4E0B\u6587\u4EF6:")}`);
-  files.forEach((f) => logger.info(`  ${pc19.green("+")} ${f}`));
+  files.forEach((f) => logger2.info(`  ${pc19.green("+")} ${f}`));
   let confirmed = true;
   if (process.stdout.isTTY) {
     const response = await prompts5(
@@ -5017,7 +5308,9 @@ ${pc19.bold("\u5C06\u521B\u5EFA\u4EE5\u4E0B\u6587\u4EF6:")}`);
     "templates/plugin",
     templateMeta.dir || ""
   );
-  if (!fs23.existsSync(targetTemplateDir)) {
+  try {
+    await fs23.access(targetTemplateDir);
+  } catch {
     throw new Error(`\u6A21\u677F\u76EE\u5F55\u4E0D\u5B58\u5728: ${targetTemplateDir}`);
   }
   await fs23.ensureDir(targetDir);
@@ -5041,9 +5334,9 @@ ${pc19.bold("\u5C06\u521B\u5EFA\u4EE5\u4E0B\u6587\u4EF6:")}`);
     force: true,
     silent: true
   });
-  logger.success(`
+  logger2.success(`
 \u63D2\u4EF6 ${pc19.green(pluginData.name)} \u521B\u5EFA\u6210\u529F!`);
-  logger.info(
+  logger2.info(
     `\u8BF7\u8FD0\u884C ${pc19.cyan(`cd ${path26.relative(process.cwd(), targetDir)}`)} \u5F00\u59CB\u5F00\u53D1`
   );
 }
@@ -5082,7 +5375,11 @@ async function readPluginManifestFile(pluginRoot) {
   if (!manifestPath) {
     return null;
   }
-  return fs24.readJson(manifestPath);
+  try {
+    return await fs24.readJson(manifestPath);
+  } catch {
+    return null;
+  }
 }
 async function writePluginManifestFile(pluginRoot, manifest) {
   const manifestPath = await findPluginManifestPath(pluginRoot) || path27.join(pluginRoot, "src", "plugin.json");
@@ -5119,7 +5416,7 @@ async function pluginBuild(options = {}) {
   const pkgPath = path28.join(cwd, "package.json");
   if (!fs25.existsSync(pkgPath)) {
     spinner.fail("\u672A\u627E\u5230 package.json");
-    logger.error("\u8BF7\u5728\u63D2\u4EF6\u76EE\u5F55\u4E2D\u8FD0\u884C\u6B64\u547D\u4EE4");
+    logger2.error("\u8BF7\u5728\u63D2\u4EF6\u76EE\u5F55\u4E2D\u8FD0\u884C\u6B64\u547D\u4EE4");
     return;
   }
   const pkg = await fs25.readJson(pkgPath);
@@ -5129,7 +5426,7 @@ async function pluginBuild(options = {}) {
     entry = "src/index.tsx";
   } else if (!fs25.existsSync(path28.join(cwd, "src/index.ts"))) {
     spinner.fail("\u672A\u627E\u5230\u5165\u53E3\u6587\u4EF6");
-    logger.error("\u671F\u671B src/index.ts \u6216 src/index.tsx");
+    logger2.error("\u671F\u671B src/index.ts \u6216 src/index.tsx");
     return;
   }
   const pluginJsonPath = await findPluginManifestPath(cwd);
@@ -5178,7 +5475,7 @@ async function pluginBuild(options = {}) {
     esmSpinner.succeed("ESM \u683C\u5F0F\u6784\u5EFA\u5B8C\u6210");
   } catch (e) {
     esmSpinner.fail("ESM \u683C\u5F0F\u6784\u5EFA\u5931\u8D25");
-    logger.error(`\u6784\u5EFA\u5931\u8D25: ${e.message}`);
+    logger2.error(`\u6784\u5EFA\u5931\u8D25: ${e.message}`);
     return;
   }
   const iifeSpinner = createSpinner("\u6B63\u5728\u6784\u5EFA IIFE \u683C\u5F0F...").start();
@@ -5213,7 +5510,7 @@ async function pluginBuild(options = {}) {
     iifeSpinner.succeed("IIFE \u683C\u5F0F\u6784\u5EFA\u5B8C\u6210");
   } catch (e) {
     iifeSpinner.fail("IIFE \u683C\u5F0F\u6784\u5EFA\u5931\u8D25");
-    logger.error(`\u6784\u5EFA\u5931\u8D25: ${e.message}`);
+    logger2.error(`\u6784\u5EFA\u5931\u8D25: ${e.message}`);
     return;
   }
   const distDir = path28.join(cwd, "dist");
@@ -5226,7 +5523,7 @@ async function pluginBuild(options = {}) {
     );
   }
   if (watch) {
-    logger.info(pc20.gray("\u76D1\u542C\u6A21\u5F0F\u5DF2\u5F00\u542F\uFF0C\u6309 Ctrl+C \u505C\u6B62..."));
+    logger2.info(pc20.gray("\u76D1\u542C\u6A21\u5F0F\u5DF2\u5F00\u542F\uFF0C\u6309 Ctrl+C \u505C\u6B62..."));
   }
 }
 var init_build2 = __esm({
@@ -5289,25 +5586,25 @@ async function pluginDelete(name, options) {
   const workspaceRoot = await SandboxPath.getWorkspaceRoot(process.cwd());
   const pluginDir = await CoreKit.resolvePluginDirectory(workspaceRoot, name);
   if (!pluginDir || !fs26.existsSync(pluginDir)) {
-    logger.error(`\u63D2\u4EF6 ${name} \u4E0D\u5B58\u5728`);
+    logger2.error(`\u63D2\u4EF6 ${name} \u4E0D\u5B58\u5728`);
     return;
   }
   const manifest = await readPluginManifest(pluginDir);
   if (!manifest) {
-    logger.error(`\u65E0\u6CD5\u8BFB\u53D6\u63D2\u4EF6 ${name} \u7684\u5143\u6570\u636E\uFF0C\u8BF7\u68C0\u67E5 plugin.json \u662F\u5426\u5B58\u5728`);
+    logger2.error(`\u65E0\u6CD5\u8BFB\u53D6\u63D2\u4EF6 ${name} \u7684\u5143\u6570\u636E\uFF0C\u8BF7\u68C0\u67E5 plugin.json \u662F\u5426\u5B58\u5728`);
     return;
   }
   const pluginType = manifest.type || "business";
   const pluginId = manifest.id || name;
   if (isSystemPlugin(pluginType)) {
-    logger.error(`\u65E0\u6CD5\u5220\u9664\u7CFB\u7EDF\u63D2\u4EF6 ${name} (type=${pluginType})`);
-    logger.info("\u7CFB\u7EDF\u63D2\u4EF6\u53D7\u5230\u4FDD\u62A4\uFF0C\u65E0\u6CD5\u5220\u9664");
+    logger2.error(`\u65E0\u6CD5\u5220\u9664\u7CFB\u7EDF\u63D2\u4EF6 ${name} (type=${pluginType})`);
+    logger2.info("\u7CFB\u7EDF\u63D2\u4EF6\u53D7\u5230\u4FDD\u62A4\uFF0C\u65E0\u6CD5\u5220\u9664");
     return;
   }
   const dependents = await findDependentPlugins(pluginId);
   if (dependents.length > 0) {
-    logger.warn(`\u4EE5\u4E0B\u63D2\u4EF6\u4F9D\u8D56\u6B64\u63D2\u4EF6: ${dependents.join(", ")}`);
-    logger.info("\u5220\u9664\u524D\u8BF7\u786E\u4FDD\u8FD9\u4E9B\u63D2\u4EF6\u5DF2\u66F4\u65B0\u6216\u79FB\u9664\u76F8\u5173\u4F9D\u8D56");
+    logger2.warn(`\u4EE5\u4E0B\u63D2\u4EF6\u4F9D\u8D56\u6B64\u63D2\u4EF6: ${dependents.join(", ")}`);
+    logger2.info("\u5220\u9664\u524D\u8BF7\u786E\u4FDD\u8FD9\u4E9B\u63D2\u4EF6\u5DF2\u66F4\u65B0\u6216\u79FB\u9664\u76F8\u5173\u4F9D\u8D56");
   }
   if (!options.force) {
     const { confirm } = await prompts6(
@@ -5319,24 +5616,24 @@ async function pluginDelete(name, options) {
       },
       {
         onCancel: () => {
-          logger.info("\u5DF2\u53D6\u6D88\u5220\u9664");
+          logger2.info("\u5DF2\u53D6\u6D88\u5220\u9664");
           return;
         }
       }
     );
     if (!confirm) {
-      logger.info("\u5DF2\u53D6\u6D88\u5220\u9664");
+      logger2.info("\u5DF2\u53D6\u6D88\u5220\u9664");
       return;
     }
   }
   try {
     await fs26.remove(pluginDir);
   } catch (err) {
-    logger.error(`\u5220\u9664\u63D2\u4EF6 ${name} \u5931\u8D25`, err);
+    logger2.error(`\u5220\u9664\u63D2\u4EF6 ${name} \u5931\u8D25`, err);
     return;
   }
-  logger.success(`\u63D2\u4EF6 ${name} \u5DF2\u5220\u9664`);
-  logger.info(`\u5DF2\u79FB\u9664: ${path29.relative(workspaceRoot, pluginDir)}`);
+  logger2.success(`\u63D2\u4EF6 ${name} \u5DF2\u5220\u9664`);
+  logger2.info(`\u5DF2\u79FB\u9664: ${path29.relative(workspaceRoot, pluginDir)}`);
 }
 var init_delete = __esm({
   "src/commands/plugin/delete.ts"() {
@@ -5367,14 +5664,15 @@ async function pluginValidate(options = {}) {
   };
   const spinner = createSpinner("\u6B63\u5728\u9A8C\u8BC1\u63D2\u4EF6\u914D\u7F6E...").start();
   const pkgPath = path30.join(cwd, "package.json");
-  if (!fs27.existsSync(pkgPath)) {
-    spinner.fail("\u672A\u627E\u5230 package.json");
+  let pkg = {};
+  try {
+    pkg = await fs27.readJson(pkgPath);
+  } catch {
+    spinner.fail("\u672A\u627E\u5230\u6216\u65E0\u6CD5\u8BFB\u53D6 package.json");
     result.valid = false;
-    result.errors.push("\u672A\u627E\u5230 package.json");
+    result.errors.push("\u672A\u627E\u5230\u6216\u65E0\u6CD5\u8BFB\u53D6 package.json");
     return result;
   }
-  spinner.text = "\u6B63\u5728\u8BFB\u53D6\u63D2\u4EF6\u914D\u7F6E...";
-  const pkg = await fs27.readJson(pkgPath);
   const pluginJsonPath = await findPluginManifestPath(cwd);
   if (!pluginJsonPath) {
     spinner.fail("\u672A\u627E\u5230 src/plugin.json");
@@ -5398,14 +5696,15 @@ async function pluginValidate(options = {}) {
         fixSpinner.succeed("\u5DF2\u521B\u5EFA src/plugin.json");
         result.errors = result.errors.filter((e) => !e.includes("plugin.json"));
       } catch (e) {
-        fixSpinner.fail("\u521B\u5EFA\u5931\u8D25");
+        fixSpinner.fail(`\u521B\u5EFA\u5931\u8D25: ${e.message}`);
       }
     }
     return result;
   }
   spinner.text = "\u6B63\u5728\u9A8C\u8BC1 Manifest \u683C\u5F0F...";
+  let pluginJson;
   try {
-    const pluginJson = await fs27.readJson(pluginJsonPath);
+    pluginJson = await fs27.readJson(pluginJsonPath);
     const validation = validateManifest(pluginJson);
     if (!validation.valid || !validation.data) {
       spinner.fail("Manifest \u683C\u5F0F\u9A8C\u8BC1\u5931\u8D25");
@@ -5417,7 +5716,9 @@ async function pluginValidate(options = {}) {
     }
     if (typeof validation.data.entry === "string") {
       const entryPath = path30.join(cwd, validation.data.entry);
-      if (!fs27.existsSync(entryPath)) {
+      try {
+        await fs27.access(entryPath);
+      } catch {
         spinner.fail(`\u5165\u53E3\u6587\u4EF6\u4E0D\u5B58\u5728: ${validation.data.entry}`);
         result.valid = false;
         result.errors.push(`\u5165\u53E3\u6587\u4EF6\u4E0D\u5B58\u5728: ${validation.data.entry}`);
@@ -5438,7 +5739,9 @@ async function pluginValidate(options = {}) {
         continue;
       }
       const depPath = path30.join(nodeModulesPath, dep);
-      if (!fs27.existsSync(depPath)) {
+      try {
+        await fs27.access(depPath);
+      } catch {
         result.warnings.push(`\u4F9D\u8D56\u672A\u5B89\u88C5: ${dep}@${version}`);
       }
     }
@@ -5477,7 +5780,7 @@ __export(publish_exports, {
   pluginPublish: () => pluginPublish
 });
 async function pluginPublish(options) {
-  logger.warn("\u63D2\u4EF6\u53D1\u5E03\u529F\u80FD\u6B63\u5728\u5F00\u53D1\u4E2D...");
+  logger2.warn("\u63D2\u4EF6\u53D1\u5E03\u529F\u80FD\u6B63\u5728\u5F00\u53D1\u4E2D...");
 }
 var init_publish = __esm({
   "src/commands/plugin/publish.ts"() {
@@ -5530,7 +5833,7 @@ async function pluginList(options = {}) {
   const discoveredPlugins = await CoreKit.discoverPlugins(cwd);
   if (discoveredPlugins.length === 0) {
     spinner.warn("\u672A\u53D1\u73B0\u4EFB\u4F55\u63D2\u4EF6");
-    logger.info(
+    logger2.info(
       pc22.gray("\u8BF7\u786E\u4FDD\u63D2\u4EF6\u5DF2\u88AB\u5DE5\u4F5C\u533A\u914D\u7F6E\u5305\u542B\uFF0C\u4E14\u76EE\u5F55\u4E2D\u5B58\u5728 package.json\u3002")
     );
     return;
@@ -5634,7 +5937,7 @@ async function resolveVersion(pluginName, pluginDir, version) {
       throw new Error(`\u65E0\u6CD5\u8BFB\u53D6\u63D2\u4EF6 ${pluginName} \u7684 package.json`);
     }
     if (satisfiesVersion(packageJson.version, version)) {
-      logger.info(
+      logger2.info(
         `\u63D2\u4EF6 ${pluginName} \u5F53\u524D\u7248\u672C ${packageJson.version} \u5DF2\u6EE1\u8DB3\u8303\u56F4 ${version}`
       );
       return packageJson.version;
@@ -5703,43 +6006,43 @@ function checkVersionCompatibility(current, target, compatibility) {
   return { compatible: true, severity: finalSeverity };
 }
 function showDryRunPreview(pluginName, currentVersion, targetVersion, compatibility, manifest) {
-  logger.info("=".repeat(50));
-  logger.info(`\u63D2\u4EF6 ${pluginName} \u66F4\u65B0\u9884\u89C8 (dry-run)`);
-  logger.info("=".repeat(50));
-  logger.info(`\u5F53\u524D\u7248\u672C: ${currentVersion}`);
-  logger.info(`\u76EE\u6807\u7248\u672C: ${targetVersion}`);
-  logger.info("");
-  logger.info("\u517C\u5BB9\u6027\u68C0\u67E5:");
+  logger2.info("=".repeat(50));
+  logger2.info(`\u63D2\u4EF6 ${pluginName} \u66F4\u65B0\u9884\u89C8 (dry-run)`);
+  logger2.info("=".repeat(50));
+  logger2.info(`\u5F53\u524D\u7248\u672C: ${currentVersion}`);
+  logger2.info(`\u76EE\u6807\u7248\u672C: ${targetVersion}`);
+  logger2.info("");
+  logger2.info("\u517C\u5BB9\u6027\u68C0\u67E5:");
   if (compatibility.compatible) {
-    logger.success(`  \u2713 \u517C\u5BB9 (severity: ${compatibility.severity})`);
+    logger2.success(`  \u2713 \u517C\u5BB9 (severity: ${compatibility.severity})`);
   } else {
-    logger.error(`  \u2717 \u4E0D\u517C\u5BB9: ${compatibility.reason}`);
+    logger2.error(`  \u2717 \u4E0D\u517C\u5BB9: ${compatibility.reason}`);
   }
-  logger.info("");
-  logger.info("\u5C06\u8981\u66F4\u65B0\u7684\u5B57\u6BB5:");
-  logger.info(`  - version: ${currentVersion} \u2192 ${targetVersion}`);
+  logger2.info("");
+  logger2.info("\u5C06\u8981\u66F4\u65B0\u7684\u5B57\u6BB5:");
+  logger2.info(`  - version: ${currentVersion} \u2192 ${targetVersion}`);
   if (manifest.compatibility) {
-    logger.info(`  - compatibility: ${JSON.stringify(manifest.compatibility)}`);
+    logger2.info(`  - compatibility: ${JSON.stringify(manifest.compatibility)}`);
   }
-  logger.info("");
-  logger.info("\u6CE8\u610F: \u8FD9\u662F\u9884\u89C8\u6A21\u5F0F\uFF0C\u672A\u6267\u884C\u5B9E\u9645\u66F4\u65B0");
-  logger.info("=".repeat(50));
+  logger2.info("");
+  logger2.info("\u6CE8\u610F: \u8FD9\u662F\u9884\u89C8\u6A21\u5F0F\uFF0C\u672A\u6267\u884C\u5B9E\u9645\u66F4\u65B0");
+  logger2.info("=".repeat(50));
 }
 async function pluginUpdate(name, options = {}) {
   const workspaceRoot = await SandboxPath.getWorkspaceRoot(process.cwd());
   const pluginDir = await CoreKit.resolvePluginDirectory(workspaceRoot, name);
   if (!pluginDir || !fs29.existsSync(pluginDir)) {
-    logger.error(`\u63D2\u4EF6 ${name} \u4E0D\u5B58\u5728`);
+    logger2.error(`\u63D2\u4EF6 ${name} \u4E0D\u5B58\u5728`);
     return;
   }
   const manifest = await readPluginManifest3(pluginDir);
   if (!manifest) {
-    logger.error(`\u65E0\u6CD5\u8BFB\u53D6\u63D2\u4EF6 ${name} \u7684\u5143\u6570\u636E\uFF0C\u8BF7\u68C0\u67E5 plugin.json \u662F\u5426\u5B58\u5728`);
+    logger2.error(`\u65E0\u6CD5\u8BFB\u53D6\u63D2\u4EF6 ${name} \u7684\u5143\u6570\u636E\uFF0C\u8BF7\u68C0\u67E5 plugin.json \u662F\u5426\u5B58\u5728`);
     return;
   }
   const packageJson = await readPluginPackageJson(pluginDir);
   if (!packageJson) {
-    logger.error(`\u65E0\u6CD5\u8BFB\u53D6\u63D2\u4EF6 ${name} \u7684 package.json`);
+    logger2.error(`\u65E0\u6CD5\u8BFB\u53D6\u63D2\u4EF6 ${name} \u7684 package.json`);
     return;
   }
   const currentVersion = packageJson.version;
@@ -5747,11 +6050,11 @@ async function pluginUpdate(name, options = {}) {
   try {
     targetVersion = await resolveVersion(name, pluginDir, options.version);
   } catch (err) {
-    logger.error(err.message);
+    logger2.error(err.message);
     return;
   }
   if (targetVersion === currentVersion) {
-    logger.info(`\u63D2\u4EF6 ${name} \u5DF2\u662F\u6700\u65B0\u7248\u672C ${currentVersion}`);
+    logger2.info(`\u63D2\u4EF6 ${name} \u5DF2\u662F\u6700\u65B0\u7248\u672C ${currentVersion}`);
     return;
   }
   if (!options.force) {
@@ -5761,17 +6064,17 @@ async function pluginUpdate(name, options = {}) {
       manifest.compatibility
     );
     if (!compatibility.compatible) {
-      logger.error(`\u66F4\u65B0\u5931\u8D25: ${compatibility.reason}`);
-      logger.info("\u4F7F\u7528 --force \u53EF\u7ED5\u8FC7\u517C\u5BB9\u6027\u68C0\u67E5 (\u53EF\u80FD\u5B58\u5728\u98CE\u9669)");
+      logger2.error(`\u66F4\u65B0\u5931\u8D25: ${compatibility.reason}`);
+      logger2.info("\u4F7F\u7528 --force \u53EF\u7ED5\u8FC7\u517C\u5BB9\u6027\u68C0\u67E5 (\u53EF\u80FD\u5B58\u5728\u98CE\u9669)");
       return;
     }
     if (compatibility.severity === "major") {
-      logger.warn(
+      logger2.warn(
         `\u8B66\u544A: \u6B64\u66F4\u65B0\u5305\u542B\u7834\u574F\u6027\u53D8\u66F4 (severity: ${compatibility.severity})`
       );
     }
   } else {
-    logger.warn("\u5F3A\u5236\u6A21\u5F0F: \u8DF3\u8FC7\u517C\u5BB9\u6027\u68C0\u67E5");
+    logger2.warn("\u5F3A\u5236\u6A21\u5F0F: \u8DF3\u8FC7\u517C\u5BB9\u6027\u68C0\u67E5");
   }
   if (options.dryRun) {
     const compatibility = checkVersionCompatibility(
@@ -5795,13 +6098,13 @@ async function pluginUpdate(name, options = {}) {
   try {
     await writePluginManifestFile(pluginDir, updatedManifest);
   } catch (err) {
-    logger.error(`\u66F4\u65B0\u63D2\u4EF6 ${name} \u5931\u8D25`, err);
+    logger2.error(`\u66F4\u65B0\u63D2\u4EF6 ${name} \u5931\u8D25`, err);
     return;
   }
-  logger.success(`\u63D2\u4EF6 ${name} \u5DF2\u66F4\u65B0`);
-  logger.info(`  ${currentVersion} \u2192 ${targetVersion}`);
+  logger2.success(`\u63D2\u4EF6 ${name} \u5DF2\u66F4\u65B0`);
+  logger2.info(`  ${currentVersion} \u2192 ${targetVersion}`);
   if (manifest.compatibility) {
-    logger.info(`  \u517C\u5BB9\u6027\u8981\u6C42: ${JSON.stringify(manifest.compatibility)}`);
+    logger2.info(`  \u517C\u5BB9\u6027\u8981\u6C42: ${JSON.stringify(manifest.compatibility)}`);
   }
 }
 var init_update = __esm({
@@ -5827,8 +6130,12 @@ async function themeCreate(options) {
   const { name, base = "standard", css = false } = options;
   const targetDir = path33.join(process.cwd(), "themes", name);
   const baseTheme = BASE_THEMES[base];
-  logger.info(`\u6B63\u5728\u521B\u5EFA\u4E3B\u9898: ${pc23.cyan(name)}`);
-  logger.info(`\u57FA\u7840\u4E3B\u9898: ${pc23.yellow(baseTheme.name)}`);
+  if (!baseTheme) {
+    logger2.error(`\u65E0\u6548\u7684\u57FA\u7840\u4E3B\u9898: ${base}\uFF0C\u53EF\u9009\u503C: standard, nebula, glass`);
+    return;
+  }
+  logger2.info(`\u6B63\u5728\u521B\u5EFA\u4E3B\u9898: ${pc23.cyan(name)}`);
+  logger2.info(`\u57FA\u7840\u4E3B\u9898: ${pc23.yellow(baseTheme.name)}`);
   await fs30.ensureDir(targetDir);
   if (css) {
     const cssContent = `:root {
@@ -5868,7 +6175,7 @@ async function themeCreate(options) {
   await fs30.writeJson(path33.join(targetDir, "theme.json"), themeJson, {
     spaces: 2
   });
-  logger.success(`\u4E3B\u9898 ${pc23.green(name)} \u521B\u5EFA\u6210\u529F!`);
+  logger2.success(`\u4E3B\u9898 ${pc23.green(name)} \u521B\u5EFA\u6210\u529F!`);
 }
 var BASE_THEMES;
 var init_create2 = __esm({
@@ -5908,13 +6215,24 @@ async function scaffold(options) {
     typescript = true,
     theme = "standard"
   } = options;
+  if (name.includes("..") || path34.isAbsolute(name)) {
+    logger2.error(`\u65E0\u6548\u7684\u9879\u76EE\u540D\u79F0: ${name}\uFF0C\u4E0D\u80FD\u5305\u542B\u8DEF\u5F84\u904D\u5386\u5E8F\u5217\u6216\u7EDD\u5BF9\u8DEF\u5F84`);
+    return;
+  }
   const targetDir = path34.join(process.cwd(), name);
-  if (fs31.existsSync(targetDir)) {
-    logger.error(`\u76EE\u5F55 ${name} \u5DF2\u5B58\u5728`);
+  try {
+    await fs31.access(targetDir);
+    logger2.error(`\u76EE\u5F55 ${name} \u5DF2\u5B58\u5728`);
+    return;
+  } catch {
+  }
+  const templateMeta = TEMPLATES2[template];
+  if (!templateMeta) {
+    logger2.error(`\u65E0\u6548\u7684\u6A21\u677F\u7C7B\u578B: ${template}\uFF0C\u53EF\u9009\u503C: full, minimal, empty`);
     return;
   }
-  logger.info(`\u6B63\u5728\u521B\u5EFA\u9879\u76EE: ${pc24.cyan(name)}`);
-  logger.info(`\u6A21\u677F: ${pc24.yellow(TEMPLATES2[template].name)}`);
+  logger2.info(`\u6B63\u5728\u521B\u5EFA\u9879\u76EE: ${pc24.cyan(name)}`);
+  logger2.info(`\u6A21\u677F: ${pc24.yellow(templateMeta.name)}`);
   await fs31.ensureDir(targetDir);
   const packageJson = {
     name,
@@ -5955,8 +6273,8 @@ export default defineConfig({
 `;
     await fs31.writeFile(path34.join(targetDir, "vite.config.ts"), viteConfig);
   }
-  logger.success(`\u9879\u76EE ${pc24.green(name)} \u521B\u5EFA\u6210\u529F!`);
-  logger.info(`\u8BF7\u8FD0\u884C ${pc24.cyan(`cd ${name} && pnpm install`)} \u5B89\u88C5\u4F9D\u8D56`);
+  logger2.success(`\u9879\u76EE ${pc24.green(name)} \u521B\u5EFA\u6210\u529F!`);
+  logger2.info(`\u8BF7\u8FD0\u884C ${pc24.cyan(`cd ${name} && pnpm install`)} \u5B89\u88C5\u4F9D\u8D56`);
 }
 var TEMPLATES2;
 var init_scaffold = __esm({
@@ -5990,33 +6308,33 @@ import { execSync } from "child_process";
 import pc25 from "picocolors";
 async function upgrade(targetVersion) {
   const currentVersion = package_default.version;
-  logger.info(`\u5F53\u524D\u7248\u672C: ${pc25.cyan(currentVersion)}`);
+  logger2.info(`\u5F53\u524D\u7248\u672C: ${pc25.cyan(currentVersion)}`);
   if (targetVersion) {
-    logger.info(`\u6B63\u5728\u5347\u7EA7\u5230\u7248\u672C: ${pc25.yellow(targetVersion)}`);
+    logger2.info(`\u6B63\u5728\u5347\u7EA7\u5230\u7248\u672C: ${pc25.yellow(targetVersion)}`);
     try {
       execSync(`pnpm add -g @chatbi-v/cli@${targetVersion}`, {
         stdio: "inherit"
       });
-      logger.success("\u5347\u7EA7\u6210\u529F!");
+      logger2.success("\u5347\u7EA7\u6210\u529F!");
     } catch (error) {
-      logger.error("\u5347\u7EA7\u5931\u8D25", error);
+      logger2.error("\u5347\u7EA7\u5931\u8D25", error);
     }
   } else {
-    logger.info("\u6B63\u5728\u68C0\u67E5\u6700\u65B0\u7248\u672C...");
+    logger2.info("\u6B63\u5728\u68C0\u67E5\u6700\u65B0\u7248\u672C...");
     try {
       const latestVersion = execSync("npm view @chatbi-v/cli version", {
         encoding: "utf-8"
       }).trim();
       if (latestVersion > currentVersion) {
-        logger.info(`\u6700\u65B0\u7248\u672C: ${pc25.green(latestVersion)}`);
-        logger.info(
+        logger2.info(`\u6700\u65B0\u7248\u672C: ${pc25.green(latestVersion)}`);
+        logger2.info(
           `\u8BF7\u8FD0\u884C ${pc25.cyan(`pnpm add -g @chatbi-v/cli@${latestVersion}`)} \u5347\u7EA7`
         );
       } else {
-        logger.success("\u5F53\u524D\u5DF2\u662F\u6700\u65B0\u7248\u672C!");
+        logger2.success("\u5F53\u524D\u5DF2\u662F\u6700\u65B0\u7248\u672C!");
       }
     } catch {
-      logger.warn("\u65E0\u6CD5\u68C0\u67E5\u6700\u65B0\u7248\u672C");
+      logger2.warn("\u65E0\u6CD5\u68C0\u67E5\u6700\u65B0\u7248\u672C");
     }
   }
 }
@@ -6042,16 +6360,22 @@ async function devtoolsTypes(options) {
   const { input = "src/plugin.json", output, type = "full" } = options;
   const inputPath = path35.resolve(process.cwd(), input);
   if (!fs32.existsSync(inputPath)) {
-    logger.error(`\u627E\u4E0D\u5230 plugin.json \u6587\u4EF6: ${inputPath}`);
+    logger2.error(`\u627E\u4E0D\u5230 plugin.json \u6587\u4EF6: ${inputPath}`);
     return;
   }
-  logger.info(`\u8BFB\u53D6\u63D2\u4EF6\u6E05\u5355: ${pc26.cyan(inputPath)}`);
+  logger2.info(`\u8BFB\u53D6\u63D2\u4EF6\u6E05\u5355: ${pc26.cyan(inputPath)}`);
   try {
-    const pluginJson = await fs32.readJson(inputPath);
+    let pluginJson;
+    try {
+      pluginJson = await fs32.readJson(inputPath);
+    } catch {
+      logger2.error(`\u8BFB\u53D6 plugin.json \u5931\u8D25: ${inputPath}`);
+      return;
+    }
     const validation = validateManifest2(pluginJson);
     if (!validation.valid || !validation.data) {
       validation.errors?.forEach((error) => {
-        logger.error(`[${error.path.join(".")}] ${error.message}`);
+        logger2.error(`[${error.path.join(".")}] ${error.message}`);
       });
       return;
     }
@@ -6061,12 +6385,12 @@ async function devtoolsTypes(options) {
       const outputPath = path35.resolve(process.cwd(), output);
       await fs32.ensureDir(path35.dirname(outputPath));
       await fs32.writeFile(outputPath, typeCode, "utf-8");
-      logger.success(`\u7C7B\u578B\u5B9A\u4E49\u5DF2\u751F\u6210: ${pc26.green(outputPath)}`);
+      logger2.success(`\u7C7B\u578B\u5B9A\u4E49\u5DF2\u751F\u6210: ${pc26.green(outputPath)}`);
     } else {
       console.log(typeCode);
     }
   } catch (error) {
-    logger.error("\u751F\u6210\u7C7B\u578B\u5B9A\u4E49\u5931\u8D25", error);
+    logger2.error("\u751F\u6210\u7C7B\u578B\u5B9A\u4E49\u5931\u8D25", error);
   }
 }
 function generateTypeDefinition(manifest, type) {
@@ -6197,17 +6521,17 @@ __export(diagnose_exports, {
 import pc27 from "picocolors";
 async function diagnose(options = {}) {
   const cwd = process.cwd();
-  logger.info("\u6B63\u5728\u6267\u884C\u6C99\u7BB1\u8BCA\u65AD...\n");
+  logger2.info("\u6B63\u5728\u6267\u884C\u6C99\u7BB1\u8BCA\u65AD...\n");
   try {
     const version = await Sandbox.resolveVersion("current");
-    logger.info(`\u5F53\u524D\u5185\u6838\u7248\u672C: ${pc27.cyan(version)}
+    logger2.info(`\u5F53\u524D\u5185\u6838\u7248\u672C: ${pc27.cyan(version)}
 `);
     const diagnostics = new SandboxDiagnostics(version, cwd);
     const result = await diagnostics.runAllDiagnostics();
-    logger.info(SandboxDiagnostics.formatResults(result));
+    logger2.info(SandboxDiagnostics.formatResults(result));
     const fixableIssues = SandboxDiagnostics.getFixableIssues(result);
     if (fixableIssues.length > 0) {
-      logger.info("");
+      logger2.info("");
       const suggestions = fixableIssues.map(
         (issue) => `  ${pc27.red("\u2022")} ${pc27.bold(issue.title)}
     ${pc27.gray(issue.description)}
@@ -6221,23 +6545,23 @@ ${suggestions}`,
       );
     }
     if (options.fix && fixableIssues.length > 0) {
-      logger.info(pc27.bold("\n\u6B63\u5728\u6267\u884C\u81EA\u52A8\u4FEE\u590D...\n"));
+      logger2.info(pc27.bold("\n\u6B63\u5728\u6267\u884C\u81EA\u52A8\u4FEE\u590D...\n"));
       const { sync: sync2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
       for (const issue of fixableIssues) {
         if (issue.fixCommand?.startsWith("chatbi sync")) {
-          logger.info(`${pc27.cyan("\u2192")} \u6267\u884C: ${issue.fixCommand}`);
+          logger2.info(`${pc27.cyan("\u2192")} \u6267\u884C: ${issue.fixCommand}`);
           try {
             await sync2({ force: true });
-            logger.success(`\u4FEE\u590D\u5B8C\u6210: ${issue.title}`);
+            logger2.success(`\u4FEE\u590D\u5B8C\u6210: ${issue.title}`);
           } catch (e) {
-            logger.error(`\u4FEE\u590D\u5931\u8D25: ${e.message}`);
+            logger2.error(`\u4FEE\u590D\u5931\u8D25: ${e.message}`);
           }
         }
       }
     }
     return result;
   } catch (e) {
-    logger.error(`\u8BCA\u65AD\u5931\u8D25: ${e.message}`);
+    logger2.error(`\u8BCA\u65AD\u5931\u8D25: ${e.message}`);
     throw e;
   }
 }
@@ -6263,19 +6587,19 @@ import pc28 from "picocolors";
 async function update(options = {}) {
   const { force = true, clean: clean2 = false, version } = options;
   const cwd = process.cwd();
-  logger.info(pc28.bold("\u6C99\u7BB1\u66F4\u65B0\u5DE5\u5177\n"));
+  logger2.info(pc28.bold("\u6C99\u7BB1\u66F4\u65B0\u5DE5\u5177\n"));
   try {
     const targetVersion = version || await Sandbox.resolveVersion("latest");
-    logger.info(`\u76EE\u6807\u7248\u672C: ${pc28.cyan(targetVersion)}`);
+    logger2.info(`\u76EE\u6807\u7248\u672C: ${pc28.cyan(targetVersion)}`);
     const currentVersion = await Sandbox.resolveVersion("current");
     if (currentVersion !== targetVersion) {
-      logger.info(
+      logger2.info(
         `\u5F53\u524D\u7248\u672C: ${pc28.yellow(currentVersion)} \u2192 ${pc28.cyan(targetVersion)}`
       );
     } else {
-      logger.info(`\u5F53\u524D\u7248\u672C: ${pc28.green(currentVersion)} (\u5DF2\u662F\u6700\u65B0)`);
+      logger2.info(`\u5F53\u524D\u7248\u672C: ${pc28.green(currentVersion)} (\u5DF2\u662F\u6700\u65B0)`);
     }
-    logger.info("");
+    logger2.info("");
     if (clean2) {
       const spinner2 = createSpinner("\u6B63\u5728\u6E05\u7406\u65E7\u7248\u672C...").start();
       try {
@@ -6284,7 +6608,7 @@ async function update(options = {}) {
       } catch (e) {
         spinner2.fail(`\u6E05\u7406\u5931\u8D25: ${e.message}`);
       }
-      logger.info("");
+      logger2.info("");
     }
     const spinner = createSpinner(`\u6B63\u5728\u66F4\u65B0\u6C99\u7BB1\u5230 ${targetVersion}...`).start();
     try {
@@ -6294,22 +6618,22 @@ async function update(options = {}) {
       spinner.fail(`\u6C99\u7BB1\u66F4\u65B0\u5931\u8D25: ${e.message}`);
       throw e;
     }
-    logger.info("");
-    logger.info(pc28.bold("\u9A8C\u8BC1\u5B89\u88C5...\n"));
+    logger2.info("");
+    logger2.info(pc28.bold("\u9A8C\u8BC1\u5B89\u88C5...\n"));
     const diagnostics = new (await Promise.resolve().then(() => (init_SandboxDiagnostics(), SandboxDiagnostics_exports))).SandboxDiagnostics(targetVersion, cwd);
     const result = await diagnostics.runAllDiagnostics();
     if (result.passed) {
-      logger.success("\u5B89\u88C5\u9A8C\u8BC1\u901A\u8FC7");
+      logger2.success("\u5B89\u88C5\u9A8C\u8BC1\u901A\u8FC7");
     } else {
-      logger.warn(
+      logger2.warn(
         `\u5B89\u88C5\u9A8C\u8BC1\u53D1\u73B0\u95EE\u9898 ${result.errorCount} \u4E2A\uFF0C\u5EFA\u8BAE\u8FD0\u884C ${pc28.cyan("chatbi sandbox diagnose")} \u67E5\u770B\u8BE6\u60C5`
       );
     }
-    logger.info("");
-    logger.success(pc28.green("\u2728 \u6C99\u7BB1\u66F4\u65B0\u5B8C\u6210\uFF01"));
+    logger2.info("");
+    logger2.success(pc28.green("\u2728 \u6C99\u7BB1\u66F4\u65B0\u5B8C\u6210\uFF01"));
     return { version: targetVersion, success: true };
   } catch (e) {
-    logger.error(`\u66F4\u65B0\u5931\u8D25: ${e.message}`);
+    logger2.error(`\u66F4\u65B0\u5931\u8D25: ${e.message}`);
     throw e;
   }
 }
@@ -6333,6 +6657,7 @@ var init_ModuleResolver = __esm({
   "src/sandbox/ModuleResolver.ts"() {
     "use strict";
     init_esm_shims();
+    init_utils();
     init_SandboxPath();
     ModuleResolver = class {
       projectRoot;
@@ -6367,15 +6692,14 @@ var init_ModuleResolver = __esm({
           ".chatbi",
           "resolution.json"
         );
-        if (fs33.existsSync(resolutionPath)) {
-          try {
-            const config4 = fs33.readJsonSync(resolutionPath);
-            this.config = {
-              ...this.config,
-              ...config4
-            };
-          } catch {
-          }
+        try {
+          const config4 = fs33.readJsonSync(resolutionPath);
+          this.config = {
+            ...this.config,
+            ...config4
+          };
+        } catch (e) {
+          logger2.debug(`\u52A0\u8F7D resolution.json \u5931\u8D25: ${e.message}`);
         }
       }
       /**
@@ -6387,12 +6711,13 @@ var init_ModuleResolver = __esm({
           const pkgPath = path36.join(this.sandboxNodeModules, name);
           let actualVersion = overrideVersion;
           try {
-            const pkgJsonPath = path36.join(pkgPath, "package.json");
-            if (fs33.existsSync(pkgJsonPath)) {
-              const pkg = await fs33.readJson(pkgJsonPath);
-              actualVersion = pkg.version || overrideVersion;
-            }
-          } catch {
+            const pkgJsonPath2 = path36.join(pkgPath, "package.json");
+            const pkg = await fs33.readJson(pkgJsonPath2);
+            actualVersion = pkg.version || overrideVersion;
+          } catch (e) {
+            logger2.debug(
+              `\u8BFB\u53D6 package.json \u5931\u8D25: ${pkgJsonPath}: ${e.message}`
+            );
           }
           return {
             name,
@@ -6470,12 +6795,9 @@ var init_ModuleResolver = __esm({
        */
       async checkInLocation(name, nodeModulesPath, source) {
         const pkgPath = path36.join(nodeModulesPath, name);
-        const pkgJsonPath = path36.join(pkgPath, "package.json");
-        if (!fs33.existsSync(pkgJsonPath)) {
-          return null;
-        }
+        const pkgJsonPath2 = path36.join(pkgPath, "package.json");
         try {
-          const pkg = await fs33.readJson(pkgJsonPath);
+          const pkg = await fs33.readJson(pkgJsonPath2);
           return {
             name,
             version: pkg.version || "unknown",
@@ -6483,7 +6805,8 @@ var init_ModuleResolver = __esm({
             source,
             isConflicted: false
           };
-        } catch {
+        } catch (e) {
+          logger2.debug(`\u68C0\u67E5\u5305\u4F4D\u7F6E\u5931\u8D25: ${name}: ${e.message}`);
           return null;
         }
       }
@@ -6530,15 +6853,13 @@ var init_ModuleResolver = __esm({
        * 列出 node_modules 中的包
        */
       async listPackages(nodeModulesPath) {
-        if (!fs33.existsSync(nodeModulesPath)) {
-          return [];
-        }
         try {
           const entries = await fs33.readdir(nodeModulesPath, {
             withFileTypes: true
           });
           return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
-        } catch {
+        } catch (e) {
+          logger2.debug(`\u5217\u51FA\u5305\u5931\u8D25: ${nodeModulesPath}: ${e.message}`);
           return [];
         }
       }
@@ -6550,8 +6871,13 @@ var init_ModuleResolver = __esm({
         if (!result.path) {
           return false;
         }
-        const pkgJsonPath = path36.join(result.path, "package.json");
-        return fs33.existsSync(pkgJsonPath);
+        const pkgJsonPath2 = path36.join(result.path, "package.json");
+        try {
+          const stats = fs33.statSync(pkgJsonPath2);
+          return stats.isFile();
+        } catch {
+          return false;
+        }
       }
       /**
        * 格式化解析结果
@@ -6583,12 +6909,12 @@ __export(resolve_exports, {
 import pc30 from "picocolors";
 async function resolve(packageName, options = {}) {
   if (!packageName) {
-    logger.error("\u8BF7\u6307\u5B9A\u8981\u89E3\u6790\u7684\u5305\u540D");
-    logger.info("\u7528\u6CD5: chatbi sandbox resolve <pkg>");
+    logger2.error("\u8BF7\u6307\u5B9A\u8981\u89E3\u6790\u7684\u5305\u540D");
+    logger2.info("\u7528\u6CD5: chatbi sandbox resolve <pkg>");
     return;
   }
   const cwd = process.cwd();
-  logger.info(`\u6B63\u5728\u89E3\u6790\u5305: ${pc30.cyan(packageName)}
+  logger2.info(`\u6B63\u5728\u89E3\u6790\u5305: ${pc30.cyan(packageName)}
 `);
   try {
     const version = await Sandbox.resolveVersion("current");
@@ -6605,54 +6931,54 @@ async function resolve(packageName, options = {}) {
       unknown: pc30.gray
     };
     const colorFn = sourceColors[result.source] || pc30.gray;
-    logger.info(
+    logger2.info(
       "\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"
     );
-    logger.info(
+    logger2.info(
       "\u2551                      Package Resolution                             \u2551"
     );
-    logger.info(
+    logger2.info(
       "\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563"
     );
-    logger.info(`\u2551  \u5305\u540D:     ${pc30.cyan(result.name.padEnd(52))}\u2551`);
-    logger.info(
+    logger2.info(`\u2551  \u5305\u540D:     ${pc30.cyan(result.name.padEnd(52))}\u2551`);
+    logger2.info(
       `\u2551  \u7248\u672C:     ${(result.version ? pc30.green(result.version) : pc30.red("\u672A\u627E\u5230")).padEnd(52)}\u2551`
     );
-    logger.info(`\u2551  \u6765\u6E90:     ${colorFn(result.source.padEnd(52))}\u2551`);
-    logger.info(
+    logger2.info(`\u2551  \u6765\u6E90:     ${colorFn(result.source.padEnd(52))}\u2551`);
+    logger2.info(
       "\u2551                                                                  \u2551"
     );
-    logger.info(`\u2551  \u8DEF\u5F84:`);
+    logger2.info(`\u2551  \u8DEF\u5F84:`);
     const pathLines = wrapText(result.path || "\u672A\u627E\u5230", 56);
     for (const line of pathLines) {
-      logger.info(`\u2551    ${pc30.gray(line.padEnd(56))}\u2551`);
+      logger2.info(`\u2551    ${pc30.gray(line.padEnd(56))}\u2551`);
     }
-    logger.info(
+    logger2.info(
       "\u2560\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2563"
     );
     if (result.isConflicted) {
-      logger.info(`\u2551  ${pc30.yellow("\u26A0\uFE0F \u5B58\u5728\u51B2\u7A81").padEnd(57)}\u2551`);
-      logger.info(
+      logger2.info(`\u2551  ${pc30.yellow("\u26A0\uFE0F \u5B58\u5728\u51B2\u7A81").padEnd(57)}\u2551`);
+      logger2.info(
         "\u2551                                                                  \u2551"
       );
       if (result.conflictDescription) {
         const descLines = wrapText(result.conflictDescription, 56);
         for (const line of descLines) {
-          logger.info(`\u2551  ${line.padEnd(57)}\u2551`);
+          logger2.info(`\u2551  ${line.padEnd(57)}\u2551`);
         }
       }
     } else {
-      logger.info(`\u2551  ${pc30.green("\u2713 \u65E0\u51B2\u7A81").padEnd(57)}\u2551`);
+      logger2.info(`\u2551  ${pc30.green("\u2713 \u65E0\u51B2\u7A81").padEnd(57)}\u2551`);
     }
-    logger.info(
+    logger2.info(
       "\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"
     );
     if (options.conflicts) {
-      logger.info("");
-      logger.info(pc30.bold("\u68C0\u6D4B\u6240\u6709\u5305\u51B2\u7A81...\n"));
+      logger2.info("");
+      logger2.info(pc30.bold("\u68C0\u6D4B\u6240\u6709\u5305\u51B2\u7A81...\n"));
       const conflicts = await resolver.detectConflicts();
       if (conflicts.length === 0) {
-        logger.success("\u672A\u68C0\u6D4B\u5230\u7248\u672C\u51B2\u7A81");
+        logger2.success("\u672A\u68C0\u6D4B\u5230\u7248\u672C\u51B2\u7A81");
       } else {
         printBox(
           conflicts.map(
@@ -6664,7 +6990,7 @@ async function resolve(packageName, options = {}) {
     }
     return result;
   } catch (e) {
-    logger.error(`\u89E3\u6790\u5931\u8D25: ${e.message}`);
+    logger2.error(`\u89E3\u6790\u5931\u8D25: ${e.message}`);
     throw e;
   }
 }
@@ -6714,8 +7040,8 @@ import pc31 from "picocolors";
 var cli = cac("chatbi-cli");
 var showHeader = () => {
   const title = figlet.textSync("ChatBI-V CLI", { font: "Standard" });
-  logger.info(gradient.pastel.multiline(title));
-  logger.info(
+  logger2.info(gradient.pastel.multiline(title));
+  logger2.info(
     boxen2(pc31.cyan(`ChatBI-V \u7EDF\u4E00\u5F00\u53D1\u5DE5\u5177 v${package_default.version}`), {
       padding: 0,
       margin: { top: 1, bottom: 1 },
@@ -6732,13 +7058,13 @@ var wrapAction = (action, commandName) => {
     const options = args[args.length - 1];
     if (options && options.debug) {
       setDebugMode(true);
-      logger.debug("Debug mode enabled");
+      logger2.debug("Debug mode enabled");
     }
     showHeader();
     try {
       await action(...args);
     } catch (e) {
-      logger.error(`${commandName} \u6267\u884C\u5931\u8D25`, e);
+      logger2.error(`${commandName} \u6267\u884C\u5931\u8D25`, e);
       process.exit(1);
     } finally {
       const latestVersion = await updateCheckPromise;
@@ -6802,7 +7128,7 @@ cli.command("update [targetVersion]", "\u66F4\u65B0\u5185\u6838\u7248\u672C").al
   wrapAction(async (targetVersion) => {
     const { sync: sync2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
     await sync2({ version: targetVersion, force: true });
-    logger.success("\u66F4\u65B0\u5B8C\u6210\uFF01");
+    logger2.success("\u66F4\u65B0\u5B8C\u6210\uFF01");
   }, "update")
 );
 cli.command("sync", "\u540C\u6B65\u5185\u6838\u4F9D\u8D56\u4E0E\u89C4\u8303").alias("s").option("-v, --core-version <version>", "\u6307\u5B9A\u5185\u6838\u7248\u672C").option("-f, --force", "\u5F3A\u5236\u91CD\u65B0\u521D\u59CB\u5316\u5185\u6838\u6C99\u7BB1").option("--clean", "\u6E05\u7406\u5E76\u91CD\u7F6E\u6C99\u7BB1").action(
@@ -6810,7 +7136,7 @@ cli.command("sync", "\u540C\u6B65\u5185\u6838\u4F9D\u8D56\u4E0E\u89C4\u8303").al
     const { sync: sync2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
     const { doctor: doctor2 } = await Promise.resolve().then(() => (init_doctor(), doctor_exports));
     await sync2({ ...options, version: options.coreVersion });
-    logger.info("");
+    logger2.info("");
     await doctor2({ fix: false });
   }, "sync")
 );
@@ -6962,14 +7288,14 @@ cli.command("devtools types", "\u4ECE plugin.json \u751F\u6210 TypeScript \u7C7B
   }, "devtools types")
 );
 cli.command("sandbox", "\u6C99\u7BB1\u7BA1\u7406\u547D\u4EE4").action(() => {
-  logger.warn(
+  logger2.warn(
     "\u8BF7\u4F7F\u7528 sandbox \u5B50\u547D\u4EE4: sandbox-diagnose, sandbox-update, sandbox-resolve"
   );
-  logger.info("\u7528\u6CD5: chatbi <\u5B50\u547D\u4EE4>");
-  logger.info("\u5B50\u547D\u4EE4:");
-  logger.info("  sandbox-diagnose  - \u8BCA\u65AD\u6C99\u7BB1\u95EE\u9898");
-  logger.info("  sandbox-update    - \u66F4\u65B0\u6C99\u7BB1");
-  logger.info("  sandbox-resolve   - \u89E3\u6790\u5305\u7248\u672C");
+  logger2.info("\u7528\u6CD5: chatbi <\u5B50\u547D\u4EE4>");
+  logger2.info("\u5B50\u547D\u4EE4:");
+  logger2.info("  sandbox-diagnose  - \u8BCA\u65AD\u6C99\u7BB1\u95EE\u9898");
+  logger2.info("  sandbox-update    - \u66F4\u65B0\u6C99\u7BB1");
+  logger2.info("  sandbox-resolve   - \u89E3\u6790\u5305\u7248\u672C");
 });
 cli.command("sandbox-diagnose", "\u8BCA\u65AD\u6C99\u7BB1\u73AF\u5883\u95EE\u9898\u5E76\u63D0\u4F9B\u4FEE\u590D\u5EFA\u8BAE").option("--fix", "\u81EA\u52A8\u4FEE\u590D\u53D1\u73B0\u7684\u95EE\u9898").option("--verbose", "\u663E\u793A\u8BE6\u7EC6\u4FE1\u606F").action(
   wrapAction(async (options) => {