chore: update dependencies and documentation, optimize build toolchain (#6060)

* chore: update packageManager version to pnpm@10.9.0 for compatibility improvements * chore: Update dependent versions and configurations to improve compatibility and stability - Update Node version to 22.1.0 - Updated pnpm version to 10.10.0 - Fixed syntax error in prettier command in lintstagedrc - Update dependent versions in pnpm-lock.yaml to ensure consistency - Update format and content in README documents to improve readability * fix: lint error
2025-08-22 22:16:18 +08:00 · 2025-04-28 23:08:05 +08:00
parent 681c1dc267
commit dd833ca56b
19 changed files with 3229 additions and 1523 deletions
--- a/scripts/clean.mjs
+++ b/scripts/clean.mjs
@@ -1,31 +1,33 @@
 import { promises as fs } from 'node:fs';
-import { join } from 'node:path';
+import { join, normalize } from 'node:path';

 const rootDir = process.cwd();

 /**
 * 递归查找并删除目标目录
 * @param {string} currentDir - 当前遍历的目录路径
+ * @param {string[]} targets - 要删除的目标列表
 */
 async function cleanTargetsRecursively(currentDir, targets) {
  const items = await fs.readdir(currentDir);

  for (const item of items) {
    try {
-      const itemPath = join(currentDir, item);
+      const itemPath = normalize(join(currentDir, item));
+      const stat = await fs.lstat(itemPath);
+
      if (targets.includes(item)) {
        // 匹配到目标目录或文件时直接删除
        await fs.rm(itemPath, { force: true, recursive: true });
        console.log(`Deleted: ${itemPath}`);
-      }
-      const stat = await fs.lstat(itemPath);
-      if (stat.isDirectory()) {
+      } else if (stat.isDirectory()) {
+        // 只对目录进行递归处理
        await cleanTargetsRecursively(itemPath, targets);
      }
-    } catch {
-      // console.error(
-      //   `Error handling item ${item} in ${currentDir}: ${error.message}`,
-      // );
+    } catch (error) {
+      console.error(
+        `Error handling item ${item} in ${currentDir}: ${error.message}`,
+      );
    }
  }
 }
@@ -33,9 +35,9 @@ async function cleanTargetsRecursively(currentDir, targets) {
 (async function startCleanup() {
  // 要删除的目录及文件名称
  const targets = ['node_modules', 'dist', '.turbo', 'dist.zip'];
-
  const deleteLockFile = process.argv.includes('--del-lock');
  const cleanupTargets = [...targets];
+
  if (deleteLockFile) {
    cleanupTargets.push('pnpm-lock.yaml');
  }
@@ -46,8 +48,9 @@ async function cleanTargetsRecursively(currentDir, targets) {

  try {
    await cleanTargetsRecursively(rootDir, cleanupTargets);
-    console.log('Cleanup process completed.');
+    console.log('Cleanup process completed successfully.');
  } catch (error) {
    console.error(`Unexpected error during cleanup: ${error.message}`);
+    process.exit(1);
  }
 })();
--- a/scripts/deploy/Dockerfile
+++ b/scripts/deploy/Dockerfile
@@ -1,4 +1,4 @@
-FROM node:20-slim AS builder
+FROM node:22-slim AS builder

 # --max-old-space-size
 ENV PNPM_HOME="/pnpm"
@@ -13,6 +13,7 @@ WORKDIR /app
 # copy package.json and pnpm-lock.yaml to workspace
 COPY . /app

+# 安装依赖
 RUN --mount=type=cache,id=pnpm,target=/pnpm/store pnpm install --frozen-lockfile
 RUN pnpm run build --filter=\!./docs

@@ -20,12 +21,17 @@ RUN echo "Builder Success 🎉"

 FROM nginx:stable-alpine AS production

-RUN echo "types { application/javascript js mjs; }" > /etc/nginx/conf.d/mjs.conf
+# 配置 nginx
+RUN echo "types { application/javascript js mjs; }" > /etc/nginx/conf.d/mjs.conf \
+    && rm -rf /etc/nginx/conf.d/default.conf
+
+# 复制构建产物
 COPY --from=builder /app/playground/dist /usr/share/nginx/html

+# 复制 nginx 配置
 COPY --from=builder /app/scripts/deploy/nginx.conf /etc/nginx/nginx.conf

 EXPOSE 8080

-# start nginx
+# 启动 nginx
 CMD ["nginx", "-g", "daemon off;"]
--- a/scripts/turbo-run/README.md
+++ b/scripts/turbo-run/README.md
@@ -1,3 +1,59 @@
 # @vben/turbo-run

-turbo-run is a command line tool that allows you to run multiple commands in parallel.
+`turbo-run` 是一个命令行工具，允许你在多个包中并行运行命令。它提供了一个交互式的界面，让你可以选择要运行命令的包。
+
+## 特性
+
+- 🚀 交互式选择要运行的包
+- 📦 支持 monorepo 项目结构
+- 🔍 自动检测可用的命令
+- 🎯 精确过滤目标包
+
+## 安装
+
+```bash
+pnpm add -D @vben/turbo-run
+```
+
+## 使用方法
+
+基本语法：
+
+```bash
+turbo-run [script]
+```
+
+例如，如果你想运行 `dev` 命令：
+
+```bash
+turbo-run dev
+```
+
+工具会自动检测哪些包有 `dev` 命令，并提供一个交互式界面让你选择要运行的包。
+
+## 示例
+
+假设你的项目中有以下包：
+
+- `@vben/app`
+- `@vben/admin`
+- `@vben/website`
+
+当你运行：
+
+```bash
+turbo-run dev
+```
+
+工具会：
+
+1. 检测哪些包有 `dev` 命令
+2. 显示一个交互式选择界面
+3. 让你选择要运行命令的包
+4. 使用 `pnpm --filter` 在选定的包中运行命令
+
+## 注意事项
+
+- 确保你的项目使用 pnpm 作为包管理器
+- 确保目标包在 `package.json` 中定义了相应的脚本命令
+- 该工具需要在 monorepo 项目的根目录下运行
--- a/scripts/turbo-run/src/run.ts
+++ b/scripts/turbo-run/src/run.ts
@@ -25,7 +25,7 @@ export async function run(options: RunOptions) {

  let selectPkg: string | symbol;
  if (selectPkgs.length > 1) {
-    selectPkg = await select<any, string>({
+    selectPkg = await select<string>({
      message: `Select the app you need to run [${command}]:`,
      options: selectPkgs.map((item) => ({
        label: item?.packageJson.name,
--- a/scripts/vsh/README.md
+++ b/scripts/vsh/README.md
@@ -1,3 +1,56 @@
 # @vben/vsh

-shell 脚本工具集合
+一个 Shell 脚本工具集合，用于 Vue Vben Admin 项目的开发和管理。
+
+## 功能特性
+
+- 🚀 基于 Node.js 的现代化 Shell 工具
+- 📦 支持模块化开发和按需加载
+- 🔍 提供依赖检查和分析功能
+- 🔄 支持循环依赖扫描
+- 📝 提供包发布检查功能
+
+## 安装
+
+```bash
+# 使用 pnpm 安装
+pnpm add -D @vben/vsh
+
+# 或者使用 npm
+npm install -D @vben/vsh
+
+# 或者使用 yarn
+yarn add -D @vben/vsh
+```
+
+## 使用方法
+
+### 全局安装
+
+```bash
+# 全局安装
+pnpm add -g @vben/vsh
+
+# 使用 vsh 命令
+vsh [command]
+```
+
+### 本地使用
+
+```bash
+# 在 package.json 中添加脚本
+{
+  "scripts": {
+    "vsh": "vsh"
+  }
+}
+
+# 运行命令
+pnpm vsh [command]
+```
+
+## 命令列表
+
+- `vsh check-deps`: 检查项目依赖
+- `vsh scan-circular`: 扫描循环依赖
+- `vsh publish-check`: 检查包发布配置
--- a/scripts/vsh/src/check-circular/index.ts
+++ b/scripts/vsh/src/check-circular/index.ts
@@ -4,77 +4,167 @@ import { extname } from 'node:path';

 import { getStagedFiles } from '@vben/node-utils';

-import { circularDepsDetect, printCircles } from 'circular-dependency-scanner';
+import { circularDepsDetect } from 'circular-dependency-scanner';

-const IGNORE_DIR = [
-  'dist',
-  '.turbo',
-  'output',
-  '.cache',
-  'scripts',
-  'internal',
-  'packages/effects/request/src/',
-  'packages/@core/ui-kit/menu-ui/src/',
-  'packages/@core/ui-kit/popup-ui/src/',
-].join(',');
+// 默认配置
+const DEFAULT_CONFIG = {
+  allowedExtensions: ['.cjs', '.js', '.jsx', '.mjs', '.ts', '.tsx', '.vue'],
+  ignoreDirs: [
+    'dist',
+    '.turbo',
+    'output',
+    '.cache',
+    'scripts',
+    'internal',
+    'packages/effects/request/src/',
+    'packages/@core/ui-kit/menu-ui/src/',
+    'packages/@core/ui-kit/popup-ui/src/',
+  ],
+  threshold: 0, // 循环依赖的阈值
+} as const;

-const IGNORE = [`**/{${IGNORE_DIR}}/**`];
+// 类型定义
+type CircularDependencyResult = string[];
+
+interface CheckCircularConfig {
+  allowedExtensions?: string[];
+  ignoreDirs?: string[];
+  threshold?: number;
+}

 interface CommandOptions {
+  config?: CheckCircularConfig;
  staged: boolean;
  verbose: boolean;
 }

-async function checkCircular({ staged, verbose }: CommandOptions) {
-  const results = await circularDepsDetect({
-    absolute: staged,
-    cwd: process.cwd(),
-    ignore: IGNORE,
+// 缓存机制
+const cache = new Map<string, CircularDependencyResult[]>();
+
+/**
+ * 格式化循环依赖的输出
+ * @param circles - 循环依赖结果
+ */
+function formatCircles(circles: CircularDependencyResult[]): void {
+  if (circles.length === 0) {
+    console.log('✅ No circular dependencies found');
+    return;
+  }
+
+  console.log('⚠️ Circular dependencies found:');
+  circles.forEach((circle, index) => {
+    console.log(`\nCircular dependency #${index + 1}:`);
+    circle.forEach((file) => console.log(`  → ${file}`));
  });
+}

-  if (staged) {
-    let files = await getStagedFiles();
+/**
+ * 检查项目中的循环依赖
+ * @param options - 检查选项
+ * @param options.staged - 是否只检查暂存区文件
+ * @param options.verbose - 是否显示详细信息
+ * @param options.config - 自定义配置
+ * @returns Promise<void>
+ */
+async function checkCircular({
+  config = {},
+  staged,
+  verbose,
+}: CommandOptions): Promise<void> {
+  try {
+    // 合并配置
+    const finalConfig = {
+      ...DEFAULT_CONFIG,
+      ...config,
+    };

-    const allowedExtensions = new Set([
-      '.cjs',
-      '.js',
-      '.jsx',
-      '.mjs',
-      '.ts',
-      '.tsx',
-      '.vue',
-    ]);
+    // 生成忽略模式
+    const ignorePattern = `**/{${finalConfig.ignoreDirs.join(',')}}/**`;

-    // 过滤文件列表
-    files = files.filter((file) => allowedExtensions.has(extname(file)));
+    // 检查缓存
+    const cacheKey = `${staged}-${process.cwd()}-${ignorePattern}`;
+    if (cache.has(cacheKey)) {
+      const cachedResults = cache.get(cacheKey);
+      if (cachedResults) {
+        verbose && formatCircles(cachedResults);
+      }
+      return;
+    }

-    const circularFiles: string[][] = [];
+    // 检测循环依赖
+    const results = await circularDepsDetect({
+      absolute: staged,
+      cwd: process.cwd(),
+      ignore: [ignorePattern],
+    });

-    for (const file of files) {
-      for (const result of results) {
-        const resultFiles = result.flat();
-        if (resultFiles.includes(file)) {
-          circularFiles.push(result);
+    if (staged) {
+      let files = await getStagedFiles();
+      const allowedExtensions = new Set(finalConfig.allowedExtensions);
+
+      // 过滤文件列表
+      files = files.filter((file) => allowedExtensions.has(extname(file)));
+
+      const circularFiles: CircularDependencyResult[] = [];
+
+      for (const file of files) {
+        for (const result of results) {
+          const resultFiles = result.flat();
+          if (resultFiles.includes(file)) {
+            circularFiles.push(result);
+          }
        }
      }
+
+      // 更新缓存
+      cache.set(cacheKey, circularFiles);
+      verbose && formatCircles(circularFiles);
+    } else {
+      // 更新缓存
+      cache.set(cacheKey, results);
+      verbose && formatCircles(results);
    }
-    verbose && printCircles(circularFiles);
-  } else {
-    verbose && printCircles(results);
+
+    // 如果发现循环依赖，只输出警告信息
+    if (results.length > 0) {
+      console.log(
+        '\n⚠️ Warning: Circular dependencies found, please check and fix',
+      );
+    }
+  } catch (error) {
+    console.error(
+      '❌ Error checking circular dependencies:',
+      error instanceof Error ? error.message : error,
+    );
  }
 }

-function defineCheckCircularCommand(cac: CAC) {
+/**
+ * 定义检查循环依赖的命令
+ * @param cac - CAC实例
+ */
+function defineCheckCircularCommand(cac: CAC): void {
  cac
    .command('check-circular')
-    .option(
-      '--staged',
-      'Whether it is the staged commit mode, in which mode, if there is a circular dependency, an alarm will be given.',
-    )
-    .usage(`Analysis of project circular dependencies.`)
-    .action(async ({ staged }) => {
-      await checkCircular({ staged, verbose: true });
+    .option('--staged', 'Only check staged files')
+    .option('--verbose', 'Show detailed information')
+    .option('--threshold <number>', 'Threshold for circular dependencies', {
+      default: 0,
+    })
+    .option('--ignore-dirs <dirs>', 'Directories to ignore, comma separated')
+    .usage('Analyze project circular dependencies')
+    .action(async ({ ignoreDirs, staged, threshold, verbose }) => {
+      const config: CheckCircularConfig = {
+        threshold: Number(threshold),
+        ...(ignoreDirs && { ignoreDirs: ignoreDirs.split(',') }),
+      };
+
+      await checkCircular({
+        config,
+        staged,
+        verbose: verbose ?? true,
+      });
    });
 }

-export { defineCheckCircularCommand };
+export { type CheckCircularConfig, defineCheckCircularCommand };
--- a/scripts/vsh/src/check-dep/index.ts
+++ b/scripts/vsh/src/check-dep/index.ts
@@ -4,82 +4,192 @@ import { getPackages } from '@vben/node-utils';

 import depcheck from 'depcheck';

-async function runDepcheck() {
-  const { packages } = await getPackages();
-  await Promise.all(
-    packages.map(async (pkg) => {
-      if (
-        [
-          '@vben/backend-mock',
-          '@vben/commitlint-config',
-          '@vben/eslint-config',
-          '@vben/lint-staged-config',
-          '@vben/node-utils',
-          '@vben/prettier-config',
-          '@vben/stylelint-config',
-          '@vben/tailwind-config',
-          '@vben/tsconfig',
-          '@vben/vite-config',
-          '@vben/vite-config',
-          '@vben/vsh',
-        ].includes(pkg.packageJson.name)
-      ) {
-        return;
-      }
+// 默认配置
+const DEFAULT_CONFIG = {
+  // 需要忽略的依赖匹配
+  ignoreMatches: [
+    'vite',
+    'vitest',
+    'unbuild',
+    '@vben/tsconfig',
+    '@vben/vite-config',
+    '@vben/tailwind-config',
+    '@types/*',
+    '@vben-core/design',
+  ],
+  // 需要忽略的包
+  ignorePackages: [
+    '@vben/backend-mock',
+    '@vben/commitlint-config',
+    '@vben/eslint-config',
+    '@vben/lint-staged-config',
+    '@vben/node-utils',
+    '@vben/prettier-config',
+    '@vben/stylelint-config',
+    '@vben/tailwind-config',
+    '@vben/tsconfig',
+    '@vben/vite-config',
+    '@vben/vsh',
+  ],
+  // 需要忽略的文件模式
+  ignorePatterns: ['dist', 'node_modules', 'public'],
+};

-      const unused = await depcheck(pkg.dir, {
-        ignoreMatches: [
-          'vite',
-          'vitest',
-          'unbuild',
-          '@vben/tsconfig',
-          '@vben/vite-config',
-          '@vben/tailwind-config',
-          '@types/*',
-          '@vben-core/design',
-        ],
-        ignorePatterns: ['dist', 'node_modules', 'public'],
-      });
-
-      // 删除file:前缀的依赖提示，该依赖是本地依赖
-      Reflect.deleteProperty(unused.missing, 'file:');
-      Object.keys(unused.missing).forEach((key) => {
-        unused.missing[key] = (unused.missing[key] || []).filter(
-          (item: string) => !item.startsWith('/'),
-        );
-        if (unused.missing[key].length === 0) {
-          Reflect.deleteProperty(unused.missing, key);
-        }
-      });
-
-      if (
-        Object.keys(unused.missing).length === 0 &&
-        unused.dependencies.length === 0 &&
-        unused.devDependencies.length === 0
-      ) {
-        return;
-      }
-      console.error(
-        '\n',
-        pkg.packageJson.name,
-        '\n missing:',
-        unused.missing,
-        '\n dependencies:',
-        unused.dependencies,
-        '\n devDependencies:',
-        unused.devDependencies,
-      );
-    }),
-  );
+interface DepcheckResult {
+  dependencies: string[];
+  devDependencies: string[];
+  missing: Record<string, string[]>;
 }

-function defineDepcheckCommand(cac: CAC) {
+interface DepcheckConfig {
+  ignoreMatches?: string[];
+  ignorePackages?: string[];
+  ignorePatterns?: string[];
+}
+
+interface PackageInfo {
+  dir: string;
+  packageJson: {
+    name: string;
+  };
+}
+
+/**
+ * 清理依赖检查结果
+ * @param unused - 依赖检查结果
+ */
+function cleanDepcheckResult(unused: DepcheckResult): void {
+  // 删除file:前缀的依赖提示，该依赖是本地依赖
+  Reflect.deleteProperty(unused.missing, 'file:');
+
+  // 清理路径依赖
+  Object.keys(unused.missing).forEach((key) => {
+    unused.missing[key] = (unused.missing[key] || []).filter(
+      (item: string) => !item.startsWith('/'),
+    );
+    if (unused.missing[key].length === 0) {
+      Reflect.deleteProperty(unused.missing, key);
+    }
+  });
+}
+
+/**
+ * 格式化依赖检查结果
+ * @param pkgName - 包名
+ * @param unused - 依赖检查结果
+ */
+function formatDepcheckResult(pkgName: string, unused: DepcheckResult): void {
+  const hasIssues =
+    Object.keys(unused.missing).length > 0 ||
+    unused.dependencies.length > 0 ||
+    unused.devDependencies.length > 0;
+
+  if (!hasIssues) {
+    return;
+  }
+
+  console.log('\n📦 Package:', pkgName);
+
+  if (Object.keys(unused.missing).length > 0) {
+    console.log('❌ Missing dependencies:');
+    Object.entries(unused.missing).forEach(([dep, files]) => {
+      console.log(`  - ${dep}:`);
+      files.forEach((file) => console.log(`    → ${file}`));
+    });
+  }
+
+  if (unused.dependencies.length > 0) {
+    console.log('⚠️ Unused dependencies:');
+    unused.dependencies.forEach((dep) => console.log(`  - ${dep}`));
+  }
+
+  if (unused.devDependencies.length > 0) {
+    console.log('⚠️ Unused devDependencies:');
+    unused.devDependencies.forEach((dep) => console.log(`  - ${dep}`));
+  }
+}
+
+/**
+ * 运行依赖检查
+ * @param config - 配置选项
+ */
+async function runDepcheck(config: DepcheckConfig = {}): Promise<void> {
+  try {
+    const finalConfig = {
+      ...DEFAULT_CONFIG,
+      ...config,
+    };
+
+    const { packages } = await getPackages();
+
+    let hasIssues = false;
+
+    await Promise.all(
+      packages.map(async (pkg: PackageInfo) => {
+        // 跳过需要忽略的包
+        if (finalConfig.ignorePackages.includes(pkg.packageJson.name)) {
+          return;
+        }
+
+        const unused = await depcheck(pkg.dir, {
+          ignoreMatches: finalConfig.ignoreMatches,
+          ignorePatterns: finalConfig.ignorePatterns,
+        });
+
+        cleanDepcheckResult(unused);
+
+        const pkgHasIssues =
+          Object.keys(unused.missing).length > 0 ||
+          unused.dependencies.length > 0 ||
+          unused.devDependencies.length > 0;
+
+        if (pkgHasIssues) {
+          hasIssues = true;
+          formatDepcheckResult(pkg.packageJson.name, unused);
+        }
+      }),
+    );
+
+    if (!hasIssues) {
+      console.log('\n✅ Dependency check completed, no issues found');
+    }
+  } catch (error) {
+    console.error(
+      '❌ Dependency check failed:',
+      error instanceof Error ? error.message : error,
+    );
+  }
+}
+
+/**
+ * 定义依赖检查命令
+ * @param cac - CAC实例
+ */
+function defineDepcheckCommand(cac: CAC): void {
  cac
    .command('check-dep')
-    .usage(`Analysis of project circular dependencies.`)
-    .action(async () => {
-      await runDepcheck();
+    .option(
+      '--ignore-packages <packages>',
+      'Packages to ignore, comma separated',
+    )
+    .option(
+      '--ignore-matches <matches>',
+      'Dependency patterns to ignore, comma separated',
+    )
+    .option(
+      '--ignore-patterns <patterns>',
+      'File patterns to ignore, comma separated',
+    )
+    .usage('Analyze project dependencies')
+    .action(async ({ ignoreMatches, ignorePackages, ignorePatterns }) => {
+      const config: DepcheckConfig = {
+        ...(ignorePackages && { ignorePackages: ignorePackages.split(',') }),
+        ...(ignoreMatches && { ignoreMatches: ignoreMatches.split(',') }),
+        ...(ignorePatterns && { ignorePatterns: ignorePatterns.split(',') }),
+      };
+
+      await runDepcheck(config);
    });
 }

-export { defineDepcheckCommand };
+export { defineDepcheckCommand, type DepcheckConfig };
--- a/scripts/vsh/src/index.ts
+++ b/scripts/vsh/src/index.ts
@@ -2,40 +2,73 @@ import { colors, consola } from '@vben/node-utils';

 import { cac } from 'cac';

+import { version } from '../package.json';
 import { defineCheckCircularCommand } from './check-circular';
 import { defineDepcheckCommand } from './check-dep';
 import { defineCodeWorkspaceCommand } from './code-workspace';
 import { defineLintCommand } from './lint';
 import { definePubLintCommand } from './publint';

-try {
-  const vsh = cac('vsh');
+// 命令描述
+const COMMAND_DESCRIPTIONS = {
+  'check-circular': 'Check for circular dependencies',
+  'check-dep': 'Check for unused dependencies',
+  'code-workspace': 'Manage VS Code workspace settings',
+  lint: 'Run linting on the project',
+  publint: 'Check package.json files for publishing standards',
+} as const;

-  // vsh lint
-  defineLintCommand(vsh);
+/**
+ * Initialize and run the CLI
+ */
+async function main(): Promise<void> {
+  try {
+    const vsh = cac('vsh');

-  // vsh publint
-  definePubLintCommand(vsh);
+    // Register commands
+    defineLintCommand(vsh);
+    definePubLintCommand(vsh);
+    defineCodeWorkspaceCommand(vsh);
+    defineCheckCircularCommand(vsh);
+    defineDepcheckCommand(vsh);

-  // vsh code-workspace
-  defineCodeWorkspaceCommand(vsh);
+    // Handle invalid commands
+    vsh.on('command:*', ([cmd]) => {
+      consola.error(
+        colors.red(`Invalid command: ${cmd}`),
+        '\n',
+        colors.yellow('Available commands:'),
+        '\n',
+        Object.entries(COMMAND_DESCRIPTIONS)
+          .map(([cmd, desc]) => `  ${colors.cyan(cmd)} - ${desc}`)
+          .join('\n'),
+      );
+      process.exit(1);
+    });

-  // vsh check-circular
-  defineCheckCircularCommand(vsh);
+    // Set up CLI
+    vsh.usage('vsh <command> [options]');
+    vsh.help();
+    vsh.version(version);

-  // vsh check-dep
-  defineDepcheckCommand(vsh);
-
-  // Invalid command
-  vsh.on('command:*', () => {
-    consola.error(colors.red('Invalid command!'));
+    // Parse arguments
+    vsh.parse();
+  } catch (error) {
+    consola.error(
+      colors.red('An unexpected error occurred:'),
+      '\n',
+      error instanceof Error ? error.message : error,
+    );
    process.exit(1);
-  });
-
-  vsh.usage('vsh');
-  vsh.help();
-  vsh.parse();
-} catch (error) {
-  consola.error(error);
-  process.exit(1);
+  }
 }
+
+// Run the CLI
+main().catch((error) => {
+  consola.error(
+    colors.red('Failed to start CLI:'),
+    '\n',
+    error instanceof Error ? error.message : error,
+  );
+  process.exit(1);
+});