哈喽大家好，我是你们的老朋友小齐哥哥。最近在HarmonyOS应用开发中，我遇到了一个让人抓狂的问题：在DevEco Studio中点击运行按钮直接安装的hap包，和通过build haps命令构建后使用hdc命令安装的hap包，版本居然不一致！更诡异的是，build haps安装的包竟然不是最新版本，这直接导致测试同学报了一堆"已修复的bug又复现了"的问题。

我一开始以为是代码没提交、分支不对、或者构建配置有问题，但检查了一圈发现都不是。直到我在华为开发者文档中找到了答案：这竟然是hap缓存数据未清理干净导致的！

今天，我将彻底复盘并分享这次"hap包版本一致性"问题的完整解决之旅。这不仅仅是关于清理缓存的简单操作，更是一次对HarmonyOS构建系统、包管理机制和开发工作流的深度探索。你将掌握一套完整的、可复用的构建缓存管理方案，让你应用中的每次构建都准确无误。

一、问题现象：那个"薛定谔"的hap包

我的需求很明确：在新闻阅读应用开发中，需要确保不同构建方式生成的hap包完全一致：

1. 场景A：开发调试时，点击DevEco Studio的运行按钮直接安装

2. 场景B：测试验证时，通过命令行构建后使用hdc安装

3. 场景C：CI/CD流水线中，自动化构建和部署

4. 场景D：所有场景下的hap包版本必须完全一致

我写下了第一版"想当然"的测试代码：

// 首页组件 - 用于验证版本
@Entry
@Component
struct VersionTestApp {
  @State currentVersion: string = '1.0.0';

  build() {
    Column({ space: 20 }) {
      Text('应用版本验证')
        .fontSize(24)
        .fontWeight(FontWeight.Bold)
      
      Text(`当前版本: ${this.currentVersion}`)
        .fontSize(18)
        .fontColor(Color.Blue)
      
      Button('检查更新')
        .width('80%')
        .height(48)
        .onClick(() => {
          this.checkVersion();
        })
    }
    .width('100%')
    .height('100%')
    .alignItems(HorizontalAlign.Center)
    .justifyContent(FlexAlign.Center)
  }

  private checkVersion(): void {
    // 模拟版本检查逻辑
    promptAction.showToast({
      message: `当前运行版本: ${this.currentVersion}`,
      duration: 2000
    });
  }
}

实际测试结果：

• ❌ 场景A失败：点击运行按钮安装，显示版本1.0.1

• ❌ 场景B失败：命令行构建安装，显示版本1.0.0（旧版本）

• ❌ 场景C失败：CI/CD流水线中版本不一致

• ❌ 场景D失败：不同构建方式结果不同

核心痛点：我们以为简单的构建命令就能生成一致的包，但实际上需要处理缓存清理、构建配置、环境变量等多个复杂问题。

二、背景知识：HarmonyOS构建系统深度解析

要彻底解决hap包版本不一致问题，必须理解HarmonyOS中构建系统、缓存机制、包管理之间的关系。

2.1 HarmonyOS构建流程全貌

在HarmonyOS中，应用构建是一个多阶段的过程：

graph TD
    A[源代码] --> B[编译阶段]
    B --> C[资源处理]
    C --> D[打包阶段]
    D --> E[签名阶段]
    E --> F[hap包生成]
    
    B --> G[编译缓存]
    C --> H[资源缓存]
    D --> I[打包缓存]
    
    G --> J[缓存复用]
    H --> J
    I --> J
    
    J --> K[可能导致版本不一致]

2.2 构建缓存机制详解

2.2.1 缓存目录结构

# HarmonyOS项目典型缓存目录
项目根目录/
├── .deveco/              # DevEco Studio缓存
│   ├── cache/           # 编译缓存
│   ├── build/           # 构建缓存
│   └── metadata/        # 元数据缓存
├── build/               # 构建输出目录
│   ├── outputs/        # 输出文件
│   └── cache/          # 构建缓存
├── oh_modules/         # 依赖模块缓存
└── node_modules/       # Node.js依赖缓存

2.2.2 缓存类型分析

缓存类型	位置	影响范围	清理难度
编译缓存​	.deveco/cache	单个项目	容易
构建缓存​	build/cache	单个项目	中等
依赖缓存​	oh_modules	多个项目	困难
全局缓存​	~/.deveco	所有项目	困难

2.3 构建命令差异分析

2.3.1 DevEco Studio运行按钮

# 实际执行的底层命令
deveco build --mode debug --target entry
# 特点：
# 1. 自动清理部分缓存
# 2. 使用内存缓存加速
# 3. 增量构建优化
# 4. 自动处理依赖

2.3.2 命令行构建

# 手动执行的命令
npm run build
# 或
deveco build haps
# 特点：
# 1. 依赖全局配置
# 2. 可能使用旧缓存
# 3. 需要手动清理
# 4. 环境变量影响大

2.3.3 hdc安装命令

# 安装hap包
hdc install build/outputs/default/entry-default-signed.hap
# 特点：
# 1. 直接安装文件
# 2. 不触发构建
# 3. 可能安装旧版本
# 4. 需要手动卸载旧版

关键洞察：版本不一致不是简单的"缓存问题"，而是构建环境差异、缓存策略不同和安装机制区别的三重叠加。

三、解决方案：四层缓存清理完整指南

基于以上分析，针对四个典型场景，我们需要不同的清理策略。

3.1 场景A：开发调试快速清理（基础方案）

这是最基本的场景，需要快速清理缓存，确保点击运行按钮时生成最新版本。

错误做法：

# ❌ 只清理build目录是不够的
rm -rf build/
# 问题：.deveco缓存还在，oh_modules缓存还在

正确方案：多层缓存清理脚本

#!/bin/bash
# cleanup_dev.sh - 开发环境缓存清理脚本

echo "🚀 开始清理HarmonyOS开发缓存..."

# 1. 清理构建输出
echo "📦 清理构建输出目录..."
rm -rf build/

# 2. 清理DevEco Studio缓存
echo "🔧 清理DevEco Studio缓存..."
rm -rf .deveco/cache/
rm -rf .deveco/build/
rm -rf .deveco/metadata/

# 3. 清理Hvigor缓存
echo "⚙️ 清理Hvigor缓存..."
rm -rf .hvigor/
rm -rf .hvigor_cache/

# 4. 清理Node.js相关缓存
echo "📁 清理Node.js缓存..."
rm -rf node_modules/.cache/

# 5. 清理临时文件
echo "🗑️ 清理临时文件..."
find . -name "*.tmp" -delete
find . -name "*.temp" -delete
find . -name "*.log" -delete

# 6. 保留oh_modules（避免重复下载）
echo "⚠️ 保留oh_modules目录（按需清理）"
# 如果需要清理oh_modules，取消下面注释
# rm -rf oh_modules/

echo "✅ 缓存清理完成！"
echo "💡 提示：现在可以点击DevEco Studio运行按钮重新构建"

自动化配置：在DevEco Studio中设置预构建任务

// .vscode/tasks.json
{
  "version": "2.0.0",
  "tasks": [
    {
      "label": "清理缓存并构建",
      "type": "shell",
      "command": "./cleanup_dev.sh && npm run build",
      "group": {
        "kind": "build",
        "isDefault": true
      },
      "problemMatcher": []
    }
  ]
}

实现要点：

1. 分层清理：不同缓存目录需要不同处理策略

2. 保留依赖：oh_modules可以保留避免重复下载

3. 临时文件：清理各种临时文件避免干扰

4. 脚本化：做成脚本方便重复使用

3.2 场景B：命令行构建完整清理

在测试验证场景中，需要通过命令行构建，需要更彻底的清理。

进阶方案：完整环境清理 + 依赖验证

#!/bin/bash
# cleanup_full.sh - 完整环境缓存清理脚本

echo "🚀 开始完整清理HarmonyOS构建环境..."

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
NC='\033[0m' # No Color

# 1. 询问是否清理oh_modules
echo -e "${YELLOW}❓ 是否清理oh_modules依赖缓存？(y/n)${NC}"
read -r clean_oh_modules

if [[ "$clean_oh_modules" =~ ^[Yy]$ ]]; then
    echo "📦 清理oh_modules依赖..."
    rm -rf oh_modules/
    echo -e "${GREEN}✅ oh_modules已清理${NC}"
else
    echo -e "${YELLOW}⚠️ 保留oh_modules${NC}"
fi

# 2. 清理所有构建相关目录
echo "🔨 清理构建目录..."
directories=(
    "build"
    ".deveco"
    ".hvigor"
    ".hvigor_cache"
    "node_modules/.cache"
    "*.log"
    "*.tmp"
    "*.temp"
)

for dir in "${directories[@]}"; do
    if [ -e "$dir" ]; then
        echo "  清理: $dir"
        rm -rf "$dir"
    fi
done

# 3. 检查并清理全局缓存
echo "🌍 检查全局缓存..."
global_cache_dirs=(
    "$HOME/.deveco"
    "$HOME/.hvigor"
    "$HOME/.npm/_cacache"
)

for dir in "${global_cache_dirs[@]}"; do
    if [ -d "$dir" ]; then
        echo -e "${YELLOW}⚠️  发现全局缓存: $dir${NC}"
        echo -e "${YELLOW}   是否清理？(y/n)${NC}"
        read -r clean_global
        if [[ "$clean_global" =~ ^[Yy]$ ]]; then
            rm -rf "$dir"
            echo -e "${GREEN}✅ 已清理${NC}"
        fi
    fi
done

# 4. 验证环境状态
echo "🔍 验证环境状态..."

# 检查Node.js版本
node_version=$(node --version)
echo -e "Node.js版本: ${GREEN}$node_version${NC}"

# 检查DevEco CLI版本
if command -v deveco &> /dev/null; then
    deveco_version=$(deveco --version)
    echo -e "DevEco CLI版本: ${GREEN}$deveco_version${NC}"
else
    echo -e "${RED}❌ DevEco CLI未安装${NC}"
fi

# 检查hdc版本
if command -v hdc &> /dev/null; then
    hdc_version=$(hdc --version)
    echo -e "hdc版本: ${GREEN}$hdc_version${NC}"
else
    echo -e "${RED}❌ hdc未安装${NC}"
fi

# 5. 重新安装依赖（如果清理了oh_modules）
if [[ "$clean_oh_modules" =~ ^[Yy]$ ]]; then
    echo "📥 重新安装依赖..."
    npm install
fi

echo -e "${GREEN}🎉 完整清理完成！${NC}"
echo "💡 现在可以执行: npm run build 或 deveco build haps"

构建验证脚本：

#!/bin/bash
# verify_build.sh - 构建验证脚本

echo "🔍 开始构建验证..."

# 1. 执行构建
echo "🏗️ 执行构建..."
deveco build haps

# 2. 检查构建输出
build_dir="build/outputs/default"
hap_file="$build_dir/entry-default-signed.hap"

if [ -f "$hap_file" ]; then
    echo -e "✅ HAP文件生成成功: $hap_file"
    
    # 获取文件信息
    file_size=$(du -h "$hap_file" | cut -f1)
    file_mtime=$(stat -f "%Sm" "$hap_file")
    
    echo "  文件大小: $file_size"
    echo "  修改时间: $file_mtime"
    
    # 提取版本信息（假设hap包内有版本文件）
    # 实际项目中可能需要更复杂的提取逻辑
    echo "📋 尝试提取版本信息..."
    
    # 临时解压查看内容
    temp_dir=$(mktemp -d)
    unzip -q "$hap_file" -d "$temp_dir"
    
    # 查找manifest文件
    manifest_file=$(find "$temp_dir" -name "config.json" -o -name "manifest.json" | head -1)
    
    if [ -f "$manifest_file" ]; then
        echo "  找到配置文件: $manifest_file"
        # 提取版本号
        version=$(grep -o '"versionName": *"[^"]*"' "$manifest_file" | cut -d'"' -f4)
        echo -e "🎯 应用版本: ${GREEN}$version${NC}"
    fi
    
    # 清理临时目录
    rm -rf "$temp_dir"
else
    echo -e "${RED}❌ HAP文件生成失败${NC}"
    exit 1
fi

# 3. 与DevEco Studio构建对比
echo "🔄 与DevEco Studio构建对比..."
echo "💡 提示：现在请通过DevEco Studio运行按钮构建一次"
echo "然后再次运行此脚本进行对比"

# 可以添加更详细的对比逻辑
echo "📊 对比建议："
echo "   1. 检查文件大小是否一致"
echo "   2. 检查版本号是否一致"
echo "   3. 检查功能是否一致"

echo "✅ 验证脚本执行完成"

批量清理优化技巧：

1. 交互式清理：询问用户是否清理重要目录

2. 全局缓存：检查并清理全局缓存目录

3. 环境验证：构建前后验证环境状态

4. 版本提取：从hap包中提取版本信息验证

3.3 场景C：CI/CD流水线自动化清理

在自动化构建场景中，需要确保每次构建都是全新的，避免缓存污染。

智能方案：Docker化构建环境 + 缓存策略

# .github/workflows/build.yml
name: HarmonyOS CI

on:
  push:
    branches: [ main, develop ]
  pull_request:
    branches: [ main ]

jobs:
  build:
    runs-on: ubuntu-latest
    
    steps:
    - name: 检出代码
      uses: actions/checkout@v3
      with:
        fetch-depth: 0
    
    - name: 设置Node.js环境
      uses: actions/setup-node@v3
      with:
        node-version: '18'
        cache: 'npm'
    
    - name: 安装DevEco CLI
      run: |
        npm install -g @ohos/deveco-cli
        deveco --version
    
    - name: 清理构建环境
      run: |
        echo "🚀 清理构建环境..."
        # 清理所有可能的缓存
        rm -rf build/
        rm -rf .deveco/
        rm -rf .hvigor/
        rm -rf .hvigor_cache/
        rm -rf oh_modules/
        
        # 清理全局缓存
        rm -rf ~/.deveco
        rm -rf ~/.hvigor
        
        echo "✅ 环境清理完成"
    
    - name: 安装依赖
      run: |
        echo "📦 安装项目依赖..."
        npm ci
        
        echo "📦 安装HarmonyOS依赖..."
        deveco install
    
    - name: 执行构建
      run: |
        echo "🏗️ 执行构建..."
        deveco build haps --mode release
        
        # 验证构建输出
        if [ -f "build/outputs/default/entry-default-signed.hap" ]; then
          echo "✅ HAP构建成功"
          ls -la build/outputs/default/
        else
          echo "❌ HAP构建失败"
          exit 1
        fi
    
    - name: 提取版本信息
      id: version
      run: |
        echo "🔍 提取版本信息..."
        # 从config.json提取版本
        version=$(node -e "console.log(require('./entry/src/main/resources/base/profile/config.json').app.versionName)")
        echo "version=$version" >> $GITHUB_OUTPUT
        echo "✅ 版本: $version"
    
    - name: 上传构建产物
      uses: actions/upload-artifact@v3
      with:
        name: harmonyos-app
        path: build/outputs/default/
    
    - name: 创建版本标签
      if: github.event_name == 'push' && github.ref == 'refs/heads/main'
      run: |
        echo "🏷️ 创建版本标签 v${{ steps.version.outputs.version }}"
        git tag -a "v${{ steps.version.outputs.version }}" -m "Release v${{ steps.version.outputs.version }}"
        git push origin "v${{ steps.version.outputs.version }}"

Docker构建环境：

# Dockerfile.harmonyos
FROM node:18-alpine

# 安装基础工具
RUN apk add --no-cache \
    git \
    curl \
    unzip \
    openjdk11

# 安装DevEco CLI
RUN npm install -g @ohos/deveco-cli

# 设置工作目录
WORKDIR /app

# 复制项目文件
COPY package*.json ./
COPY entry/ ./entry/

# 安装依赖
RUN npm ci && deveco install

# 清理缓存脚本
COPY scripts/cleanup.sh /usr/local/bin/cleanup
RUN chmod +x /usr/local/bin/cleanup

# 构建脚本
COPY scripts/build.sh /usr/local/bin/build-app
RUN chmod +x /usr/local/bin/build-app

# 默认命令
CMD ["build-app"]

缓存策略配置：

// build-profile.json5
{
  "buildOption": {
    "externalNativeOptions": {
      "path": "./src/main/cpp/CMakeLists.txt",
      "arguments": "",
      "cppFlags": "",
      "cFlags": ""
    },
    "generateBuildCache": false,  // 禁用构建缓存
    "incremental": false,         // 禁用增量构建
    "cleanBuildCache": true       // 构建前清理缓存
  },
  "targets": [
    {
      "name": "default",
      "applyTo": "product.default"
    }
  ]
}

条件判断逻辑：

1. 环境隔离：使用Docker确保环境一致性

2. 缓存控制：在CI中完全禁用缓存

3. 版本追踪：自动提取和标记版本

4. 产物管理：规范化的产物存储

3.4 场景D：高级缓存管理方案

对于大型项目团队，需要更智能的缓存管理方案。

优雅方案：缓存监控 + 智能清理 + 团队协作

// scripts/cache-manager.ets
import { fileIo, process } from '@kit.ArkTS';

export class CacheManager {
  private cacheDirs: string[] = [
    'build',
    '.deveco',
    '.hvigor',
    '.hvigor_cache',
    'oh_modules/.cache',
    'node_modules/.cache'
  ];

  private cacheStats: Map<string, CacheStat> = new Map();

  // 监控缓存使用情况
  async monitorCache(): Promise<CacheReport> {
    const report: CacheReport = {
      totalSize: 0,
      dirStats: [],
      timestamp: new Date().toISOString()
    };

    for (const dir of this.cacheDirs) {
      const stat = await this.getDirStat(dir);
      if (stat.exists) {
        report.totalSize += stat.size;
        report.dirStats.push(stat);
        this.cacheStats.set(dir, stat);
      }
    }

    return report;
  }

  // 智能清理建议
  getCleanupRecommendation(): CleanupRecommendation {
    const recommendations: CleanupRecommendation = {
      immediate: [],
      suggested: [],
      keep: []
    };

    for (const [dir, stat] of this.cacheStats) {
      if (stat.size > 1024 * 1024 * 100) { // 大于100MB
        recommendations.immediate.push({
          dir,
          size: stat.size,
          reason: '占用空间过大'
        });
      } else if (stat.ageDays > 7) { // 超过7天
        recommendations.suggested.push({
          dir,
          size: stat.size,
          reason: '缓存过期'
        });
      } else {
        recommendations.keep.push({
          dir,
          size: stat.size,
          reason: '近期使用'
        });
      }
    }

    return recommendations;
  }

  // 执行清理
  async executeCleanup(options: CleanupOptions): Promise<CleanupResult> {
    const result: CleanupResult = {
      cleaned: [],
      failed: [],
      totalFreed: 0
    };

    for (const dir of options.dirs) {
      try {
        const beforeStat = this.cacheStats.get(dir);
        if (beforeStat?.exists) {
          await this.deleteDir(dir);
          const freed = beforeStat.size;
          result.totalFreed += freed;
          result.cleaned.push({
            dir,
            freed
          });
        }
      } catch (error) {
        result.failed.push({
          dir,
          error: error.message
        });
      }
    }

    return result;
  }

  private async getDirStat(dir: string): Promise<CacheStat> {
    try {
      const stat = await fileIo.stat(dir);
      return {
        dir,
        exists: true,
        size: stat.size,
        lastModified: stat.mtime,
        ageDays: this.getAgeDays(stat.mtime)
      };
    } catch {
      return {
        dir,
        exists: false,
        size: 0,
        lastModified: 0,
        ageDays: 0
      };
    }
  }

  private getAgeDays(timestamp: number): number {
    const now = Date.now();
    const diffMs = now - timestamp;
    return Math.floor(diffMs / (1000 * 60 * 60 * 24));
  }

  private async deleteDir(dir: string): Promise<void> {
    await process.execute(`rm -rf ${dir}`);
  }
}

interface CacheStat {
  dir: string;
  exists: boolean;
  size: number;
  lastModified: number;
  ageDays: number;
}

interface CacheReport {
  totalSize: number;
  dirStats: CacheStat[];
  timestamp: string;
}

interface CleanupRecommendation {
  immediate: Array<{ dir: string; size: number; reason: string }>;
  suggested: Array<{ dir: string; size: number; reason: string }>;
  keep: Array<{ dir: string; size: number; reason: string }>;
}

interface CleanupOptions {
  dirs: string[];
  dryRun?: boolean;
}

interface CleanupResult {
  cleaned: Array<{ dir: string; freed: number }>;
  failed: Array<{ dir: string; error: string }>;
  totalFreed: number;
}

团队协作配置：

// .deveco/team-config.json
{
  "cacheManagement": {
    "sharedCacheDir": "/team/shared/harmonyos-cache",
    "cleanupSchedule": {
      "daily": ["build", ".deveco/cache"],
      "weekly": [".hvigor_cache", "node_modules/.cache"],
      "monthly": ["oh_modules", ".deveco"]
    },
    "exclusions": [
      "oh_modules/@official-packages",
      ".deveco/settings"
    ]
  },
  "buildConsistency": {
    "requiredTools": {
      "node": ">=18.0.0",
      "deveco": ">=3.1.0",
      "hdc": ">=1.0.0"
    },
    "environmentCheck": {
      "preBuild": "./scripts/check-env.js",
      "postBuild": "./scripts/verify-build.js"
    }
  }
}

高级缓存特性：

1. 智能监控：实时监控缓存使用情况

2. 推荐清理：基于规则推荐清理策略

3. 团队共享：支持团队共享缓存配置

4. 环境验证：构建前后验证环境一致性

四、实战总结与最佳实践

通过以上四个场景的完整实现，我们总结出HarmonyOS中解决hap包版本不一致的最佳实践：

4.1 核心要点回顾

1. 缓存分层管理是关键：不同缓存目录需要不同清理策略

2. 环境一致性是基础：确保所有构建环境工具版本一致

3. 自动化验证是保障：构建后自动验证版本和功能

4. 团队协作要规范：统一团队的缓存管理策略

4.2 性能优化建议

1. 缓存保留策略：oh_modules可以保留，其他缓存定期清理

2. 构建环境优化：使用Docker确保环境一致性

3. 监控告警：设置缓存大小监控和告警

4. 文档化：团队共享缓存管理文档

4.3 常见问题解决

1. 清理不彻底问题：使用完整清理脚本覆盖所有缓存目录

2. 依赖下载慢问题：设置国内镜像源，保留oh_modules

3. 团队不一致问题：统一团队开发环境和构建脚本

4. CI/CD失败问题：在CI中完全禁用缓存，全新构建

4.4 扩展思考

1. 缓存分析工具：开发可视化缓存分析工具

2. 智能清理算法：基于使用频率的智能清理

3. 云构建缓存：使用云服务共享构建缓存

4. 版本溯源系统：构建产物版本溯源和比对

五、完整示例代码

最后，提供一个完整的、可直接使用的缓存管理工具：

// scripts/harmonyos-cache-tool.ets
import { promptAction, fileIo, process } from '@kit.ArkTS';

@Entry
@Component
struct CacheToolApp {
  @State cacheReport: string = '';
  @State isCleaning: boolean = false;

  build() {
    Column({ space: 20 }) {
      Text('HarmonyOS缓存管理工具')
        .fontSize(24)
        .fontWeight(FontWeight.Bold)
        .fontColor('#1A1A1A')

      Button('分析缓存使用情况')
        .width('90%')
        .height(48)
        .backgroundColor('#007DFF')
        .fontColor(Color.White)
        .onClick(() => {
          this.analyzeCache();
        })

      Button('快速清理开发缓存')
        .width('90%')
        .height(48)
        .backgroundColor('#34C759')
        .fontColor(Color.White)
        .onClick(() => {
          this.cleanDevCache();
        })

      Button('完整清理所有缓存')
        .width('90%')
        .height(48)
        .backgroundColor('#FF3B30')
        .fontColor(Color.White)
        .onClick(() => {
          this.cleanAllCache();
        })

      if (this.cacheReport) {
        Scroll() {
          Text(this.cacheReport)
            .fontSize(12)
            .fontColor('#666666')
            .textAlign(TextAlign.Start)
            .padding(10)
        }
        .height(200)
        .width('90%')
        .backgroundColor('#F8F9FA')
        .border({ width: 1, color: '#E0E0E0', radius: 8 })
      }

      if (this.isCleaning) {
        LoadingProgress()
          .color('#007DFF')
          .width(40)
          .height(40)
      }
    }
    .width('100%')
    .height('100%')
    .alignItems(HorizontalAlign.Center)
    .justifyContent(FlexAlign.Start)
    .padding({ top: 40 })
    .backgroundColor('#F5F5F5')
  }

  private async analyzeCache(): Promise<void> {
    try {
      this.cacheReport = '正在分析缓存...';
      
      const result = await process.execute({
        command: 'sh',
        args: ['./scripts/analyze-cache.sh']
      });

      this.cacheReport = result.stdout;
      
      promptAction.showToast({
        message: '缓存分析完成',
        duration: 2000
      });
    } catch (error) {
      this.cacheReport = `分析失败: ${error.message}`;
    }
  }

  private async cleanDevCache(): Promise<void> {
    this.isCleaning = true;
    
    try {
      const result = await process.execute({
        command: 'sh',
        args: ['./scripts/cleanup-dev.sh']
      });

      promptAction.showToast({
        message: '开发缓存清理完成',
        duration: 2000
      });
      
      this.cacheReport = result.stdout;
    } catch (error) {
      promptAction.showToast({
        message: `清理失败: ${error.message}`,
        duration: 3000
      });
    } finally {
      this.isCleaning = false;
    }
  }

  private async cleanAllCache(): Promise<void> {
    promptAction.showDialog({
      title: '确认清理',
      message: '这将清理所有缓存，包括oh_modules依赖，需要重新下载。确定继续吗？',
      buttons: [
        {
          text: '取消',
          color: '#666666'
        },
        {
          text: '确定清理',
          color: '#FF3B30',
          action: async () => {
            this.isCleaning = true;
            
            try {
              const result = await process.execute({
                command: 'sh',
                args: ['./scripts/cleanup-full.sh']
              });

              promptAction.showToast({
                message: '所有缓存清理完成',
                duration: 2000
              });
              
              this.cacheReport = result.stdout;
            } catch (error) {
              promptAction.showToast({
                message: `清理失败: ${error.message}`,
                duration: 3000
              });
            } finally {
              this.isCleaning = false;
            }
          }
        }
      ]
    });
  }
}

使用说明：

1. 将上述脚本保存到项目scripts/目录

2. 给脚本添加执行权限：chmod +x scripts/*.sh

3. 在DevEco Studio中运行CacheToolApp

4. 根据需要选择清理选项

通过这套完整的解决方案，你可以彻底解决HarmonyOS开发中hap包版本不一致的问题，确保开发、测试、生产环境的应用版本完全一致，提升团队协作效率和软件交付质量。