跟随update

修改终端为默认终端
跟上maicss的提交
2026-06-22 22:23:49 +08:00 · 2020-06-24 15:48:32 +08:00 · 2020-06-24 09:07:16 +08:00 · 2020-06-23 19:27:10 +08:00 · 2020-06-23 15:47:35 +08:00 · 2020-06-23 01:09:50 +08:00
2422 changed files with 2951 additions and 448171 deletions
@@ -1,139 +0,0 @@
 ---
 description: Bug 修复流程
 ---
 ## 工作流说明
 此工作流指导如何修复 Bug。
 ## 步骤
 ### 1. 复现 Bug
 - 根据 Issue 描述复现问题
 - 记录详细的复现步骤
 - 收集相关日志和错误信息
 - 确认环境信息
 ### 2. 分析问题
 - 查看相关代码
 - 使用调试器定位问题
 - 检查日志输出
 - 识别根本原因
 ### 3. 创建修复分支
 ```bash
 git checkout -b fix/your-bug-fix
 ```
 ### 4. 编写回归测试
 先编写测试来复现 Bug：
 ```typescript
 // src/__tests__/unit/bugFix.test.ts
 import { describe, it, expect } from "vitest";
 import { buggyFunction } from "@/modules/example";
 describe("buggyFunction", () => {
  it("should not crash with null input", () => {
    expect(() => buggyFunction(null)).not.toThrow();
  });
 });
 ```
 ### 5. 修复代码
 - 最小化修改
 - 保持代码可读性
 - 添加必要的注释
 - 更新相关类型定义
 ### 6. 运行测试
 ```bash
 # 确保新测试通过
 npm run test
 # 运行所有测试
 npm run test:all
 # 代码检查
 npm run lint
 npm run format
 ```
 ### 7. 本地验证
 - 验证 Bug 已修复
 - 测试相关功能
 - 检查是否引入新问题
 - 测试边界情况
 ### 8. 更新文档
 - 更新 CHANGELOG.md（如果需要）
 - 更新相关文档（如需要）
 ### 9. 提交代码
 ```bash
 git add .
 git commit -m "fix(scope): describe the bug fix" -s
 git push origin fix/your-bug-fix
 ```
 ### 10. 创建 Pull Request
 - 引用相关 Issue（`Fixes #123`）
 - 描述修复方法
 - 说明复现步骤
 - 添加测试说明
 ### 11. 代码审查
 - 响应审查意见
 - 进行必要的修改
 - 确保所有 CI 检查通过
 ### 12. 合并
 - 等待审查批准
 - Squash 合并到 main 分支
 - 删除修复分支
 ## 注意事项
 - ⚠️ 修复前先理解问题根源
 - ⚠️ 最小化修改范围
 - ⚠️ 添加回归测试防止复发
 - ⚠️ 考虑向后兼容性
 - ⚠️ 测试所有受影响的功能
 ## 常见 Bug 类型
 ### IPC 通信问题
 - 检查事件名称是否匹配
 - 检查数据格式是否正确
 - 检查异步处理
 ### 状态管理问题
 - 检查响应式依赖
 - 检查状态更新时机
 - 检查内存泄漏
 ### 类型错误
 - 检查类型定义
 - 检查类型断言
 - 检查可选值处理
 ## 相关文档
 - [CONTRIBUTING.md](../../CONTRIBUTING.md) - 贡献指南
 - [TESTING.md](../../TESTING.md) - 测试文档
 - [TROUBLESHOOTING.md](../../TROUBLESHOOTING.md) - 问题排查
@@ -1,47 +0,0 @@
 ---
 description: 为 Spark Store 构建DEB软件包
 ---
 本工作流将指导你如何构建适用于 Linux 的 Spark Store 软件包。
 ### 1. 安装依赖
 确保你已经安装了所有的项目依赖。如果你还没有安装，可以使用 `/run-project` 工作流。
 // turbo
 ```bash
 npm install
 ```
 ### 2. 构建生产版本
 你可以选择构建所有支持的格式，或者仅构建特定的格式（deb 或 rpm）。
 #### 构建所有格式 (deb, rpm, AppImage)
 // turbo
 ```bash
 npm run build
 ```
 #### 仅构建 deb 包
 // turbo
 ```bash
 npm run build:deb
 ```
 ### 3. 查看构建产物
 构建完成后的安装包将存放在项目根目录下的 `release` 目录中。
 ```bash
 ls -l release/$(node -p "require('./package.json').version")
 ```
 ### 4. 常见问题排查
 如果构建失败，请检查以下几点：
 - 确保 Node.js 版本符合要求 (>= 20.x)。
 - 确保系统已安装必要的编译工具。
 - 检查 `electron-builder.yml` 中的配置是否正确。
@@ -1,245 +0,0 @@
 ---
 description: 代码审查流程
 ---
 ## 工作流说明
 此工作流指导如何进行代码审查。
 ## 审查清单
 ### 代码质量
 - [ ] 代码遵循项目规范
 - [ ] TypeScript 类型正确
 - [ ] 没有 `any` 类型（除非必要）
 - [ ] ESLint 和 Prettier 通过
 - [ ] 代码可读性良好
 ### 功能实现
 - [ ] 实现符合需求
 - [ ] 边界情况处理
 - [ ] 错误处理完善
 - [ ] 没有引入新 Bug
 ### 测试
 - [ ] 包含足够的测试
 - [ ] 测试覆盖率合理
 - [ ] 所有测试通过
 - [ ] E2E 测试（如需要）
 ### 文档
 - [ ] 更新了相关文档
 - [ ] 代码注释充分
 - [ ] API 文档（如需要）
 - [ ] CHANGELOG.md（如需要）
 ### 安全性
 - [ ] 没有安全漏洞
 - [ ] 输入验证完善
 - [ ] 权限检查正确
 - [ ] 敏感信息保护
 ### 性能
 - [ ] 没有明显的性能问题
 - [ ] 内存使用合理
 - [ ] 没有不必要的渲染
 - [ ] 资源加载优化
 ## 审查流程
 ### 1. 理解变更
 - 阅读 PR 描述
 - 查看 Issue 链接
 - 理解变更目的
 - 检查变更范围
 ### 2. 代码审查
 **主进程代码:**
 ```bash
 # 检查类型安全
 npx tsc --noEmit
 # 检查代码质量
 npm run lint
 ```
 **渲染进程代码:**
 - 组件结构
 - 状态管理
 - 事件处理
 - 样式实现
 ### 3. 测试验证
 ```bash
 # 运行单元测试
 npm run test
 # 运行 E2E 测试
 npm run test:e2e
 # 检查覆盖率
 npm run test:coverage
 ```
 ### 4. 提供反馈
 **正面反馈:**
 - 好的实现
 - 优秀的代码
 - 有价值的贡献
 **建设性反馈:**
 - 指出问题
 - 提出建议
 - 解释原因
 **反馈格式:**
 ````markdown
 ### 问题
 **位置:** `src/components/AppCard.vue:45`
 **描述:** 这里缺少错误处理，可能导致应用崩溃。
 **建议:**
 ```typescript
 try {
  await installPackage();
 } catch (error) {
  console.error("Install failed:", error);
  showError(error.message);
 }
 ```
 ````
 ````
 ### 5. 批准或要求修改
 **批准条件:**
 - 所有审查项目通过
 - 所有测试通过
 - CI 检查通过
 - 没有阻塞问题
 **要求修改:**
 - 指出必须修复的问题
 - 给出明确的修改建议
 - 等待作者响应
 ## 审查原则
 ### 及时性
 - 尽快响应 PR
 - 设定响应时间预期
 - 优先处理紧急 PR
 ### 建设性
 - 提供具体的反馈
 - 给出改进建议
 - 解释审查理由
 ### 尊重
 - 尊重作者的贡献
 - 使用礼貌的语言
 - 认可好的实现
 ### 一致性
 - 遵循项目规范
 - 保持审查标准一致
 - 参考之前类似 PR
 ## 常见问题
 ### 类型安全问题
 **问题:** 使用了 `any` 类型
 **建议:**
 ```typescript
 // ❌ 避免
 const data: any = response;
 // ✅ 推荐
 interface ResponseData {
  id: string;
  name: string;
 }
 const data: ResponseData = response;
 ````
 ### 代码重复
 **问题:** 代码重复
 **建议:**
 ```typescript
 // 提取公共函数
 function formatSize(size: number): string {
  return size > 1024 ? `${size / 1024} MB` : `${size} KB`;
 }
 ```
 ### 错误处理
 **问题:** 缺少错误处理
 **建议:**
 ```typescript
 async function loadApps() {
  try {
    const response = await axios.get("/api/apps");
    return response.data;
  } catch (error) {
    logger.error({ err: error }, "Failed to load apps");
    throw error;
  }
 }
 ```
 ## 审查后操作
 ### 批准
 - 点击 "Approve review"
 - 添加评论（可选）
 - 等待合并
 ### 要求修改
 - 选择 "Request changes"
 - 提供详细反馈
 - 等待作者更新
 ### 评论
 - 选择 "Comment"
 - 提供建议或问题
 - 不阻止合并
 ## 相关文档
 - [CONTRIBUTING.md](../../CONTRIBUTING.md) - 贡献指南
 - [DEVELOPMENT.md](../../DEVELOPMENT.md) - 开发文档
 - [AGENTS.md](../../AGENTS.md) - AI 编码指南
@@ -1,264 +0,0 @@
 ---
 description: 文档更新流程
 ---
 ## 工作流说明
 此工作流指导如何更新项目文档。
 ## 步骤
 ### 1. 确定需要更新的文档
 根据变更内容确定需要更新的文档：
 - README.md - 主要说明
 - DEVELOPMENT.md - 开发指南
 - CONTRIBUTING.md - 贡献指南
 - TESTING.md - 测试文档
 - DEPLOYMENT.md - 部署文档
 - TROUBLESHOOTING.md - 问题排查
 - FAQ.md - 常见问题
 - AGENTS.md - AI 编码指南
 - CHANGELOG.md - 变更日志
 ### 2. 创建文档分支
 ```bash
 git checkout -b docs/update-documentation
 ```
 ### 3. 更新文档
 #### README.md
 添加新功能说明：
 ```markdown
 ## 新功能
 ### 应用更新
 现在支持一键更新所有可更新的应用。
 ### 下载管理
 改进了下载队列管理，支持暂停和继续。
 ```
 #### DEVELOPMENT.md
 添加开发指南：
 ```markdown
 ## 新功能开发
 ### 添加新功能步骤
 1. 理解需求
 2. 设计方案
 3. 实现功能
 4. 编写测试
 5. 提交 PR
 ```
 #### CONTRIBUTING.md
 更新贡献指南：
 ```markdown
 ### 新功能贡献
 - 遵循现有代码风格
 - 编写充分的测试
 - 更新相关文档
 ```
 #### TESTING.md
 添加测试示例：
 ```typescript
 describe("New Feature", () => {
  it("should work correctly", () => {
    // 测试代码
  });
 });
 ```
 #### CHANGELOG.md
 添加变更记录：
 ```markdown
 ## [4.10.0](https://github.com/elysia-best/apm-app-store/compare/v4.9.9...v4.10.0) (2026-03-10)
 ### Features
 - feat(download): add pause and resume for downloads
 - feat(update): add batch update for apps
 ### Bug Fixes
 - fix(ui): correct dark mode toggle persistence
 ```
 ### 4. 检查文档质量
 - [ ] 语法正确
 - [ ] 格式统一
 - [ ] 链接有效
 - [ ] 内容准确
 - [ ] 示例可运行
 ### 5. 运行文档测试
 ```bash
 # 如果有文档测试
 npm run test:docs
 # 检查链接
 npm run check-links
 ```
 ### 6. 本地预览
 使用 Markdown 预览工具查看效果。
 ### 7. 提交文档
 ```bash
 git add .
 git commit -m "docs: update documentation for new features" -s
 git push origin docs/update-documentation
 ```
 ### 8. 创建 Pull Request
 - 说明更新的内容
 - 提供预览截图（如需要）
 - 引用相关 Issue
 ### 9. 代码审查
 - 响应审查意见
 - 确保文档质量
 - 合并到 main 分支
 ## 文档编写规范
 ### 格式规范
 - 使用 Markdown
 - 保持一致的标题层级
 - 使用代码块展示示例
 - 使用表格对比选项
 ### 语言规范
 - 使用简洁清晰的语言
 - 避免技术术语（或解释）
 - 保持中英文术语一致
 - 使用被动语态
 ### 示例规范
 ```typescript
 // 好的示例
 import { ref } from "vue";
 const count = ref(0);
 function increment() {
  count.value++;
 }
 ```
 ### 链接规范
 ```markdown
 - 内部链接: [文档名](./document.md)
 - 外部链接: [Vue 文档](https://vuejs.org/)
 - 锚点链接: [章节](#section-name)
 ```
 ## 文档模板
 ### 新功能文档
 ````markdown
 ## 功能名称
 ### 描述
 简要描述功能
 ### 使用方法
 ```typescript
 // 示例代码
 ```
 ````
 ### 配置选项
 | 选项   | 类型   | 默认值    | 说明     |
 | ------ | ------ | --------- | -------- |
 | option | string | 'default' | 选项说明 |
 ### 注意事项
 - 注意事项 1
 - 注意事项 2
 ````
 ### API 文档
 ```markdown
 ## API 函数名
 ### 签名
 ```typescript
 function functionName(param1: Type1, param2: Type2): ReturnType
 ````
 ### 参数
 | 参数   | 类型  | 必填 | 说明     |
 | ------ | ----- | ---- | -------- |
 | param1 | Type1 | 是   | 参数说明 |
 | param2 | Type2 | 否   | 参数说明 |
 ### 返回值
 | 类型       | 说明       |
 | ---------- | ---------- |
 | ReturnType | 返回值说明 |
 ### 示例
 ```typescript
 const result = functionName(arg1, arg2);
 ```
 ### 错误
 抛出 `Error` 异常的情况说明。
 ```
 ## 注意事项
 - ⚠️ 保持文档与代码同步
 - ⚠️ 更新示例代码
 - ⚠️ 检查链接有效性
 - ⚠️ 使用统一的格式
 - ⚠️ 提供清晰的说明
 ## 相关文档
 - [CONTRIBUTING.md](../../CONTRIBUTING.md) - 贡献指南
 - [DEVELOPMENT.md](../../DEVELOPMENT.md) - 开发文档
 - [AGENTS.md](../../AGENTS.md) - AI 编码指南
 ```
@@ -1,135 +0,0 @@
 ---
 description: 新功能开发流程
 ---
 ## 工作流说明
 此工作流指导如何开发新功能。
 ## 步骤
 ### 1. 理解需求
 - 阅读 Issue 描述
 - 确认功能范围
 - 识别依赖关系
 - 设计 API 和数据结构
 ### 2. 设计方案
 - 设计 UI/UX（如需要）
 - 设计数据流
 - 确定 IPC 通信（如需要）
 - 编写技术方案文档（可选）
 ### 3. 创建功能分支
 ```bash
 git checkout -b feature/your-feature-name
 ```
 ### 4. 更新类型定义
 在 `src/global/typedefinition.ts` 中添加新的类型定义：
 ```typescript
 export interface NewFeatureData {
  id: string;
  name: string;
  // ...其他字段
 }
 ```
 ### 5. 编写测试
 先编写测试，遵循 TDD 原则：
 ```typescript
 // src/__tests__/unit/newFeature.test.ts
 import { describe, it, expect } from "vitest";
 import { newFunction } from "@/modules/newFeature";
 describe("newFunction", () => {
  it("should work correctly", () => {
    const result = newFunction(input);
    expect(result).toBe(expected);
  });
 });
 ```
 ### 6. 实现功能
 按照以下顺序实现：
 - 后端逻辑（Electron 主进程）
 - 前端逻辑（Vue 组件）
 - IPC 通信（如需要）
 - 样式和布局
 ### 7. 运行测试
 ```bash
 # 单元测试
 npm run test
 # E2E 测试
 npm run test:e2e
 # 代码检查
 npm run lint
 npm run format
 ```
 ### 8. 本地测试
 - 测试所有功能场景
 - 测试边界情况
 - 测试错误处理
 - 检查性能影响
 ### 9. 更新文档
 - 更新 API 文档（如需要）
 - 更新用户文档（如需要）
 - 更新 CHANGELOG.md
 ### 10. 提交代码
 ```bash
 git add .
 git commit -m "feat(scope): add new feature" -s
 git push origin feature/your-feature-name
 ```
 ### 11. 创建 Pull Request
 - 使用 PR 模板
 - 引用相关 Issue
 - 添加测试说明
 - 添加截图/录屏（UI 变更）
 ### 12. 代码审查
 - 响应审查意见
 - 进行必要的修改
 - 确保所有 CI 检查通过
 ### 13. 合并
 - 等待审查批准
 - Squash 合并到 main 分支
 - 删除功能分支
 ## 注意事项
 - ⚠️ 保持 PR 小而聚焦（建议 < 500 行）
 - ⚠️ 确保 TypeScript 严格模式通过
 - ⚠️ 不引入 `any` 类型（必要时使用 `eslint-disable`）
 - ⚠️ 所有新功能必须有测试
 - ⚠️ 遵循代码规范
 ## 相关文档
 - [CONTRIBUTING.md](../../CONTRIBUTING.md) - 贡献指南
 - [DEVELOPMENT.md](../../DEVELOPMENT.md) - 开发文档
 - [TESTING.md](../../TESTING.md) - 测试文档
@@ -1,333 +0,0 @@
 ---
 description: 性能优化流程
 ---
 ## 工作流说明
 此工作流指导如何优化应用性能。
 ## 步骤
 ### 1. 识别性能问题
 使用工具分析性能：
 - Chrome DevTools Performance
 - Vue DevTools
 - Vite Build Analysis
 - 内存分析工具
 ### 2. 分析瓶颈
 确定性能瓶颈：
 - 渲染性能
 - 网络请求
 - 内存使用
 - CPU 使用
 - 磁盘 I/O
 ### 3. 创建优化分支
 ```bash
 git checkout -b perf/optimize-performance
 ```
 ### 4. 添加性能测试
 ```typescript
 // src/__tests__/perf/performance.test.ts
 import { describe, it, expect } from "vitest";
 import { heavyFunction } from "@/modules/example";
 describe("heavyFunction", () => {
  it("should complete within 100ms", () => {
    const start = performance.now();
    heavyFunction();
    const duration = performance.now() - start;
    expect(duration).toBeLessThan(100);
  });
 });
 ```
 ### 5. 实施优化
 #### 渲染性能优化
 ```typescript
 // 使用 computed 缓存计算结果
 const filteredApps = computed(() => {
  return apps.value.filter(app => app.category === selectedCategory);
 });
 // 使用 v-memo 优化列表渲染
 <template>
  <div v-for="app in apps" :key="app.pkgname" v-memo="[app.id]">
    {{ app.name }}
  </div>
 </template>
 // 防抖和节流
 import { debounce } from 'lodash-es';
 const debouncedSearch = debounce((query: string) => {
  searchApps(query);
 }, 300);
 ```
 #### 网络请求优化
 ```typescript
 // 使用缓存
 const appCache = new Map<string, App[]>();
 async function fetchApps(category: string): Promise<App[]> {
  if (appCache.has(category)) {
    return appCache.get(category)!;
  }
  const apps = await axios.get(`/api/apps/${category}`);
  appCache.set(category, apps.data);
  return apps.data;
 }
 // 并发请求
 const [apps1, apps2] = await Promise.all([
  fetchApps("category1"),
  fetchApps("category2"),
 ]);
 ```
 #### 内存优化
 ```typescript
 // 及时清理事件监听
 onMounted(() => {
  window.addEventListener("resize", handleResize);
 });
 onUnmounted(() => {
  window.removeEventListener("resize", handleResize);
 });
 // 避免内存泄漏
 let timer: number;
 function startTimer() {
  clearInterval(timer);
  timer = setInterval(() => {
    // 定时任务
  }, 1000);
 }
 onUnmounted(() => {
  clearInterval(timer);
 });
 ```
 #### 代码分割
 ```typescript
 // 动态导入组件
 const AppDetailModal = defineAsyncComponent(
  () => import("@/components/AppDetailModal.vue"),
 );
 // 路由懒加载
 const routes = [
  {
    path: "/app/:id",
    component: () => import("@/views/AppDetail.vue"),
  },
 ];
 ```
 ### 6. 测试性能
 ```bash
 # 运行性能测试
 npm run test:perf
 # 使用 DevTools 分析
 # 1. 打开 DevTools
 # 2. 切换到 Performance 标签
 # 3. 点击 Record
 # 4. 执行操作
 # 5. 停止录制并分析
 ```
 ### 7. 对比优化效果
 记录优化前后的数据：
 - 渲染时间
 - 内存使用
 - 网络请求数
 - 应用启动时间
 ### 8. 验证功能
 ```bash
 # 确保功能正常
 npm run test
 # 手动测试主要流程
 ```
 ### 9. 代码审查
 检查优化是否：
 - 提升了性能
 - 没有破坏功能
 - 代码可读
 - 易于维护
 ### 10. 更新文档
 - 记录优化内容
 - 更新性能指标
 - 添加优化说明
 ### 11. 提交代码
 ```bash
 git add .
 git commit -m "perf(scope): optimize performance" -s
 git push origin perf/optimize-performance
 ```
 ### 12. 创建 Pull Request
 - 说明优化内容
 - 提供性能对比
 - 展示优化效果
 ## 性能优化清单
 ### 渲染性能
 - [ ] 使用 computed 缓存
 - [ ] 使用 v-memo 优化
 - [ ] 避免不必要的重新渲染
 - [ ] 使用虚拟滚动（大数据集）
 - [ ] 图片懒加载
 ### 网络性能
 - [ ] 减少请求数量
 - [ ] 使用缓存
 - [ ] 压缩资源
 - [ ] 使用 CDN
 - [ ] 并发请求
 ### 内存性能
 - [ ] 清理事件监听
 - [ ] 避免内存泄漏
 - [ ] 释放不再使用的资源
 - [ ] 使用对象池（如需要）
 - [ ] 优化数据结构
 ### 构建性能
 - [ ] 代码分割
 - [ ] Tree shaking
 - [ ] 压缩代码
 - [ ] 优化依赖
 - [ ] 使用缓存
 ## 性能监控
 ### 关键指标
 - **FCP (First Contentful Paint):** < 1.5s
 - **LCP (Largest Contentful Paint):** < 2.5s
 - **TTI (Time to Interactive):** < 3.5s
 - **CLS (Cumulative Layout Shift):** < 0.1
 - **FID (First Input Delay):** < 100ms
 ### 监控工具
 ```typescript
 // 使用 Performance API
 const perfData = performance.getEntriesByType("navigation")[0];
 console.log("Page Load Time:", perfData.loadEventEnd - perfData.fetchStart);
 // 使用 Vue DevTools
 // 监控组件渲染时间
 ```
 ## 常见性能问题
 ### 1. 大列表渲染
 **问题:** 渲染大量数据导致卡顿
 **解决方案:**
 ```vue
 <template>
  <RecycleScroller :items="largeList" :item-size="50" key-field="id">
    <template #default="{ item }">
      <div>{{ item.name }}</div>
    </template>
  </RecycleScroller>
 </template>
 ```
 ### 2. 频繁的 DOM 更新
 **问题:** 频繁更新 DOM 导致性能下降
 **解决方案:**
 ```typescript
 // 使用 requestAnimationFrame
 function animate() {
  updatePosition();
  requestAnimationFrame(animate);
 }
 ```
 ### 3. 内存泄漏
 **问题:** 内存持续增长
 **解决方案:**
 ```typescript
 // 及时清理
 onUnmounted(() => {
  clearInterval(timer);
  removeEventListener("resize", handleResize);
  clearTimeout(timeout);
 });
 ```
 ### 4. 不必要的计算
 **问题:** 重复计算相同结果
 **解决方案:**
 ```typescript
 // 使用 computed
 const expensiveValue = computed(() => {
  return heavyCalculation(data.value);
 });
 ```
 ## 注意事项
 - ⚠️ 不要过早优化
 - ⚠️ 先测量再优化
 - ⚠️ 保持代码可读
 - ⚠️ 避免过度优化
 - ⚠️ 持续监控性能
 ## 相关文档
 - [DEVELOPMENT.md](../../DEVELOPMENT.md) - 开发文档
 - [TESTING.md](../../TESTING.md) - 测试文档
 - [TROUBLESHOOTING.md](../../TROUBLESHOOTING.md) - 问题排查
@@ -1,284 +0,0 @@
 ---
 description: 代码重构流程
 ---
 ## 工作流说明
 此工作流指导如何安全地重构代码。
 ## 步骤
 ### 1. 识别重构需求
 分析代码中的问题：
 - 代码重复
 - 复杂度过高
 - 性能问题
 - 可读性差
 - 难以维护
 ### 2. 制定重构计划
 - 确定重构范围
 - 列出具体改进点
 - 评估影响范围
 - 制定测试策略
 ### 3. 创建重构分支
 ```bash
 git checkout -b refactor/your-refactor
 ```
 ### 4. 编写测试
 如果代码缺少测试，先添加测试：
 ```typescript
 // src/__tests__/unit/refactorTarget.test.ts
 import { describe, it, expect } from "vitest";
 import { functionToRefactor } from "@/modules/example";
 describe("functionToRefactor", () => {
  it("should maintain existing behavior", () => {
    const result = functionToRefactor(input);
    expect(result).toBe(expected);
  });
 });
 ```
 ### 5. 逐步重构
 **原则:**
 - 小步迭代
 - 保持测试通过
 - 不改变外部行为
 **示例:**
 ```typescript
 // 重构前
 function processApp(app: any) {
  if (app) {
    return {
      name: app.name,
      pkgname: app.pkgname,
      version: app.version,
    };
  }
  return null;
 }
 // 重构后 - 添加类型
 interface App {
  name: string;
  pkgname: string;
  version: string;
 }
 function processApp(app: App | null): App | null {
  if (!app) return null;
  return {
    name: app.name,
    pkgname: app.pkgname,
    version: app.version,
  };
 }
 ```
 ### 6. 运行测试
 ```bash
 # 每次重构后运行测试
 npm run test
 # 确保所有测试通过
 npm run test:all
 ```
 ### 7. 性能验证
 如果重构涉及性能：
 ```bash
 # 运行性能测试
 npm run test:perf
 # 对比重构前后性能
 ```
 ### 8. 代码审查
 自我检查：
 - 代码更清晰
 - 性能未下降
 - 测试全部通过
 - 没有引入新问题
 ### 9. 更新文档
 - 更新相关文档
 - 添加注释说明
 - 更新 CHANGELOG.md
 ### 10. 提交代码
 ```bash
 git add .
 git commit -m "refactor(scope): describe the refactoring" -s
 git push origin refactor/your-refactor
 ```
 ### 11. 创建 Pull Request
 - 说明重构原因
 - 展示改进效果
 - 提供性能对比（如需要）
 ### 12. 代码审查
 - 响应审查意见
 - 确保所有测试通过
 - 合并到 main 分支
 ## 重构原则
 ### 不改变外部行为
 - 保持 API 兼容
 - 保持输出一致
 - 保持错误处理
 ### 小步迭代
 - 每次只改一处
 - 频繁运行测试
 - 及时提交代码
 ### 测试驱动
 - 先写测试
 - 重构代码
 - 确保通过
 ### 保持简单
 - 减少复杂度
 - 提高可读性
 - 增强可维护性
 ## 常见重构模式
 ### 提取函数
 ```typescript
 // 重构前
 function processApps(apps: App[]) {
  for (const app of apps) {
    if (app.installed) {
      console.log(app.name + " is installed");
    }
  }
 }
 // 重构后
 function logInstalledApp(app: App) {
  if (app.installed) {
    console.log(`${app.name} is installed`);
  }
 }
 function processApps(apps: App[]) {
  apps.forEach(logInstalledApp);
 }
 ```
 ### 提取类型
 ```typescript
 // 重构前
 function createDownload(data: any) {
  return {
    id: data.id,
    name: data.name,
    pkgname: data.pkgname,
  };
 }
 // 重构后
 interface DownloadData {
  id: number;
  name: string;
  pkgname: string;
 }
 function createDownload(data: DownloadData): DownloadItem {
  return {
    id: data.id,
    name: data.name,
    pkgname: data.pkgname,
    status: "queued",
    progress: 0,
    downloadedSize: 0,
    totalSize: 0,
    speed: 0,
    timeRemaining: 0,
    startTime: Date.now(),
    logs: [],
    source: "APM Store",
    retry: false,
  };
 }
 ```
 ### 简化条件
 ```typescript
 // 重构前
 function getStatus(status: string): string {
  if (status === "queued") {
    return "Queued";
  } else if (status === "downloading") {
    return "Downloading";
  } else if (status === "installing") {
    return "Installing";
  } else if (status === "completed") {
    return "Completed";
  } else if (status === "failed") {
    return "Failed";
  } else {
    return "Unknown";
  }
 }
 // 重构后
 const statusMap: Record<string, string> = {
  queued: "Queued",
  downloading: "Downloading",
  installing: "Installing",
  completed: "Completed",
  failed: "Failed",
 };
 function getStatus(status: string): string {
  return statusMap[status] || "Unknown";
 }
 ```
 ## 注意事项
 - ⚠️ 不要在重构中引入新功能
 - ⚠️ 不要同时重构多处
 - ⚠️ 确保测试覆盖充分
 - ⚠️ 保持提交历史清晰
 - ⚠️ 及时回退有问题的重构
 ## 相关文档
 - [CONTRIBUTING.md](../../CONTRIBUTING.md) - 贡献指南
 - [DEVELOPMENT.md](../../DEVELOPMENT.md) - 开发文档
 - [TESTING.md](../../TESTING.md) - 测试文档
@@ -1,211 +0,0 @@
 ---
 description: 发布流程
 ---
 ## 工作流说明
 此工作流指导如何发布新版本。
 ## 步骤
 ### 1. 更新版本号
 ```bash
 # 更新版本
 npm version patch  # 1.0.0 → 1.0.1
 npm version minor  # 1.0.0 → 1.1.0
 npm version major  # 1.0.0 → 2.0.0
 # 或手动编辑 package.json
 ```
 ### 2. 更新 CHANGELOG.md
 ```bash
 # 生成变更日志
 npm run changelog
 ```
 或手动更新：
 ```markdown
 ## [1.0.1](https://github.com/elysia-best/apm-app-store/compare/v1.0.0...v1.0.1) (2026-03-10)
 ### Bug Fixes
 - fix(ui): correct dark mode toggle persistence (#123)
 ### Features
 - feat(install): add retry mechanism for failed installations (#124)
 ```
 ### 3. 运行完整测试
 ```bash
 # 运行所有测试
 npm run test:all
 # 运行代码检查
 npm run lint
 npm run format
 # 构建项目
 npm run build:vite
 ```
 ### 4. 提交变更
 ```bash
 git add .
 git commit -m "chore(release): bump version to x.x.x" -s
 git push origin main
 ```
 ### 5. 创建 Git 标签
 ```bash
 # 创建标签
 git tag v{version}
 # 推送标签
 git push origin v{version}
 ```
 ### 6. 触发 CI 构建
 推送标签后会自动触发 GitHub Actions 构建。
 ### 7. 验证构建
 在 GitHub Actions 页面查看：
 - 所有测试通过
 - 构建成功
 - 构建产物生成
 ### 8. 检查 Release
 GitHub Actions 会自动创建 Release：
 - 访问 Releases 页面
 - 检查版本信息
 - 确认构建产物
 ### 9. 发布说明
 如果需要，更新 Release 说明：
 - 添加主要变更
 - 添加已知问题
 - 添加升级说明
 ### 10. 通知用户
 - 更新 README
 - 发布公告
 - 通知用户
 ## 发布检查清单
 ### 代码质量
 - [ ] 所有测试通过
 - [ ] 代码检查通过
 - [ ] 没有已知严重 Bug
 - [ ] 性能测试通过
 ### 文档
 - [ ] CHANGELOG.md 更新
 - [ ] README.md 更新（如需要）
 - [ ] API 文档更新（如需要）
 ### 构建
 - [ ] 本地构建成功
 - [ ] CI 构建成功
 - [ ] 构建产物正确
 ### 发布
 - [ ] 版本号正确
 - [ ] 标签已推送
 - [ ] Release 已创建
 - [ ] 构建产物已上传
 ## 版本号规范
 遵循 [Semantic Versioning](https://semver.org/)：
 - **MAJOR:** 不兼容的 API 变更
 - **MINOR:** 向后兼容的功能新增
 - **PATCH:** 向后兼容的 Bug 修复
 ### 示例
 ```
 4.9.9 → 4.9.10 (PATCH: Bug 修复)
 4.9.9 → 4.10.0 (MINOR: 新功能)
 4.9.9 → 5.0.0 (MAJOR: 重大变更)
 ```
 ## 发布后
 ### 更新开发分支
 ```bash
 git checkout develop
 git merge main
 git push origin develop
 ```
 ### 监控反馈
 - 收集用户反馈
 - 监控 Bug 报告
 - 记录性能数据
 ### 准备下一个版本
 - 创建新的 Issue
 - 规划新功能
 - 评估技术债务
 ## 回滚流程
 如果发现严重问题：
 ### 1. 立即停止推广
 - 通知用户暂停升级
 - 更新下载页面
 ### 2. 修复问题
 ```bash
 git checkout main
 git checkout -b fix/critical-issue
 # 修复问题
 git push origin fix/critical-issue
 ```
 ### 3. 紧急发布
 ```bash
 npm version patch
 git tag -a v{x.x.x} -m "Hotfix: description"
 git push origin v{x.x.x}
 ```
 ### 4. 通知用户
 - 发布新版本
 - 说明问题和修复
 - 提供升级说明
 ## 相关文档
 - [DEPLOYMENT.md](../../DEPLOYMENT.md) - 部署文档
 - [CONTRIBUTING.md](../../CONTRIBUTING.md) - 贡献指南
 - [CHANGELOG.md](../../CHANGELOG.md) - 变更日志
@@ -1,47 +0,0 @@
 ---
 description: 运行项目 (自动安装依赖)
 ---
 ## 工作流说明
 此工作流将检查运行环境，自动安装缺失的依赖，并启动开发服务器。
 ## 步骤
 ### 1. 检查 Node.js 环境
 确保已安装 Node.js 和 npm。
 // turbo
 ```bash
 node -v && npm -v
 ```
 ### 2. 检查并安装依赖
 检查 `node_modules` 是否存在。如果不存在，将自动运行 `npm install`。
 // turbo
 ```bash
 if [ ! -d "node_modules" ]; then
  echo "检测到缺少依赖，正在安装..."
  npm install
 else
  echo "依赖已安装，准备启动..."
 fi
 ```
 ### 3. 运行开发服务器
 启动项目开发模式。
 // turbo
 ```bash
 npm run dev
 ```
 ## 注意事项
 - 首次运行可能需要一些时间安装依赖。
 - 如果安装失败，请手动运行 `npm install` 查看详细错误。
 - 确保您的系统中已安装并配置好 Electron 所需的系统依赖。
@@ -1,435 +0,0 @@
 ---
 description: 安全审计流程
 ---
 ## 工作流说明
 此工作流指导如何进行安全审计。
 ## 步骤
 ### 1. 确定审计范围
 确定需要审计的方面：
 - 代码安全
 - 依赖安全
 - 数据安全
 - 网络安全
 - 权限管理
 ### 2. 创建审计分支
 ```bash
 git checkout -b security/security-audit
 ```
 ### 3. 代码安全审计
 #### 检查 SQL 注入
 ```typescript
 // ❌ 不安全
 const query = `SELECT * FROM apps WHERE name = '${appName}'`;
 // ✅ 安全
 const query = "SELECT * FROM apps WHERE name = ?";
 db.query(query, [appName]);
 ```
 #### 检查 XSS 攻击
 ```typescript
 // ❌ 不安全
 element.innerHTML = userInput;
 // ✅ 安全
 element.textContent = userInput;
 // 或使用 DOMPurify
 import DOMPurify from "dompurify";
 element.innerHTML = DOMPurify.sanitize(userInput);
 ```
 #### 检查命令注入
 ```typescript
 // ❌ 不安全
 const cmd = `apm install ${packageName}`;
 exec(cmd);
 // ✅ 安全
 const args = ["apm", "install", packageName];
 spawn("apm", args);
 ```
 #### 检查路径遍历
 ```typescript
 // ❌ 不安全
 const filePath = path.join(basePath, userInput);
 // ✅ 安全
 const safePath = path.normalize(userInput).replace(/^(\.\.(\/|\\|$))+/, "");
 const filePath = path.join(basePath, safePath);
 ```
 ### 4. 依赖安全审计
 ```bash
 # 检查依赖漏洞
 npm audit
 # 自动修复
 npm audit fix
 # 手动修复
 npm audit fix --force
 ```
 #### 检查 package.json
 ```json
 {
  "dependencies": {
    "axios": "^1.13.2",
    "pino": "^10.3.0"
  },
  "devDependencies": {
    "@playwright/test": "^1.40.0"
  }
 }
 ```
 ### 5. 数据安全审计
 #### 检查敏感信息
 ```typescript
 // ❌ 不安全 - 硬编码密钥
 const apiKey = "sk-1234567890";
 // ✅ 安全 - 使用环境变量
 const apiKey = process.env.API_KEY;
 // ❌ 不安全 - 记录敏感信息
 logger.info({ password: user.password }, "User logged in");
 // ✅ 安全 - 不记录敏感信息
 logger.info({ userId: user.id }, "User logged in");
 ```
 #### 检查数据加密
 ```typescript
 // 加密敏感数据
 import crypto from "crypto";
 function encrypt(text: string, key: string): string {
  const iv = crypto.randomBytes(16);
  const cipher = crypto.createCipheriv("aes-256-cbc", key, iv);
  let encrypted = cipher.update(text, "utf8", "hex");
  encrypted += cipher.final("hex");
  return iv.toString("hex") + ":" + encrypted;
 }
 ```
 ### 6. 网络安全审计
 #### 检查 HTTPS
 ```typescript
 // ❌ 不安全 - HTTP
 const baseURL = "http://api.example.com";
 // ✅ 安全 - HTTPS
 const baseURL = "https://api.example.com";
 ```
 #### 检查证书验证
 ```typescript
 // 配置 Axios 验证证书
 const axiosInstance = axios.create({
  httpsAgent: new https.Agent({
    rejectUnauthorized: true,
  }),
 });
 ```
 #### 检查 CORS
 ```typescript
 // 配置 CORS
 app.use(
  cors({
    origin: "https://yourdomain.com",
    credentials: true,
  }),
 );
 ```
 ### 7. 权限管理审计
 #### 检查权限提升
 ```typescript
 // 检查 pkexec 可用性
 const checkSuperUserCommand = async (): Promise<string> => {
  if (process.getuid && process.getuid() !== 0) {
    const { stdout } = await execAsync("which /usr/bin/pkexec");
    return stdout.trim().length > 0 ? "/usr/bin/pkexec" : "";
  }
  return "";
 };
 ```
 #### 检查上下文隔离
 ```typescript
 // electron/preload/index.ts
 // ✅ 安全 - 启用上下文隔离
 contextBridge.exposeInMainWorld("ipcRenderer", {
  send: (...args) => ipcRenderer.send(...args),
  on: (...args) => ipcRenderer.on(...args),
  invoke: (...args) => ipcRenderer.invoke(...args),
 });
 // ❌ 不安全 - 禁用上下文隔离
 contextIsolation: false;
 ```
 ### 8. 运行安全工具
 ```bash
 # 使用 Snyk 扫描
 npx snyk test
 # 使用 npm audit
 npm audit
 # 使用 ESLint 安全规则
 npm run lint
 ```
 ### 9. 修复安全问题
 根据审计结果修复发现的问题：
 ```typescript
 // 修复示例
 function validateInput(input: string): boolean {
  // 验证输入
  const regex = /^[a-zA-Z0-9-_]+$/;
  return regex.test(input);
 }
 function sanitizeInput(input: string): string {
  // 清理输入
  return input.trim().replace(/[<>]/g, "");
 }
 ```
 ### 10. 安全测试
 ```typescript
 // src/__tests__/security/security.test.ts
 import { describe, it, expect } from "vitest";
 import { validateInput, sanitizeInput } from "@/modules/security";
 describe("Security", () => {
  describe("validateInput", () => {
    it("should reject malicious input", () => {
      expect(validateInput('<script>alert("xss")</script>')).toBe(false);
    });
    it("should accept valid input", () => {
      expect(validateInput("valid-app-name")).toBe(true);
    });
  });
  describe("sanitizeInput", () => {
    it("should remove dangerous characters", () => {
      expect(sanitizeInput("<script>app</script>")).toBe("scriptapp/script");
    });
  });
 });
 ```
 ### 11. 更新文档
 - 记录安全问题
 - 说明修复方法
 - 更新安全指南
 ### 12. 提交代码
 ```bash
 git add .
 git commit -m "security: fix security vulnerabilities" -s
 git push origin security/security-audit
 ```
 ### 13. 创建 Pull Request
 - 说明安全问题
 - 展示修复方法
 - 提供安全测试结果
 ## 安全检查清单
 ### 代码安全
 - [ ] 输入验证
 - [ ] 输出编码
 - [ ] 参数化查询
 - [ ] 错误处理
 - [ ] 日志安全
 ### 依赖安全
 - [ ] 定期更新依赖
 - [ ] 使用 `npm audit`
 - [ ] 检查已知漏洞
 - [ ] 使用可信源
 ### 数据安全
 - [ ] 敏感数据加密
 - [ ] 不记录敏感信息
 - [ ] 使用环境变量
 - [ ] 安全存储
 ### 网络安全
 - [ ] 使用 HTTPS
 - [ ] 验证证书
 - [ ] 配置 CORS
 - [ ] 防止 CSRF
 ### 权限管理
 - [ ] 最小权限原则
 - [ ] 上下文隔离
 - [ ] 权限检查
 - [ ] 审计日志
 ## 常见安全问题
 ### 1. XSS 攻击
 **问题:** 用户输入包含恶意脚本
 **解决方案:**
 ```typescript
 import DOMPurify from "dompurify";
 function sanitizeHTML(html: string): string {
  return DOMPurify.sanitize(html);
 }
 ```
 ### 2. SQL 注入
 **问题:** 恶意 SQL 代码注入
 **解决方案:**
 ```typescript
 // 使用参数化查询
 db.query("SELECT * FROM apps WHERE name = ?", [appName]);
 ```
 ### 3. 命令注入
 **问题:** 恶意命令注入
 **解决方案:**
 ```typescript
 // 使用 spawn 而非 exec
 const args = ["apm", "install", packageName];
 spawn("apm", args);
 ```
 ### 4. 路径遍历
 **问题:** 访问未授权文件
 **解决方案:**
 ```typescript
 // 验证路径
 const safePath = path.normalize(userPath).replace(/^(\.\.(\/|\\|$))+/, "");
 ```
 ### 5. 敏感信息泄露
 **问题:** 日志中包含敏感信息
 **解决方案:**
 ```typescript
 // 不记录敏感信息
 logger.info({ userId: user.id }, "User logged in");
 ```
 ## 安全最佳实践
 ### 1. 最小权限原则
 只授予必要的权限，避免过度授权。
 ### 2. 深度防御
 多层安全防护，不依赖单一安全措施。
 ### 3. 输入验证
 验证所有输入，包括用户输入和 API 响应。
 ### 4. 输出编码
 对输出进行编码，防止 XSS 攻击。
 ### 5. 定期审计
 定期进行安全审计，及时发现和修复问题。
 ### 6. 安全更新
 及时更新依赖和系统，修复已知漏洞。
 ## 安全工具
 ### 静态分析
 - ESLint
 - TypeScript
 - SonarQube
 ### 动态分析
 - OWASP ZAP
 - Burp Suite
 - Snyk
 ### 依赖扫描
 - npm audit
 - Snyk
 - Dependabot
 ## 注意事项
 - ⚠️ 不要忽视安全问题
 - ⚠️ 及时修复漏洞
 - ⚠️ 定期更新依赖
 - ⚠️ 保持安全意识
 - ⚠️ 遵循安全最佳实践
 ## 相关文档
 - [CONTRIBUTING.md](../../CONTRIBUTING.md) - 贡献指南
 - [DEVELOPMENT.md](../../DEVELOPMENT.md) - 开发文档
 - [SECURITY.md](../../SECURITY.md) - 安全政策
@@ -1,108 +0,0 @@
 ---
 description: 测试编写流程
 ---
 ## 工作流说明
 此工作流指导如何为新功能或 Bug 修复编写测试。
 ## 步骤
 ### 1. 确定测试范围
 分析需要测试的功能点：
 - 单元测试：测试独立函数/组件
 - 集成测试：测试模块间交互
 - E2E 测试：测试完整用户流程
 ### 2. 编写单元测试（Vitest）
 在 `src/__tests__/unit/` 目录下创建测试文件：
 ```typescript
 import { describe, it, expect } from "vitest";
 import { someFunction } from "@/modules/example";
 describe("someFunction", () => {
  it("should return expected result", () => {
    const result = someFunction(input);
    expect(result).toBe(expected);
  });
 });
 ```
 ### 3. 编写组件测试
 ```typescript
 import { describe, it, expect } from "vitest";
 import { mount } from "@vue/test-utils";
 import AppCard from "@/components/AppCard.vue";
 describe("AppCard", () => {
  it("should render app name", () => {
    const wrapper = mount(AppCard, {
      props: {
        app: {
          name: "Test App",
          pkgname: "test-app",
        },
      },
    });
    expect(wrapper.text()).toContain("Test App");
  });
 });
 ```
 ### 4. 编写 E2E 测试（Playwright）
 在 `e2e/` 目录下创建测试文件：
 ```typescript
 import { test, expect } from "@playwright/test";
 test("install app from store", async ({ page }) => {
  await page.goto("http://localhost:3344");
  await page.click("text=Test App");
  await page.click('button:has-text("安装")');
  await expect(page.locator(".install-progress")).toBeVisible();
 });
 ```
 ### 5. 运行测试
 ```bash
 # 运行单元测试
 npm run test
 # 运行测试并监听
 npm run test:watch
 # 运行 E2E 测试
 npm run test:e2e
 # 生成覆盖率报告
 npm run test:coverage
 ```
 ### 6. 确保测试通过
 - 所有单元测试必须通过
 - E2E 测试覆盖主要用户流程
 - 测试覆盖率不低于 70%
 ### 7. 提交代码
 测试通过后，提交代码并创建 PR。
 ## 注意事项
 - ⚠️ 不要测试第三方库的功能
 - ⚠️ 保持测试独立性和可重复性
 - ⚠️ 使用有意义的测试名称
 - ⚠️ Mock 外部依赖（APM 命令、API 调用）
 ## 相关文档
 - [TESTING.md](../../TESTING.md) - 测试框架和规范
 - [DEVELOPMENT.md](../../DEVELOPMENT.md) - 开发文档
@@ -1,3 +0,0 @@
 VITE_APM_STORE_LOCAL_MODE=true
 VITE_APM_STORE_BASE_URL=/local_amd64-store
 VITE_APM_STORE_STATS_BASE_URL=/local_stats
@@ -1,2 +0,0 @@
 VITE_APM_STORE_BASE_URL=https://erotica.spark-app.store
 VITE_APM_STORE_STATS_BASE_URL=https://feedback.spark-app.store
@@ -1,52 +0,0 @@
 ---
 name: Bug 报告
 about: 创建一个 Bug 报告以帮助我们改进
 title: "[Bug] "
 labels: bug
 assignees: ""
 ---
 ## 描述
 清晰简洁地描述这个 Bug 是什么。
 ## 复现步骤
 1. 打开 '...'
 2. 点击 '....'
 3. 滚动到 '....'
 4. 看到错误
 ## 期望行为
 清晰简洁地描述你期望发生什么。
 ## 实际行为
 清晰简洁地描述实际发生了什么。
 ## 截图
 如果适用，添加截图以帮助解释你的问题。
 ## 环境信息
 **操作系统:** [例如: Ubuntu 22.04]
 **APM 版本:** [例如: 1.0.0]
 **应用商店版本:** [例如: 4.9.9]
 **桌面环境:** [例如: GNOME, KDE]
 ## 日志
 如果相关，粘贴日志到以下区域（使用代码块）：
 ```
 粘贴日志内容
 ```
 ## 额外上下文
 添加任何其他关于问题的上下文信息。
@@ -1,23 +0,0 @@
 ---
 name: 功能请求 / 帮助请求
 about: 为这个项目建议一个新想法
 title: "[Feature] "
 labels: enhancement
 assignees: ""
 ---
 ## 你的功能请求是否与问题有关？
 清晰简洁地描述问题。例如：我在 [...] 时总是感到沮丧
 ## 你想要的解决方案是什么？
 清晰简洁地描述你想要发生什么。
 ## 你考虑过哪些替代方案？
 清晰简洁地描述你考虑过的任何替代解决方案或功能。
 ## 额外上下文
 添加任何其他关于功能请求的上下文或截图。
@@ -1,12 +0,0 @@
 <!-- Thank you for contributing! -->
 ### Description
 <!-- Please insert your description here and provide especially info about the "what" this PR is solving -->
 ### What is the purpose of this pull request? <!-- (put an "X" next to an item) -->
 - [ ] Bug fix
 - [ ] New Feature
 - [ ] Documentation update
 - [ ] Other
@@ -1,15 +0,0 @@
 # To get started with Dependabot version updates, you'll need to specify which
 # package ecosystems to update and where the package manifests are located.
 # Please see the documentation for all configuration options:
 # https://help.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
 version: 2
 updates:
  - package-ecosystem: "npm" # See documentation for possible values
    directory: "/" # Location of package manifests
    schedule:
      interval: "weekly"
  - package-ecosystem: "github-actions"
    directory: "/" # Location of package manifests
    schedule:
      interval: "weekly" 
@@ -1,143 +0,0 @@
 name: Build
 on:
  push:
    branches: [main]
    tags:
      - "*"
    paths-ignore:
      - "**.md"
      - "**.spec.js"
      - ".idea"
      - ".vscode"
      - ".dockerignore"
      - "Dockerfile"
      - ".gitignore"
      - ".github/**"
      - "!.github/workflows/build.yml"
      - "!.github/workflows/test.yml"
  pull_request:
    branches: [main]
    paths-ignore:
      - "**.md"
      - "**.spec.js"
      - ".idea"
      - ".vscode"
      - ".dockerignore"
      - "Dockerfile"
      - ".gitignore"
      - ".github/**"
      - "!.github/workflows/build.yml"
 permissions:
  contents: write
 jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v6
      - name: Setup Node.js
        uses: actions/setup-node@v6
        with:
          node-version: 20
      - name: Install dependencies
        run: npm install
      - name: Run tests
        run: npm run test
      - name: Run lint
        run: npm run lint
  build:
    needs: test
    runs-on: ${{ matrix.os }}
    container: ${{ matrix.docker_image }}
    strategy:
      matrix:
        os: [ubuntu-latest]
        package: [deb, rpm]
        architecture: [x64, arm64]
        include:
          - package: deb
            docker_image: "debian:12"
          - package: rpm
            docker_image: "almalinux:8"
    steps:
      - name: Install Build Dependencies
        if: matrix.package == 'deb'
        run: |
          apt-get update
          apt-get install -y curl git wget devscripts fakeroot equivs lintian python3
          apt-get install -y build-essential
      - name: Install Build Dependencies
        if: matrix.package == 'rpm'
        run: |
          dnf install -y curl git wget rpm-build rpmdevtools rpmlint python3
          dnf group install -y "Development Tools"
      - name: Checkout Code
        uses: actions/checkout@v6
      - name: Setup Node.js
        uses: actions/setup-node@v6
        with:
          node-version: 20
      - name: Install Dependencies
        run: |
          npm install
      - name: Download host-spawn
        shell: bash
        run: |
          if [ "${{ matrix.architecture }}" == "x64" ]; then
            curl -fsSL -o ./extras/host-spawn https://github.com/1player/host-spawn/releases/latest/download/host-spawn-x86_64
          elif [ "${{ matrix.architecture }}" == "arm64" ]; then
            curl -fsSL -o ./extras/host-spawn https://github.com/1player/host-spawn/releases/latest/download/host-spawn-aarch64
          fi
          chmod +x ./extras/host-spawn
      - name: Build Release Files
        shell: bash
        run: |
          if [ "${{ matrix.package }}" == "deb" ]; then
            npm run build:deb -- --${{ matrix.architecture }}
          elif [ "${{ matrix.package }}" == "rpm" ]; then
            npm run build:rpm -- --${{ matrix.architecture }}
          fi
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      - name: Upload Artifact
        uses: actions/upload-artifact@v6
        with:
          name: release_for_${{ matrix.package }}_${{ matrix.architecture }}
          path: release/**/*.${{ matrix.package }}
          retention-days: 5
  release:
    needs: build
    runs-on: ubuntu-latest
    if: startsWith(github.ref, 'refs/tags/')
    steps:
      - name: Download all artifacts
        uses: actions/download-artifact@v7
        with:
          path: artifacts
      - name: Upload to GitHub Release
        uses: softprops/action-gh-release@v2
        with:
          tag_name: ${{ github.ref_name }}
          files: |
            artifacts/**/*.deb
            artifacts/**/*.rpm
          generate_release_notes: true
@@ -1,83 +0,0 @@
 name: Test
 on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main, develop]
 jobs:
  unit-tests:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v6
      - name: Setup Node.js
        uses: actions/setup-node@v6
        with:
          node-version: 20
      - name: Install dependencies
        run: npm install
      - name: Run unit tests
        run: npm run test -- --coverage
      - name: Upload coverage to Codecov
        uses: codecov/codecov-action@v4
        with:
          files: ./coverage/lcov.info
          flags: unittests
          name: codecov-umbrella
  e2e-tests:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v6
      - name: Setup Node.js
        uses: actions/setup-node@v6
        with:
          node-version: 20
      - name: Install dependencies
        run: npm install
      - name: Install Playwright Browsers
        run: npx playwright install --with-deps chromium
      - name: Run E2E tests
        run: xvfb-run npm run test:e2e
      - name: Upload test results
        if: always()
        uses: actions/upload-artifact@v6
        with:
          name: playwright-report
          path: playwright-report/
          retention-days: 30
  lint:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v6
      - name: Setup Node.js
        uses: actions/setup-node@v6
        with:
          node-version: 20
      - name: Install dependencies
        run: npm install
      - name: Run ESLint
        run: npm run lint
      - name: Check formatting
        run: npm run format -- --check
@@ -1,42 +0,0 @@
 # Logs
 logs
 *.log
 npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
 pnpm-debug.log*
 lerna-debug.log*
 node_modules
 dist
 dist-ssr
 dist-electron
 release
 *.local
 # Test coverage
 coverage
 .nyc_output
 # Playwright
 test-results
 playwright-report
 playwright/.cache
 # Editor directories and files
 .vscode/.debug.env
 .idea
 .DS_Store
 *.suo
 *.ntvs*
 *.njsproj
 *.sln
 *.sw?
 # lockfile
 pnpm-lock.yaml
 yarn.lock
 .lock
 test-results.json
 .worktrees/
@@ -1,6 +0,0 @@
 # For electron-builder
 # https://github.com/electron-userland/electron-builder/issues/6289#issuecomment-1042620422
 shamefully-hoist=true
 # For China 🇨🇳 developers
 # electron_mirror=https://npmmirror.com/mirrors/electron/
@@ -1,23 +0,0 @@
 import fs from 'node:fs'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { createRequire } from 'node:module'
 import { spawn } from 'node:child_process'
 const pkg = createRequire(import.meta.url)('../package.json')
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 // write .debug.env
 const envContent = Object.entries(pkg.debug.env).map(([key, val]) => `${key}=${val}`)
 fs.writeFileSync(path.join(__dirname, '.debug.env'), envContent.join('\n'))
 // bootstrap
 spawn(
  // TODO: terminate `npm run dev` when Debug exits.
  process.platform === 'win32' ? 'npm.cmd' : 'npm',
  ['run', 'dev'],
  {
    stdio: 'inherit',
    env: Object.assign(process.env, { VSCODE_DEBUG: 'true' }),
  },
 )
@@ -1,6 +0,0 @@
 {
 	"recommendations": [
 		"Vue.volar",
 		"Vue.vscode-typescript-vue-plugin"
 	]
 }
@@ -1,53 +0,0 @@
 {
  // Use IntelliSense to learn about possible attributes.
  // Hover to view descriptions of existing attributes.
  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
  "version": "0.2.0",
  "compounds": [
    {
      "name": "Debug App",
      "preLaunchTask": "Before Debug",
      "configurations": [
        "Debug Main Process",
        "Debug Renderer Process"
      ],
      "presentation": {
        "hidden": false,
        "group": "",
        "order": 1
      },
      "stopAll": true
    }
  ],
  "configurations": [
    {
      "name": "Debug Main Process",
      "type": "node",
      "request": "launch",
      "runtimeExecutable": "${workspaceRoot}/node_modules/.bin/electron",
      // "windows": {
      //   "runtimeExecutable": "${workspaceRoot}/node_modules/.bin/electron.cmd"
      // },
      "runtimeArgs": [
        "--remote-debugging-port=9229",
        "."
      ],
      "envFile": "${workspaceFolder}/.vscode/.debug.env",
      "console": "integratedTerminal"
    },
    {
      "name": "Debug Renderer Process",
      "port": 9229,
      "request": "attach",
      "type": "chrome",
      "timeout": 60000,
      "skipFiles": [
        "<node_internals>/**",
        "${workspaceRoot}/node_modules/**",
        "${workspaceRoot}/dist-electron/**",
        // Skip files in host(VITE_DEV_SERVER_URL)
        "http://127.0.0.1:3344/**"
      ]
    },
  ]
 }
@@ -1,18 +0,0 @@
 {
  "typescript.tsdk": "node_modules/typescript/lib",
  "typescript.tsc.autoDetect": "off",
  "json.schemas": [
    {
      "fileMatch": [
        "/*electron-builder.json5",
        "/*electron-builder.json"
      ],
      "url": "https://json.schemastore.org/electron-builder"
    }
  ],
  "eslint.validate": [
    "javascript",
    "javascriptreact",
    "vue"
  ]
 }
@@ -1,31 +0,0 @@
 {
  // See https://go.microsoft.com/fwlink/?LinkId=733558 
  // for the documentation about the tasks.json format
  "version": "2.0.0",
  "tasks": [
    {
      "label": "Before Debug",
      "type": "shell",
      "command": "node .vscode/.debug.script.mjs",
      "isBackground": true,
      "problemMatcher": {
        "owner": "typescript",
        "fileLocation": "relative",
        "pattern": {
          // TODO: correct "regexp"
          "regexp": "^([a-zA-Z]\\:\/?([\\w\\-]\/?)+\\.\\w+):(\\d+):(\\d+): (ERROR|WARNING)\\: (.*)$",
          "file": 1,
          "line": 3,
          "column": 4,
          "code": 5,
          "message": 6
        },
        "background": {
          "activeOnStart": true,
          "beginsPattern": "^.*VITE v.*  ready in \\d* ms.*$",
          "endsPattern": "^.*\\[startup\\] Electron App.*$"
        }
      }
    }
  ]
 }
@@ -1,146 +0,0 @@
 ## [1.1.1](https://github.com/elysia-best/apm-app-store/compare/v1.1.0...v1.1.1) (2026-02-17)
 ### Bug Fixes
 * **main:** use app.getVersion() for packaged app ([d45d508](https://github.com/elysia-best/apm-app-store/commit/d45d5082f45d60de69d07998429d6f49c64a7b95))
 # [1.1.0](https://github.com/elysia-best/apm-app-store/compare/v1.1.0-beta.1...v1.1.0) (2026-02-14)
 ### Bug Fixes
 * **app:** floor download progress percentage ([ed92145](https://github.com/elysia-best/apm-app-store/commit/ed92145f9145b9190858e1cf4c2a722efe0e2ff0))
 # [1.1.0-beta.1](https://github.com/elysia-best/apm-app-store/compare/v1.0.4...v1.1.0-beta.1) (2026-02-14)
 ### Bug Fixes
 * 修复应用还没有安装完，按钮就重新变成可安装状态 ([#11](https://github.com/elysia-best/apm-app-store/issues/11)) ([b43c611](https://github.com/elysia-best/apm-app-store/commit/b43c6117ecb1ec12f590667dfad7db13263d9d68))
 ### Features
 * 更新类型系统指南，添加代码检查和格式化要求 ([10808c8](https://github.com/elysia-best/apm-app-store/commit/10808c8f3b2f5535c7dfca6fc8a1e7a45cb5b95c))
 * 更新搜索逻辑 ([d5266c6](https://github.com/elysia-best/apm-app-store/commit/d5266c6af81eb6aa28e2f376c88affbea227a5f7))
 * 添加 ESLint 配置并优化代码风格，移除未使用的功能 ([e11740a](https://github.com/elysia-best/apm-app-store/commit/e11740ad4cff877d93e409bc8adb28f15717e97e))
 * **app:** add cache buster for API requests ([9f50e25](https://github.com/elysia-best/apm-app-store/commit/9f50e25dc09cc0bf1d8e68cefb6843aa9bd8b7e6)), closes [#16](https://github.com/elysia-best/apm-app-store/issues/16)
 * **app:** add download count display ([a3f18bb](https://github.com/elysia-best/apm-app-store/commit/a3f18bb593a8b3b1da9927582eb9f6fb5ef18e24))
 * **docs:** 添加 AI 编码指导文档以概述项目架构和核心概念 ([c3ae477](https://github.com/elysia-best/apm-app-store/commit/c3ae4774976bd0464ca8d500792f4865f0b589e9))
 * **install:** add metalink download support and progress tracking ([74c4eb4](https://github.com/elysia-best/apm-app-store/commit/74c4eb4fbc7dd0d91bbbfac2b91bbb2bf1fa0b68)), closes [#12](https://github.com/elysia-best/apm-app-store/issues/12)
 * support download statistics ([5ac9376](https://github.com/elysia-best/apm-app-store/commit/5ac9376200e54e331d22564424db4c41564d23d3)), closes [#15](https://github.com/elysia-best/apm-app-store/issues/15)
 * **theme:** add system theme support ([7aeb3d5](https://github.com/elysia-best/apm-app-store/commit/7aeb3d5dd4d53ce6a6fed03957ee6f5d9eee0f39)), closes [#13](https://github.com/elysia-best/apm-app-store/issues/13)
 ## [1.0.4](https://github.com/elysia-best/apm-app-store/compare/v1.0.4-beta.1...v1.0.4) (2026-01-31)
 ## [1.0.4-beta.1](https://github.com/elysia-best/apm-app-store/compare/v1.0.4-beta.0...v1.0.4-beta.1) (2026-01-31)
 ### Bug Fixes
 * 修复应用启动命令，移除交互式模式 ([2f7af3c](https://github.com/elysia-best/apm-app-store/commit/2f7af3ca8f704ae0ae9aba572f3f451c7d5a701c))
 ### Features
 * 添加 host-spawn 下载步骤并更新应用启动命令 ([850b8dc](https://github.com/elysia-best/apm-app-store/commit/850b8dcd1ff9789960dca38527cfa03008fa8c89))
 ## [1.0.4-beta.0](https://github.com/elysia-best/apm-app-store/compare/v1.0.3...v1.0.4-beta.0) (2026-01-31)
 ### Features
 * 添加重复任务检查，避免重复下载任务 ([0d1d4e5](https://github.com/elysia-best/apm-app-store/commit/0d1d4e567940366c5754f4dcdb83213f8fe87d7d))
 * 现在仅在有任务时才会到托盘 ([92d1573](https://github.com/elysia-best/apm-app-store/commit/92d1573cf082402b7f44a6beedbc47f58dc91781))
 * enhance install manager to prevent duplicate package installations and improve app launching command ([eeefe52](https://github.com/elysia-best/apm-app-store/commit/eeefe5295b8698b887afad467c8151add6e4e8f5))
 ## [1.0.3](https://github.com/elysia-best/apm-app-store/compare/v1.0.3-beta.1...v1.0.3) (2026-01-31)
 ### Bug Fixes
 * deep link handling at electron startup ([0ed7f64](https://github.com/elysia-best/apm-app-store/commit/0ed7f64a218e0a26b384810b1a0ac8ae314c2501))
 ### Features
 * add app launching functionality and update related components ([6154d75](https://github.com/elysia-best/apm-app-store/commit/6154d75fa6893825e74f7bc421fa91eef0fc4f3f))
 * enhance application type definitions and improve app management logic ([39e40ff](https://github.com/elysia-best/apm-app-store/commit/39e40ff946911c82190c7f0158b5bab9287ac3e4))
 * update application icons and implement tray functionality ([f89b9eb](https://github.com/elysia-best/apm-app-store/commit/f89b9ebfd9ba75fef675d063bf8632143fd125d4))
 * update application name and paths to reflect new branding ([641589f](https://github.com/elysia-best/apm-app-store/commit/641589f8754b638a7f53c729a2930f33884cd51e))
 ## [1.0.3-beta.1](https://github.com/elysia-best/apm-app-store/compare/v1.0.2...v1.0.3-beta.1) (2026-01-31)
 ### Bug Fixes
 * 修复确认卸载界面应用名称显示 ([b4ef653](https://github.com/elysia-best/apm-app-store/commit/b4ef6532997fdfeb950af16edfa718d1c19507f5))
 * 修复卸载请求中的应用名称查找逻辑 ([9799718](https://github.com/elysia-best/apm-app-store/commit/97997182bc2bf7b8d3a34f062deadfd910987b09))
 * **build:** add bash shell to build release files ([354eea3](https://github.com/elysia-best/apm-app-store/commit/354eea36267f0284381521ee401d15256ecf8151))
 ### Features
 * 更新安装按钮状态反馈，添加安装队列提示 ([4ce097b](https://github.com/elysia-best/apm-app-store/commit/4ce097bae032601572112d4647f6374875ca9719))
 * 更新版本号至 1.0.3-beta.0 ([327ee54](https://github.com/elysia-best/apm-app-store/commit/327ee5400e1b967902734d381411a2cf239ddb16))
 * 更新本地应用列表，区分依赖和用户安装的包 ([588eaf9](https://github.com/elysia-best/apm-app-store/commit/588eaf9746482d18716c4f929a3150b560aa5a62))
 * 更新模态框样式，添加最大高度限制 ([61790a8](https://github.com/elysia-best/apm-app-store/commit/61790a85882b6c4ef3ac6b3d60de2f7a7d852025))
 * 添加卸载确认模态框，支持卸载进度显示 ([b9325db](https://github.com/elysia-best/apm-app-store/commit/b9325db8b0d3e426d7f2e443069a4641aab7d581))
 * **preload:** expose architecture detection to renderer process ([5b09dfb](https://github.com/elysia-best/apm-app-store/commit/5b09dfb3d985a0fd6dcd222e33312f957c330cd5))
 ### Performance Improvements
 * 移除模态框背景模糊效果 ([eaa2868](https://github.com/elysia-best/apm-app-store/commit/eaa28686a36dd7c5942e227ba30e4ffae249fa2f))
 ## [1.0.2](https://github.com/elysia-best/apm-app-store/compare/9b17c57c5cb6ef6848fdc83f37d1b4d317e2b9a1...v1.0.2) (2026-01-30)
 ### Bug Fixes
 * 更新构建依赖，添加构建工具支持 ([bc2f791](https://github.com/elysia-best/apm-app-store/commit/bc2f79114c700dc98426379703383873908f8f21))
 * 更新构建依赖，添加python3支持 ([f8f163e](https://github.com/elysia-best/apm-app-store/commit/f8f163e3b87ea0dae7e3af0645ae4620c468479b))
 * 更新构建依赖，移除不必要的包并优化安装命令 ([1c791cd](https://github.com/elysia-best/apm-app-store/commit/1c791cd3c83ebc51db8348c6ebce8b4d4eff42d9))
 * 更新上传工件路径以支持不同包类型 ([9ee8339](https://github.com/elysia-best/apm-app-store/commit/9ee8339577ee93f5c7c47be119a6275379321bfe))
 * 更新应用图标格式为ICNS，优化安装管理器命令执行 ([4b49424](https://github.com/elysia-best/apm-app-store/commit/4b49424105451eceb6653fd2974fad7021a4b2cd))
 * 更新应用ID和版本信息，修复许可证类型 ([a3d50e0](https://github.com/elysia-best/apm-app-store/commit/a3d50e026aa570cd2a49da0acd604f4db682bd72))
 * 更新vite版本至6.4.1 ([51ee401](https://github.com/elysia-best/apm-app-store/commit/51ee4019d969767f313cd8af23ea1f0e310b3f4b))
 * 将依赖项'apm'更改为'amber-package-manager' ([f7eedcd](https://github.com/elysia-best/apm-app-store/commit/f7eedcd4fd3a073dd1b2c5623c9fe12bb43b43a1))
 ### Features
 *  统一安装和卸载脚本以支持PolicyKit权限配置 ([f15fb28](https://github.com/elysia-best/apm-app-store/commit/f15fb28d80c481a40d768c12cb5f28a4daa6a5a6))
 * 更新窗口标题和尺寸，优化按钮样式 ([185b498](https://github.com/elysia-best/apm-app-store/commit/185b4984c60a3b5049d44d8e8dc4ff45384b9000))
 * 更新TODO列表，添加应用更新和显示已安装应用功能 ([402ba1f](https://github.com/elysia-best/apm-app-store/commit/402ba1fb00d81828f6c228fb1012203861629fab))
 * 添加对deb和rpm包的构建支持，更新构建依赖和版本信息 ([640e0bd](https://github.com/elysia-best/apm-app-store/commit/640e0bd69df90e278803a14e30aa50c99123db95))
 * 添加已安装应用和可更新应用的管理功能，支持卸载和升级操作 ([ea0261a](https://github.com/elysia-best/apm-app-store/commit/ea0261a1923fbc692ab0480374f7232759446dc7))
 * 添加deb和rpm包的依赖项配置 ([847bcc7](https://github.com/elysia-best/apm-app-store/commit/847bcc7885708a3a2c83f78a951ac3608fc6356c))
 * 添加electron-builder.yml配置文件并更新构建脚本 ([38a4d45](https://github.com/elysia-best/apm-app-store/commit/38a4d4512f3c634e923192f01bbcbd2cc0687634))
 * 添加PolicyKit权限配置和安装/卸载脚本 ([071aa36](https://github.com/elysia-best/apm-app-store/commit/071aa36fb417478d79db0f0e62aebefe573a699a))
 * **deeplink:** implement custom deep link handling and remove electron-app-universal-protocol-client ([c7b3257](https://github.com/elysia-best/apm-app-store/commit/c7b3257a2cefade75a6bc5a82313b38d9acc5d06))
 * **download:** 支持重试下载功能并更新相关逻辑 ([bdf51a1](https://github.com/elysia-best/apm-app-store/commit/bdf51a1037822d117a84a1b2914d6c3c39387d57))
 * **install:** 实现安装管理器，支持安装、检查已安装状态和初步卸载功能 ([bf93059](https://github.com/elysia-best/apm-app-store/commit/bf93059da177c2403c2c6f5b31b8855220d032b2))
 * **install:** add app uninstall functionality ([ac0dc22](https://github.com/elysia-best/apm-app-store/commit/ac0dc225bcd8e202489a0b733449a3d8071a4a60))
 * **install:** added basis install process ([50fb1a0](https://github.com/elysia-best/apm-app-store/commit/50fb1a00658119191a35e98413c13b39d5e5699e))
 * overhaul application to APM 应用商店 with enhanced download management ([9b17c57](https://github.com/elysia-best/apm-app-store/commit/9b17c57c5cb6ef6848fdc83f37d1b4d317e2b9a1))
@@ -1,247 +0,0 @@
 # 贡献指南
 感谢您对 APM 应用商店项目的关注！我们欢迎任何形式的贡献。
 ## 📋 目录
 - [行为准则](#行为准则)
 - [如何贡献](#如何贡献)
 - [开发流程](#开发流程)
 - [代码规范](#代码规范)
 - [提交信息规范](#提交信息规范)
 - [Pull Request 流程](#pull-request-流程)
 - [问题报告](#问题报告)
 ## 行为准则
 - 尊重所有贡献者
 - 接受建设性批评
 - 专注于对项目最有利的事情
 - 对社区表现出同理心
 ## 如何贡献
 ### 报告 Bug
 1. 使用 [Bug 报告模板](.github/ISSUE_TEMPLATE/bug_report.md)
 2. 搜索现有 Issue，避免重复
 3. 提供清晰的重现步骤
 4. 包含相关日志和截图
 ### 建议新功能
 1. 使用 [功能请求模板](.github/ISSUE_TEMPLATE/help_wanted.md)
 2. 解释使用场景和需求
 3. 考虑是否值得投入开发资源
 4. 愿意帮助实现吗？
 ### 提交代码
 1. Fork 项目并创建分支
 2. 编写代码和测试
 3. 确保所有测试通过
 4. 提交 Pull Request
 ### 改进文档
 - 修正错误或不清晰之处
 - 添加示例和教程
 - 翻译文档
 - 提出文档改进建议
 ## 开发流程
 ### 环境搭建
 ```bash
 # 克隆仓库
 git clone https://github.com/elysia-best/apm-app-store.git
 cd apm-app-store
 # 安装依赖
 npm install
 # 启动开发服务器
 npm run dev
 ```
 ### 创建分支
 ```bash
 # 功能分支
 git checkout -b feature/your-feature-name
 # Bug 修复分支
 git checkout -b fix/your-bug-fix
 ```
 ### 本地开发
 1. 遵循 [代码规范](#代码规范)
 2. 编写 [单元测试](TESTING.md)
 3. 运行 `npm run lint` 和 `npm run format`
 4. 运行 `npm run test` 确保测试通过
 ### 代码审查
 - 保持 PR 小而聚焦
 - 添加清晰的描述
 - 引用相关的 Issue
 - 回应审查意见
 ## 代码规范
 ### TypeScript
 - 使用严格模式 (`strict: true`)
 - 避免使用 `any` 类型（必要时使用 `eslint-disable` 注释）
 - 使用显式类型注解
 - 优先使用 `interface` 而非 `type`
 ### Vue 3
 - 使用 Composition API 和 `<script setup>`
 - 使用 `ref` 和 `computed` 管理状态
 - 遵循 Props 和 Events 模式
 - 组件名使用 PascalCase
 ### 样式（Tailwind CSS）
 - 优先使用 Tailwind 工具类
 - 支持暗色模式（`dark:` 前缀）
 - 响应式设计（`md:`, `lg:` 前缀）
 ### 命名约定
 - **组件:** PascalCase (`AppCard.vue`)
 - **函数:** camelCase (`handleInstall`)
 - **常量:** UPPER_SNAKE_CASE (`SHELL_CALLER_PATH`)
 - **文件:** kebab-case (`install-manager.ts`)
 ## 提交信息规范
 遵循 [Conventional Commits](https://www.conventionalcommits.org/) 规范。
 ### 格式
 ```
 type(scope): subject
 [可选的正文]
 [可选的脚注]
 ```
 ### Type 类型
 - `feat`: 新功能
 - `fix`: Bug 修复
 - `docs`: 文档更新
 - `style`: 代码格式（不影响功能）
 - `refactor`: 重构
 - `perf`: 性能优化
 - `test`: 测试相关
 - `chore`: 构建/工具相关
 ### Scope 范围
 - `app`: 应用核心
 - `install`: 安装/卸载
 - `ui`: UI 组件
 - `ipc`: IPC 通信
 - `api`: API 集成
 - `theme`: 主题
 - `build`: 构建
 - `docs`: 文档
 ### Subject 主题
 - 使用现在时态（"add" 而非 "added"）
 - 首字母小写
 - 不以句号结尾
 ### 示例
 ```bash
 feat(install): add retry mechanism for failed installations
 fix(ui): correct dark mode toggle persistence
 refactor(ipc): simplify install manager event handling
 docs(readme): update build instructions
 test(download): add unit tests for download queue
 ```
 ### 签名（可选）
 添加签名以遵守 DCO（Developer Certificate of Origin）：
 ```bash
 git commit -m "feat(example): add new feature" -s
 ```
 或在 `~/.gitconfig` 中配置：
 ```ini
 [commit]
    gpgsign = true
 ```
 ## Pull Request 流程
 ### PR 前检查
 - [ ] 代码通过 `npm run lint`
 - [ ] 代码通过 `npm run format`
 - [ ] 所有测试通过 (`npm run test`)
 - [ ] 新功能包含测试
 - [ ] 文档已更新（如需要）
 ### PR 描述
 使用 [PR 模板](.github/PULL_REQUEST_TEMPLATE.md)，包括：
 1. **变更类型:** feat / fix / refactor 等
 2. **变更描述:** 清晰说明做了什么
 3. **相关 Issue:** 引用 `#123`
 4. **测试说明:** 如何测试这些变更
 5. **截图/录屏:** UI 变更需要
 6. **检查清单:** 完成上述 PR 前检查
 ### 审查流程
 1. 至少一位维护者审查通过
 2. 解决所有审查意见
 3. 确保所有 CI 检查通过
 4. Squash 并合并到 main 分支
 ### 合并要求
 - CI 检查全部通过
 - 至少一次审查批准
 - 无冲突
 - 分支最新
 ## 问题报告
 ### Bug 报告
 使用 [Bug 报告模板](.github/ISSUE_TEMPLATE/bug_report.md)，包含：
 - 描述
 - 复现步骤
 - 期望行为
 - 实际行为
 - 环境信息
 - 截图/日志
 ### 功能请求
 使用 [功能请求模板](.github/ISSUE_TEMPLATE/help_wanted.md)，包含：
 - 问题描述
 - 期望的解决方案
 - 替代方案
 - 额外上下文
 ---
 **© 2026 APM 应用商店项目**
@@ -1,45 +0,0 @@
 # List of referenced projects
 1. https://github.com/electron-vite/electron-vite-vue MIT License
    MIT License
    Copyright (c) 2023 草鞋没号
    Permission is hereby granted, free of charge, to any person obtaining a copy
    of this software and associated documentation files (the "Software"), to deal
    in the Software without restriction, including without limitation the rights
    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
    copies of the Software, and to permit persons to whom the Software is
    furnished to do so, subject to the following conditions:
    The above copyright notice and this permission notice shall be included in all
    copies or substantial portions of the Software.
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
    SOFTWARE.
 2. https://github.com/elysia-best/apm-app-store MulanPSL-2.0
    Copyright (c) 2026-present The Spark Project Contributors
    apm-store is licensed under Mulan PSL v2.
    You can use this software according to the terms and conditions of the Mulan PSL v2.
    You may obtain a copy of Mulan PSL v2 at:
    http://license.coscl.org.cn/MulanPSL2
    THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
    EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
    MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
    See the Mulan PSL v2 for more details.
@@ -1,156 +0,0 @@
 # 部署文档
 ## 📋 目录
 - [构建配置](#构建配置)
 - [打包流程](#打包流程)
 - [发布流程](#发布流程)
 - [CI/CD 工作流](#cicd-工作流)
 - [版本管理](#版本管理)
 ## 构建配置
 ### electron-builder.yml
 主要配置项：
 - **appId:** `store.spark-app.apm`
 - **productName:** `spark-store`
 - **打包格式:** deb, rpm, AppImage
 - **输出目录:** `release/${version}`
 ### 环境变量
 | 变量                  | 说明                     |
 | --------------------- | ------------------------ |
 | `GITHUB_TOKEN`        | GitHub Token（用于发布） |
 | `VITE_DEV_SERVER_URL` | 开发服务器地址           |
 ## 打包流程
 ### 本地构建
 ```bash
 # 构建所有格式
 npm run build
 # 仅构建 deb
 npm run build:deb
 # 仅构建 rpm
 npm run build:rpm
 # 仅构建前端（不打包）
 npm run build:vite
 ```
 ### 构建产物
 构建完成后，产物位于：
 ```
 release/
 └── {version}/
    ├── spark-store_{version}_linux_amd64.deb
    ├── spark-store_{version}_linux_amd64.rpm
    ├── spark-store_{version}_linux_arm64.deb
    └── spark-store_{version}_linux_arm64.rpm
 ```
 ## 发布流程
 ### 1. 更新版本号
 ```bash
 # 更新 package.json 中的版本
 npm version patch  # 1.0.0 → 1.0.1
 npm version minor  # 1.0.0 → 1.1.0
 npm version major  # 1.0.0 → 2.0.0
 ```
 ### 2. 更新 CHANGELOG.md
 ```bash
 # 生成变更日志
 npm run changelog
 ```
 ### 3. 提交并推送
 ```bash
 git add .
 git commit -m "chore(release): bump version to x.x.x" -s
 git push origin main
 ```
 ### 4. 创建 Git 标签
 ```bash
 git tag v{version}
 git push origin v{version}
 ```
 ### 5. 触发 CI 构建
 推送标签后会自动触发 GitHub Actions 构建。
 ### 6. 检查构建结果
 在 GitHub Actions 页面查看构建状态。
 ### 7. 发布到 GitHub Release
 构建成功后，GitHub Actions 会自动创建 Release 并上传构建产物。
 ## CI/CD 工作流
 ### test.yml
 每次推送或 PR 时运行：
 - 单元测试
 - E2E 测试
 - Lint 检查
 ### build.yml
 推送到 main 分支或标签时运行：
 - 运行测试（前置依赖）
 - 构建 deb 和 rpm 包
 - 支持 x64 和 arm64 架构
 - 标签推送时自动创建 Release
 ## 版本管理
 ### 语义化版本
 遵循 [Semantic Versioning](https://semver.org/)：
 - **MAJOR:** 不兼容的 API 变更
 - **MINOR:** 向后兼容的功能新增
 - **PATCH:** 向后兼容的 Bug 修复
 ### 版本号示例
 ```
 4.9.9
 │ └─ PATCH (Bug 修复)
 │   └─ MINOR (新功能)
 └───── MAJOR (重大变更)
 ```
 ### 发布流程检查清单
 - [ ] 版本号已更新
 - [ ] CHANGELOG.md 已更新
 - [ ] 所有测试通过
 - [ ] 代码已审查
 - [ ] Lint 检查通过
 - [ ] 构建成功
 - [ ] Release 已创建
 - [ ] 构建产物已上传
 ---
 **© 2026 APM 应用商店项目**
@@ -1,380 +0,0 @@
 # 开发文档
 ## 📋 目录
 - [环境搭建](#环境搭建)
 - [项目结构详解](#项目结构详解)
 - [开发工作流](#开发工作流)
 - [调试技巧](#调试技巧)
 - [本地开发最佳实践](#本地开发最佳实践)
 ## 环境搭建
 ### 系统要求
 - **Node.js:** >= 22.12.0
 - **npm:** >= 9.x 或 pnpm >= 8.x
 - **操作系统:** Linux（推荐 Ubuntu 22.04+）
 - **可选:** APM 包管理器（用于测试）
 ### 安装依赖
 ```bash
 # 克隆仓库
 git clone https://github.com/elysia-best/apm-app-store.git
 cd apm-app-store
 # 安装依赖
 npm install
 # 或使用 pnpm
 pnpm install
 ```
 ### 开发服务器启动
 ```bash
 # 启动开发模式
 npm run dev
 # 应用将在以下地址启动
 # Vite 开发服务器: http://127.0.0.1:3344/
 # Electron 窗口将自动打开
 ```
 ### 构建项目
 ```bash
 # 构建生产版本（deb + rpm）
 npm run build
 # 仅构建前端
 npm run build:vite
 # 仅构建 deb 包
 npm run build:deb
 # 仅构建 rpm 包
 npm run build:rpm
 ```
 ## 项目结构详解
 ### Electron 主进程
 **目录:** `electron/main/`
 **核心文件:**
 - **`index.ts`** - 主进程入口
  - 创建应用窗口
  - 管理 IPC 通信
  - 处理生命周期事件
 - **`backend/install-manager.ts`** - 安装管理器
  - 管理安装任务队列
  - 执行 APM 命令
  - 流式输出日志
  - 解析安装结果
 - **`deeplink.ts`** - Deep Link 处理
  - 解析 `spk://` 协议
  - 路由到对应操作
 ### Vue 渲染进程
 **目录:** `src/`
 **核心模块:**
 - **`App.vue`** - 根组件
  - 应用状态管理
  - 分类和应用加载
  - 模态框协调
  - Deep Link 监听
 - **`components/`** - UI 组件
  - `AppCard.vue` - 应用卡片
  - `AppDetailModal.vue` - 应用详情
  - `DownloadQueue.vue` - 下载队列
  - 其他 11 个组件
 - **`global/`** - 全局状态
  - `downloadStatus.ts` - 下载队列
  - `storeConfig.ts` - API 配置
  - `typedefinition.ts` - 类型定义
 - **`modules/`** - 业务逻辑
  - `processInstall.ts` - 安装/卸载
 ### 共享模块
 **目录:** `electron/global.ts`
 - 进程间共享的常量和配置
 - 系统架构检测
 ### 配置文件
 - **`vite.config.ts`** - Vite 构建配置
 - **`electron-builder.yml`** - 打包配置
 - **`tsconfig.json`** - TypeScript 配置
 - **`eslint.config.ts`** - ESLint 配置
 ## 开发工作流
 ### 功能开发流程
 1. **需求分析**
   - 理解功能需求
   - 设计 API 和数据结构
   - 确定影响范围
 2. **创建分支**
   ```bash
   git checkout -b feature/your-feature
   ```
 3. **实现功能**
   - 更新类型定义 (`src/global/typedefinition.ts`)
   - 实现 Vue 组件
   - 添加 IPC 处理（如需要）
   - 编写测试
 4. **测试**
   ```bash
   npm run test
   npm run test:e2e
   ```
 5. **代码检查**
   ```bash
   npm run lint
   npm run format
   ```
 6. **提交 PR**
   - 使用 `feat(scope): description` 格式
   - 引用相关 Issue
   - 添加详细描述
 ### Bug 修复流程
 1. **复现 Bug**
   - 确认 Bug 存在
   - 添加复现步骤到 Issue
 2. **定位问题**
   - 查看日志
   - 使用调试器
   - 检查相关代码
 3. **创建分支**
   ```bash
   git checkout -b fix/your-bug-fix
   ```
 4. **修复代码**
   - 最小化修改
   - 添加回归测试
   - 更新文档（如需要）
 5. **验证修复**
   - 本地测试
   - 确保测试通过
 6. **提交 PR**
   - 使用 `fix(scope): description` 格式
   - 说明修复方法
 ### 重构流程
 1. **识别需要重构的代码**
   - 代码重复
   - 复杂度过高
   - 性能问题
 2. **制定重构计划**
   - 不改变外部行为
   - 逐步进行
   - 保持测试通过
 3. **执行重构**
   ```bash
   git checkout -b refactor/your-refactor
   ```
 4. **验证**
   - 所有测试通过
   - 性能未下降
   - 代码可读性提升
 ## 调试技巧
 ### 主进程调试
 **VS Code 配置:**
 创建 `.vscode/launch.json`:
 ```json
 {
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Electron: Main",
      "type": "node",
      "request": "launch",
      "cwd": "${workspaceFolder}",
      "runtimeExecutable": "${workspaceFolder}/node_modules/.bin/electron",
      "windows": {
        "runtimeExecutable": "${workspaceFolder}/node_modules/.bin/electron.cmd"
      },
      "args": ["."],
      "outputCapture": "std"
    }
  ]
 }
 ```
 **日志调试:**
 ```typescript
 import pino from "pino";
 const logger = pino({ name: "module-name" });
 logger.info("Application started");
 logger.error({ err }, "Failed to load apps");
 logger.debug("Debug information");
 ```
 ### 渲染进程调试
 **使用 Vue DevTools:**
 1. 安装 Vue DevTools 浏览器扩展
 2. Electron 会自动检测
 3. 检查组件树和状态
 **控制台日志:**
 ```typescript
 console.log("Debug:", data);
 console.error("Error:", error);
 console.table(apps);
 ```
 ### IPC 通信调试
 **主进程:**
 ```typescript
 ipcMain.on("test-channel", (event, data) => {
  console.log("Received:", data);
  event.sender.send("test-response", { result: "ok" });
 });
 ```
 **渲染进程:**
 ```typescript
 window.ipcRenderer.send("test-channel", { test: "data" });
 window.ipcRenderer.on("test-response", (_event, data) => {
  console.log("Response:", data);
 });
 ```
 ### 性能分析
 **Chrome DevTools:**
 1. 打开 DevTools (Ctrl+Shift+I)
 2. Performance 面板
 3. 录制并分析
 **Vite 分析:**
 ```bash
 npm run build:vite -- --mode profile
 ```
 ## 本地开发最佳实践
 ### 代码组织
 1. **组件拆分**
   - 单一职责原则
   - 组件不超过 300 行
   - 提取可复用逻辑
 2. **状态管理**
   - 使用 Vue 响应式系统
   - 全局状态放在 `src/global/`
   - 组件状态使用 `ref` 和 `computed`
 3. **类型定义**
   - 所有数据结构都有类型
   - 避免 `any` 类型
   - 使用 TypeScript 工具类型
 ### 组件复用
 1. **Props 设计**
   - 明确的类型定义
   - 合理的默认值
   - 必填项标注
 2. **Events 设计**
   - 使用 TypeScript 定义
   - 清晰的事件命名
 3. **插槽使用**
   - 提供灵活的内容布局
   - 具名插槽增强可用性
 ### 错误处理
 1. **Try-Catch**
   ```typescript
   try {
     await someAsyncOperation();
   } catch (error) {
     logger.error({ err: error }, "Operation failed");
     showErrorToUser(error.message);
   }
   ```
 2. **Promise 错误**
   ```typescript
   somePromise()
     .then((result) => {
       // handle success
     })
     .catch((error) => {
       // handle error
     });
   ```
 3. **Vue 错误捕获**
   ```typescript
   onMounted(() => {
     window.addEventListener("error", handleError);
   });
   ```
 ### 性能优化
 1. **列表虚拟化**（大数据集）
 2. **图片懒加载**
 3. **防抖和节流**
 4. **计算结果缓存**
 ---
 **© 2026 APM 应用商店项目**
@@ -1,154 +0,0 @@
 # 常见问题 (FAQ)
 ## 基本问题
 ### Q: APM 应用商店是什么？
 **A:** APM 应用商店是基于 Electron + Vue 3 构建的桌面应用商店客户端，用于 APM (AmberPM) 包管理器的图形化界面。
 ### Q: 支持哪些操作系统？
 **A:** 目前支持 Linux 系统，包括但不限于：
 - Ubuntu 20.04+
 - Debian 11+
 - Fedora 35+
 - Arch Linux
 - 银河麒麟
 - 统信 UOS
 ### Q: 如何安装 APM 应用商店？
 **A:**
 1. 从 GitHub Releases 下载 deb 或 rpm 包
 2. 使用包管理器安装：
   ```bash
   # Debian/Ubuntu
   sudo dpkg -i spark-store_*.deb
   # Fedora/RHEL
   sudo dnf install spark-store_*.rpm
   ```
 ### Q: 需要 APM 包管理器吗？
 **A:** 是的，APM 应用商店需要 APM 包管理器才能工作。请先安装 APM。
 ## 使用问题
 ### Q: 如何安装应用？
 **A:**
 1. 打开 APM 应用商店
 2. 浏览或搜索应用
 3. 点击应用卡片查看详情
 4. 点击"安装"按钮
 5. 等待安装完成
 ### Q: 如何卸载应用？
 **A:**
 1. 点击右上角"已安装"按钮
 2. 在列表中找到要卸载的应用
 3. 点击"卸载"按钮
 4. 确认卸载
 ### Q: 如何更新应用？
 **A:**
 1. 点击右上角"更新"按钮
 2. 选择要更新的应用
 3. 点击"更新"按钮
 4. 等待更新完成
 ### Q: 下载的应用在哪里？
 **A:**
 应用下载后存储在 APM 管理的目录中，通常位于：
 ```
 /opt/spark-store/apps/{pkgname}/
 ```
 ## 技术问题
 ### Q: 应用无法启动怎么办？
 **A:** 请参考 [问题排查指南](TROUBLESHOOTING.md)。
 ### Q: 如何查看日志？
 **A:**
 日志位置：
 - 主进程日志：`~/.config/spark-store/logs/`
 - 系统日志：`journalctl -u spark-store`
 ### Q: 如何切换主题？
 **A:**
 点击右上角主题切换按钮，或按 `Ctrl+Shift+T`。
 ### Q: 支持深色模式吗？
 **A:** 是的，支持亮色、暗色和跟随系统主题。
 ## 开发问题
 ### Q: 如何参与开发？
 **A:** 请参考 [贡献指南](CONTRIBUTING.md)。
 ### Q: 如何运行开发版本？
 **A:**
 ```bash
 git clone https://github.com/elysia-best/apm-app-store.git
 cd apm-app-store
 npm install
 npm run dev
 ```
 ### Q: 技术栈是什么？
 **A:**
 - Electron 40.0.0
 - Vue 3
 - Vite 6.4.1
 - TypeScript
 - Tailwind CSS 4.1.18
 ### Q: 如何报告 Bug？
 **A:**
 请在 [GitHub Issues](https://github.com/elysia-best/apm-app-store/issues) 提交 Bug 报告。
 ## 其他问题
 ### Q: 可以在 Windows/Mac 上使用吗？
 **A:** 目前不支持，但计划在未来添加跨平台支持。
 ### Q: 如何获取帮助？
 **A:**
 - 查看 [文档](README.md)
 - 提交 [Issue](https://github.com/elysia-best/apm-app-store/issues)
 - 加入 [社区论坛](https://bbs.spark-app.store/)
 ### Q: 许可证是什么？
 **A:**
 本项目采用 [GPL-3.0](LICENSE.md) 协议开源。
 ---
 **© 2026 APM 应用商店项目**
@@ -1,7 +1,7 @@
                    GNU GENERAL PUBLIC LICENSE
                       Version 3, 29 June 2007
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.
@@ -645,7 +645,7 @@ the "copyright" line and a pointer to where the full notice is found.
    GNU General Public License for more details.
    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 Also add information on how to contact you by electronic and paper mail.
@@ -664,11 +664,11 @@ might be different; for a GUI interface, you would use an "about box".
  You should also get your employer (if you work as a programmer) or school,
 if any, to sign a "copyright disclaimer" for the program, if necessary.
 For more information on this, and how to apply and follow the GNU GPL, see
-<https://www.gnu.org/licenses/>.
+<http://www.gnu.org/licenses/>.
  The GNU General Public License does not permit incorporating your program
 into proprietary programs.  If your program is a subroutine library, you
 may consider it more useful to permit linking proprietary applications with
 the library.  If this is what you want to do, use the GNU Lesser General
 Public License instead of this License.  But first, please read
-<https://www.gnu.org/licenses/why-not-lgpl.html>.
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
@@ -1,636 +0,0 @@
 # GNU GENERAL PUBLIC LICENSE
 Version 3, 29 June 2007
 Copyright (C) 2007 [Free Software Foundation, Inc.](http://fsf.org/)
 Everyone is permitted to copy and distribute verbatim copies of this license
 document, but changing it is not allowed.
 ## Preamble
 The GNU General Public License is a free, copyleft license for software and
 other kinds of works.
 The licenses for most software and other practical works are designed to take
 away your freedom to share and change the works. By contrast, the GNU General
 Public License is intended to guarantee your freedom to share and change all
 versions of a program--to make sure it remains free software for all its users.
 We, the Free Software Foundation, use the GNU General Public License for most
 of our software; it applies also to any other work released this way by its
 authors. You can apply it to your programs, too.
 When we speak of free software, we are referring to freedom, not price. Our
 General Public Licenses are designed to make sure that you have the freedom to
 distribute copies of free software (and charge for them if you wish), that you
 receive source code or can get it if you want it, that you can change the
 software or use pieces of it in new free programs, and that you know you can do
 these things.
 To protect your rights, we need to prevent others from denying you these rights
 or asking you to surrender the rights. Therefore, you have certain
 responsibilities if you distribute copies of the software, or if you modify it:
 responsibilities to respect the freedom of others.
 For example, if you distribute copies of such a program, whether gratis or for
 a fee, you must pass on to the recipients the same freedoms that you received.
 You must make sure that they, too, receive or can get the source code. And you
 must show them these terms so they know their rights.
 Developers that use the GNU GPL protect your rights with two steps:
  1. assert copyright on the software, and
  2. offer you this License giving you legal permission to copy, distribute
     and/or modify it.
 For the developers' and authors' protection, the GPL clearly explains that
 there is no warranty for this free software. For both users' and authors' sake,
 the GPL requires that modified versions be marked as changed, so that their
 problems will not be attributed erroneously to authors of previous versions.
 Some devices are designed to deny users access to install or run modified
 versions of the software inside them, although the manufacturer can do so. This
 is fundamentally incompatible with the aim of protecting users' freedom to
 change the software. The systematic pattern of such abuse occurs in the area of
 products for individuals to use, which is precisely where it is most
 unacceptable. Therefore, we have designed this version of the GPL to prohibit
 the practice for those products. If such problems arise substantially in other
 domains, we stand ready to extend this provision to those domains in future
 versions of the GPL, as needed to protect the freedom of users.
 Finally, every program is threatened constantly by software patents. States
 should not allow patents to restrict development and use of software on
 general-purpose computers, but in those that do, we wish to avoid the special
 danger that patents applied to a free program could make it effectively
 proprietary. To prevent this, the GPL assures that patents cannot be used to
 render the program non-free.
 The precise terms and conditions for copying, distribution and modification
 follow.
 ## TERMS AND CONDITIONS
 ### 0. Definitions.
 *This License* refers to version 3 of the GNU General Public License.
 *Copyright* also means copyright-like laws that apply to other kinds of works,
 such as semiconductor masks.
 *The Program* refers to any copyrightable work licensed under this License.
 Each licensee is addressed as *you*. *Licensees* and *recipients* may be
 individuals or organizations.
 To *modify* a work means to copy from or adapt all or part of the work in a
 fashion requiring copyright permission, other than the making of an exact copy.
 The resulting work is called a *modified version* of the earlier work or a work
 *based on* the earlier work.
 A *covered work* means either the unmodified Program or a work based on the
 Program.
 To *propagate* a work means to do anything with it that, without permission,
 would make you directly or secondarily liable for infringement under applicable
 copyright law, except executing it on a computer or modifying a private copy.
 Propagation includes copying, distribution (with or without modification),
 making available to the public, and in some countries other activities as well.
 To *convey* a work means any kind of propagation that enables other parties to
 make or receive copies. Mere interaction with a user through a computer
 network, with no transfer of a copy, is not conveying.
 An interactive user interface displays *Appropriate Legal Notices* to the
 extent that it includes a convenient and prominently visible feature that
  1. displays an appropriate copyright notice, and
  2. tells the user that there is no warranty for the work (except to the
     extent that warranties are provided), that licensees may convey the work
     under this License, and how to view a copy of this License.
 If the interface presents a list of user commands or options, such as a menu, a
 prominent item in the list meets this criterion.
 ### 1. Source Code.
 The *source code* for a work means the preferred form of the work for making
 modifications to it. *Object code* means any non-source form of a work.
 A *Standard Interface* means an interface that either is an official standard
 defined by a recognized standards body, or, in the case of interfaces specified
 for a particular programming language, one that is widely used among developers
 working in that language.
 The *System Libraries* of an executable work include anything, other than the
 work as a whole, that (a) is included in the normal form of packaging a Major
 Component, but which is not part of that Major Component, and (b) serves only
 to enable use of the work with that Major Component, or to implement a Standard
 Interface for which an implementation is available to the public in source code
 form. A *Major Component*, in this context, means a major essential component
 (kernel, window system, and so on) of the specific operating system (if any) on
 which the executable work runs, or a compiler used to produce the work, or an
 object code interpreter used to run it.
 The *Corresponding Source* for a work in object code form means all the source
 code needed to generate, install, and (for an executable work) run the object
 code and to modify the work, including scripts to control those activities.
 However, it does not include the work's System Libraries, or general-purpose
 tools or generally available free programs which are used unmodified in
 performing those activities but which are not part of the work. For example,
 Corresponding Source includes interface definition files associated with source
 files for the work, and the source code for shared libraries and dynamically
 linked subprograms that the work is specifically designed to require, such as
 by intimate data communication or control flow between those subprograms and
 other parts of the work.
 The Corresponding Source need not include anything that users can regenerate
 automatically from other parts of the Corresponding Source.
 The Corresponding Source for a work in source code form is that same work.
 ### 2. Basic Permissions.
 All rights granted under this License are granted for the term of copyright on
 the Program, and are irrevocable provided the stated conditions are met. This
 License explicitly affirms your unlimited permission to run the unmodified
 Program. The output from running a covered work is covered by this License only
 if the output, given its content, constitutes a covered work. This License
 acknowledges your rights of fair use or other equivalent, as provided by
 copyright law.
 You may make, run and propagate covered works that you do not convey, without
 conditions so long as your license otherwise remains in force. You may convey
 covered works to others for the sole purpose of having them make modifications
 exclusively for you, or provide you with facilities for running those works,
 provided that you comply with the terms of this License in conveying all
 material for which you do not control copyright. Those thus making or running
 the covered works for you must do so exclusively on your behalf, under your
 direction and control, on terms that prohibit them from making any copies of
 your copyrighted material outside their relationship with you.
 Conveying under any other circumstances is permitted solely under the
 conditions stated below. Sublicensing is not allowed; section 10 makes it
 unnecessary.
 ### 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
 No covered work shall be deemed part of an effective technological measure
 under any applicable law fulfilling obligations under article 11 of the WIPO
 copyright treaty adopted on 20 December 1996, or similar laws prohibiting or
 restricting circumvention of such measures.
 When you convey a covered work, you waive any legal power to forbid
 circumvention of technological measures to the extent such circumvention is
 effected by exercising rights under this License with respect to the covered
 work, and you disclaim any intention to limit operation or modification of the
 work as a means of enforcing, against the work's users, your or third parties'
 legal rights to forbid circumvention of technological measures.
 ### 4. Conveying Verbatim Copies.
 You may convey verbatim copies of the Program's source code as you receive it,
 in any medium, provided that you conspicuously and appropriately publish on
 each copy an appropriate copyright notice; keep intact all notices stating that
 this License and any non-permissive terms added in accord with section 7 apply
 to the code; keep intact all notices of the absence of any warranty; and give
 all recipients a copy of this License along with the Program.
 You may charge any price or no price for each copy that you convey, and you may
 offer support or warranty protection for a fee.
 ### 5. Conveying Modified Source Versions.
 You may convey a work based on the Program, or the modifications to produce it
 from the Program, in the form of source code under the terms of section 4,
 provided that you also meet all of these conditions:
  - a) The work must carry prominent notices stating that you modified it, and
    giving a relevant date.
  - b) The work must carry prominent notices stating that it is released under
    this License and any conditions added under section 7. This requirement
    modifies the requirement in section 4 to *keep intact all notices*.
  - c) You must license the entire work, as a whole, under this License to
    anyone who comes into possession of a copy. This License will therefore
    apply, along with any applicable section 7 additional terms, to the whole
    of the work, and all its parts, regardless of how they are packaged. This
    License gives no permission to license the work in any other way, but it
    does not invalidate such permission if you have separately received it.
  - d) If the work has interactive user interfaces, each must display
    Appropriate Legal Notices; however, if the Program has interactive
    interfaces that do not display Appropriate Legal Notices, your work need
    not make them do so.
 A compilation of a covered work with other separate and independent works,
 which are not by their nature extensions of the covered work, and which are not
 combined with it such as to form a larger program, in or on a volume of a
 storage or distribution medium, is called an *aggregate* if the compilation and
 its resulting copyright are not used to limit the access or legal rights of the
 compilation's users beyond what the individual works permit. Inclusion of a
 covered work in an aggregate does not cause this License to apply to the other
 parts of the aggregate.
 ### 6. Conveying Non-Source Forms.
 You may convey a covered work in object code form under the terms of sections 4
 and 5, provided that you also convey the machine-readable Corresponding Source
 under the terms of this License, in one of these ways:
  - a) Convey the object code in, or embodied in, a physical product (including
    a physical distribution medium), accompanied by the Corresponding Source
    fixed on a durable physical medium customarily used for software
    interchange.
  - b) Convey the object code in, or embodied in, a physical product (including
    a physical distribution medium), accompanied by a written offer, valid for
    at least three years and valid for as long as you offer spare parts or
    customer support for that product model, to give anyone who possesses the
    object code either
    1. a copy of the Corresponding Source for all the software in the product
       that is covered by this License, on a durable physical medium
       customarily used for software interchange, for a price no more than your
       reasonable cost of physically performing this conveying of source, or
    2. access to copy the Corresponding Source from a network server at no
       charge.
  - c) Convey individual copies of the object code with a copy of the written
    offer to provide the Corresponding Source. This alternative is allowed only
    occasionally and noncommercially, and only if you received the object code
    with such an offer, in accord with subsection 6b.
  - d) Convey the object code by offering access from a designated place
    (gratis or for a charge), and offer equivalent access to the Corresponding
    Source in the same way through the same place at no further charge. You
    need not require recipients to copy the Corresponding Source along with the
    object code. If the place to copy the object code is a network server, the
    Corresponding Source may be on a different server operated by you or a
    third party) that supports equivalent copying facilities, provided you
    maintain clear directions next to the object code saying where to find the
    Corresponding Source. Regardless of what server hosts the Corresponding
    Source, you remain obligated to ensure that it is available for as long as
    needed to satisfy these requirements.
  - e) Convey the object code using peer-to-peer transmission, provided you
    inform other peers where the object code and Corresponding Source of the
    work are being offered to the general public at no charge under subsection
    6d.
 A separable portion of the object code, whose source code is excluded from the
 Corresponding Source as a System Library, need not be included in conveying the
 object code work.
 A *User Product* is either
  1. a *consumer product*, which means any tangible personal property which is
     normally used for personal, family, or household purposes, or
  2. anything designed or sold for incorporation into a dwelling.
 In determining whether a product is a consumer product, doubtful cases shall be
 resolved in favor of coverage. For a particular product received by a
 particular user, *normally used* refers to a typical or common use of that
 class of product, regardless of the status of the particular user or of the way
 in which the particular user actually uses, or expects or is expected to use,
 the product. A product is a consumer product regardless of whether the product
 has substantial commercial, industrial or non-consumer uses, unless such uses
 represent the only significant mode of use of the product.
 *Installation Information* for a User Product means any methods, procedures,
 authorization keys, or other information required to install and execute
 modified versions of a covered work in that User Product from a modified
 version of its Corresponding Source. The information must suffice to ensure
 that the continued functioning of the modified object code is in no case
 prevented or interfered with solely because modification has been made.
 If you convey an object code work under this section in, or with, or
 specifically for use in, a User Product, and the conveying occurs as part of a
 transaction in which the right of possession and use of the User Product is
 transferred to the recipient in perpetuity or for a fixed term (regardless of
 how the transaction is characterized), the Corresponding Source conveyed under
 this section must be accompanied by the Installation Information. But this
 requirement does not apply if neither you nor any third party retains the
 ability to install modified object code on the User Product (for example, the
 work has been installed in ROM).
 The requirement to provide Installation Information does not include a
 requirement to continue to provide support service, warranty, or updates for a
 work that has been modified or installed by the recipient, or for the User
 Product in which it has been modified or installed. Access to a network may be
 denied when the modification itself materially and adversely affects the
 operation of the network or violates the rules and protocols for communication
 across the network.
 Corresponding Source conveyed, and Installation Information provided, in accord
 with this section must be in a format that is publicly documented (and with an
 implementation available to the public in source code form), and must require
 no special password or key for unpacking, reading or copying.
 ### 7. Additional Terms.
 *Additional permissions* are terms that supplement the terms of this License by
 making exceptions from one or more of its conditions. Additional permissions
 that are applicable to the entire Program shall be treated as though they were
 included in this License, to the extent that they are valid under applicable
 law. If additional permissions apply only to part of the Program, that part may
 be used separately under those permissions, but the entire Program remains
 governed by this License without regard to the additional permissions.
 When you convey a copy of a covered work, you may at your option remove any
 additional permissions from that copy, or from any part of it. (Additional
 permissions may be written to require their own removal in certain cases when
 you modify the work.) You may place additional permissions on material, added
 by you to a covered work, for which you have or can give appropriate copyright
 permission.
 Notwithstanding any other provision of this License, for material you add to a
 covered work, you may (if authorized by the copyright holders of that material)
 supplement the terms of this License with terms:
  - a) Disclaiming warranty or limiting liability differently from the terms of
    sections 15 and 16 of this License; or
  - b) Requiring preservation of specified reasonable legal notices or author
    attributions in that material or in the Appropriate Legal Notices displayed
    by works containing it; or
  - c) Prohibiting misrepresentation of the origin of that material, or
    requiring that modified versions of such material be marked in reasonable
    ways as different from the original version; or
  - d) Limiting the use for publicity purposes of names of licensors or authors
    of the material; or
  - e) Declining to grant rights under trademark law for use of some trade
    names, trademarks, or service marks; or
  - f) Requiring indemnification of licensors and authors of that material by
    anyone who conveys the material (or modified versions of it) with
    contractual assumptions of liability to the recipient, for any liability
    that these contractual assumptions directly impose on those licensors and
    authors.
 All other non-permissive additional terms are considered *further restrictions*
 within the meaning of section 10. If the Program as you received it, or any
 part of it, contains a notice stating that it is governed by this License along
 with a term that is a further restriction, you may remove that term. If a
 license document contains a further restriction but permits relicensing or
 conveying under this License, you may add to a covered work material governed
 by the terms of that license document, provided that the further restriction
 does not survive such relicensing or conveying.
 If you add terms to a covered work in accord with this section, you must place,
 in the relevant source files, a statement of the additional terms that apply to
 those files, or a notice indicating where to find the applicable terms.
 Additional terms, permissive or non-permissive, may be stated in the form of a
 separately written license, or stated as exceptions; the above requirements
 apply either way.
 ### 8. Termination.
 You may not propagate or modify a covered work except as expressly provided
 under this License. Any attempt otherwise to propagate or modify it is void,
 and will automatically terminate your rights under this License (including any
 patent licenses granted under the third paragraph of section 11).
 However, if you cease all violation of this License, then your license from a
 particular copyright holder is reinstated
  - a) provisionally, unless and until the copyright holder explicitly and
    finally terminates your license, and
  - b) permanently, if the copyright holder fails to notify you of the
    violation by some reasonable means prior to 60 days after the cessation.
 Moreover, your license from a particular copyright holder is reinstated
 permanently if the copyright holder notifies you of the violation by some
 reasonable means, this is the first time you have received notice of violation
 of this License (for any work) from that copyright holder, and you cure the
 violation prior to 30 days after your receipt of the notice.
 Termination of your rights under this section does not terminate the licenses
 of parties who have received copies or rights from you under this License. If
 your rights have been terminated and not permanently reinstated, you do not
 qualify to receive new licenses for the same material under section 10.
 ### 9. Acceptance Not Required for Having Copies.
 You are not required to accept this License in order to receive or run a copy
 of the Program. Ancillary propagation of a covered work occurring solely as a
 consequence of using peer-to-peer transmission to receive a copy likewise does
 not require acceptance. However, nothing other than this License grants you
 permission to propagate or modify any covered work. These actions infringe
 copyright if you do not accept this License. Therefore, by modifying or
 propagating a covered work, you indicate your acceptance of this License to do
 so.
 ### 10. Automatic Licensing of Downstream Recipients.
 Each time you convey a covered work, the recipient automatically receives a
 license from the original licensors, to run, modify and propagate that work,
 subject to this License. You are not responsible for enforcing compliance by
 third parties with this License.
 An *entity transaction* is a transaction transferring control of an
 organization, or substantially all assets of one, or subdividing an
 organization, or merging organizations. If propagation of a covered work
 results from an entity transaction, each party to that transaction who receives
 a copy of the work also receives whatever licenses to the work the party's
 predecessor in interest had or could give under the previous paragraph, plus a
 right to possession of the Corresponding Source of the work from the
 predecessor in interest, if the predecessor has it or can get it with
 reasonable efforts.
 You may not impose any further restrictions on the exercise of the rights
 granted or affirmed under this License. For example, you may not impose a
 license fee, royalty, or other charge for exercise of rights granted under this
 License, and you may not initiate litigation (including a cross-claim or
 counterclaim in a lawsuit) alleging that any patent claim is infringed by
 making, using, selling, offering for sale, or importing the Program or any
 portion of it.
 ### 11. Patents.
 A *contributor* is a copyright holder who authorizes use under this License of
 the Program or a work on which the Program is based. The work thus licensed is
 called the contributor's *contributor version*.
 A contributor's *essential patent claims* are all patent claims owned or
 controlled by the contributor, whether already acquired or hereafter acquired,
 that would be infringed by some manner, permitted by this License, of making,
 using, or selling its contributor version, but do not include claims that would
 be infringed only as a consequence of further modification of the contributor
 version. For purposes of this definition, *control* includes the right to grant
 patent sublicenses in a manner consistent with the requirements of this
 License.
 Each contributor grants you a non-exclusive, worldwide, royalty-free patent
 license under the contributor's essential patent claims, to make, use, sell,
 offer for sale, import and otherwise run, modify and propagate the contents of
 its contributor version.
 In the following three paragraphs, a *patent license* is any express agreement
 or commitment, however denominated, not to enforce a patent (such as an express
 permission to practice a patent or covenant not to sue for patent
 infringement). To *grant* such a patent license to a party means to make such
 an agreement or commitment not to enforce a patent against the party.
 If you convey a covered work, knowingly relying on a patent license, and the
 Corresponding Source of the work is not available for anyone to copy, free of
 charge and under the terms of this License, through a publicly available
 network server or other readily accessible means, then you must either
  1. cause the Corresponding Source to be so available, or
  2. arrange to deprive yourself of the benefit of the patent license for this
     particular work, or
  3. arrange, in a manner consistent with the requirements of this License, to
     extend the patent license to downstream recipients.
 *Knowingly relying* means you have actual knowledge that, but for the patent
 license, your conveying the covered work in a country, or your recipient's use
 of the covered work in a country, would infringe one or more identifiable
 patents in that country that you have reason to believe are valid.
 If, pursuant to or in connection with a single transaction or arrangement, you
 convey, or propagate by procuring conveyance of, a covered work, and grant a
 patent license to some of the parties receiving the covered work authorizing
 them to use, propagate, modify or convey a specific copy of the covered work,
 then the patent license you grant is automatically extended to all recipients
 of the covered work and works based on it.
 A patent license is *discriminatory* if it does not include within the scope of
 its coverage, prohibits the exercise of, or is conditioned on the non-exercise
 of one or more of the rights that are specifically granted under this License.
 You may not convey a covered work if you are a party to an arrangement with a
 third party that is in the business of distributing software, under which you
 make payment to the third party based on the extent of your activity of
 conveying the work, and under which the third party grants, to any of the
 parties who would receive the covered work from you, a discriminatory patent
 license
  - a) in connection with copies of the covered work conveyed by you (or copies
    made from those copies), or
  - b) primarily for and in connection with specific products or compilations
    that contain the covered work, unless you entered into that arrangement, or
    that patent license was granted, prior to 28 March 2007.
 Nothing in this License shall be construed as excluding or limiting any implied
 license or other defenses to infringement that may otherwise be available to
 you under applicable patent law.
 ### 12. No Surrender of Others' Freedom.
 If conditions are imposed on you (whether by court order, agreement or
 otherwise) that contradict the conditions of this License, they do not excuse
 you from the conditions of this License. If you cannot convey a covered work so
 as to satisfy simultaneously your obligations under this License and any other
 pertinent obligations, then as a consequence you may not convey it at all. For
 example, if you agree to terms that obligate you to collect a royalty for
 further conveying from those to whom you convey the Program, the only way you
 could satisfy both those terms and this License would be to refrain entirely
 from conveying the Program.
 ### 13. Use with the GNU Affero General Public License.
 Notwithstanding any other provision of this License, you have permission to
 link or combine any covered work with a work licensed under version 3 of the
 GNU Affero General Public License into a single combined work, and to convey
 the resulting work. The terms of this License will continue to apply to the
 part which is the covered work, but the special requirements of the GNU Affero
 General Public License, section 13, concerning interaction through a network
 will apply to the combination as such.
 ### 14. Revised Versions of this License.
 The Free Software Foundation may publish revised and/or new versions of the GNU
 General Public License from time to time. Such new versions will be similar in
 spirit to the present version, but may differ in detail to address new problems
 or concerns.
 Each version is given a distinguishing version number. If the Program specifies
 that a certain numbered version of the GNU General Public License *or any later
 version* applies to it, you have the option of following the terms and
 conditions either of that numbered version or of any later version published by
 the Free Software Foundation. If the Program does not specify a version number
 of the GNU General Public License, you may choose any version ever published by
 the Free Software Foundation.
 If the Program specifies that a proxy can decide which future versions of the
 GNU General Public License can be used, that proxy's public statement of
 acceptance of a version permanently authorizes you to choose that version for
 the Program.
 Later license versions may give you additional or different permissions.
 However, no additional obligations are imposed on any author or copyright
 holder as a result of your choosing to follow a later version.
 ### 15. Disclaimer of Warranty.
 THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE
 LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER
 PARTIES PROVIDE THE PROGRAM *AS IS* WITHOUT WARRANTY OF ANY KIND, EITHER
 EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE
 QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE
 DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR
 CORRECTION.
 ### 16. Limitation of Liability.
 IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY
 COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS
 PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL,
 INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE
 THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED
 INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE
 PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY
 HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 ### 17. Interpretation of Sections 15 and 16.
 If the disclaimer of warranty and limitation of liability provided above cannot
 be given local legal effect according to their terms, reviewing courts shall
 apply local law that most closely approximates an absolute waiver of all civil
 liability in connection with the Program, unless a warranty or assumption of
 liability accompanies a copy of the Program in return for a fee.
 ## END OF TERMS AND CONDITIONS ###
 ### How to Apply These Terms to Your New Programs
 If you develop a new program, and you want it to be of the greatest possible
 use to the public, the best way to achieve this is to make it free software
 which everyone can redistribute and change under these terms.
 To do so, attach the following notices to the program. It is safest to attach
 them to the start of each source file to most effectively state the exclusion
 of warranty; and each file should have at least the *copyright* line and a
 pointer to where the full notice is found.
 	<one line to give the program's name and a brief idea of what it does.>
 	Copyright (C) <year>  <name of author>
 	This program is free software: you can redistribute it and/or modify
 	it under the terms of the GNU General Public License as published by
 	the Free Software Foundation, either version 3 of the License, or
 	(at your option) any later version.
 	This program is distributed in the hope that it will be useful,
 	but WITHOUT ANY WARRANTY; without even the implied warranty of
 	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 	GNU General Public License for more details.
 	You should have received a copy of the GNU General Public License
 	along with this program.  If not, see <http://www.gnu.org/licenses/>.
 Also add information on how to contact you by electronic and paper mail.
 If the program does terminal interaction, make it output a short notice like
 this when it starts in an interactive mode:
 	<program>  Copyright (C) <year>  <name of author>
 	This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
 	This is free software, and you are welcome to redistribute it
 	under certain conditions; type `show c' for details.
 The hypothetical commands `show w` and `show c` should show the appropriate
 parts of the General Public License. Of course, your program's commands might
 be different; for a GUI interface, you would use an *about box*.
 You should also get your employer (if you work as a programmer) or school, if
 any, to sign a *copyright disclaimer* for the program, if necessary. For more
 information on this, and how to apply and follow the GNU GPL, see
 [http://www.gnu.org/licenses/](http://www.gnu.org/licenses/).
 The GNU General Public License does not permit incorporating your program into
 proprietary programs. If your program is a subroutine library, you may consider
 it more useful to permit linking proprietary applications with the library. If
 this is what you want to do, use the GNU Lesser General Public License instead
 of this License. But first, please read
 [http://www.gnu.org/philosophy/why-not-lgpl.html](http://www.gnu.org/philosophy/why-not-lgpl.html).
@@ -1,229 +0,0 @@
 # 项目整理完成总结
 ## ✅ 完成的工作
 ### 1. 核心文档（3个文件）
 | 文件            | 状态              | 说明                        |
 | --------------- | ----------------- | --------------------------- |
 | AGENTS.md       | ✅ 已替换为中文版 | 完整的 AI 编码指南（894行） |
 | CONTRIBUTING.md | ✅ 新建           | 贡献指南（中文）            |
 | DEVELOPMENT.md  | ✅ 新建           | 开发文档（中文）            |
 ### 2. 工作流文档（9个文件）
 | 文件                                          | 说明           |
 | --------------------------------------------- | -------------- |
 | .agents/workflows/feature-development.md      | 新功能开发流程 |
 | .agents/workflows/bug-fix.md                  | Bug 修复流程   |
 | .agents/workflows/code-review.md              | 代码审查流程   |
 | .agents/workflows/testing.md                  | 测试编写流程   |
 | .agents/workflows/release.md                  | 发布流程       |
 | .agents/workflows/refactoring.md              | 代码重构流程   |
 | .agents/workflows/documentation.md            | 文档更新流程   |
 | .agents/workflows/performance-optimization.md | 性能优化流程   |
 | .agents/workflows/security-audit.md           | 安全审计流程   |
 **删除的文件:**
 - .agents/workflows/1.md
 - .agents/workflows/代码审查.md
 ### 3. 测试基础设施（5个文件）
 | 文件                                      | 说明                    |
 | ----------------------------------------- | ----------------------- |
 | vitest.config.ts                          | Vitest 单元测试配置     |
 | playwright.config.ts                      | Playwright E2E 测试配置 |
 | src/**tests**/setup.ts                    | 测试环境设置            |
 | src/**tests**/unit/downloadStatus.test.ts | 示例单元测试            |
 | e2e/basic.spec.ts                         | 示例 E2E 测试           |
 ### 4. 测试文档（1个文件）
 | 文件       | 说明                   |
 | ---------- | ---------------------- |
 | TESTING.md | 完整的测试文档（中文） |
 ### 5. CI/CD 集成（2个文件）
 | 文件                        | 操作                 |
 | --------------------------- | -------------------- |
 | .github/workflows/test.yml  | 新建（测试 CI）      |
 | .github/workflows/build.yml | 更新（添加测试步骤） |
 ### 6. 完善文档（3个文件）
 | 文件               | 说明                 |
 | ------------------ | -------------------- |
 | DEPLOYMENT.md      | 部署文档（中文）     |
 | TROUBLESHOOTING.md | 问题排查指南（中文） |
 | FAQ.md             | 常见问题（中文）     |
 ### 7. Issue 模板更新（2个文件）
 | 文件                                  | 操作           |
 | ------------------------------------- | -------------- |
 | .github/ISSUE_TEMPLATE/bug_report.md  | 更新为标准模板 |
 | .github/ISSUE_TEMPLATE/help_wanted.md | 更新为标准模板 |
 ### 8. 配置更新
 | 文件         | 操作               |
 | ------------ | ------------------ |
 | package.json | 添加测试依赖和脚本 |
 | .gitignore   | 添加测试相关忽略项 |
 ## 📊 统计数据
 - **创建的文件:** 23个
 - **更新的文件:** 3个
 - **删除的文件:** 2个
 - **总计:** 28个文件操作
 ## 📝 新增的 npm 脚本
 ```json
 {
  "test": "vitest",
  "test:watch": "vitest --watch",
  "test:coverage": "vitest --coverage",
  "test:e2e": "playwright test",
  "test:e2e:ui": "playwright test --ui",
  "test:e2e:debug": "playwright test --debug",
  "test:all": "npm run test && npm run test:e2e"
 }
 ```
 ## 📦 新增的依赖
 ### Dev Dependencies
 - `@playwright/test`: ^1.40.0
 - `@testing-library/jest-dom`: ^6.1.5
 - `@testing-library/vue`: ^8.0.1
 - `@vitest/coverage-v8`: ^1.0.0
 - `@vue/test-utils`: ^2.4.3
 - `jsdom`: ^23.0.1
 - `vitest`: ^1.0.0
 ## 🔍 已知问题
 ### LSP 类型错误
 由于 Vitest 和 Vite 的版本兼容性问题，LSP 会报告一些类型错误，但这些不会影响实际运行：
 - `vitest.config.ts` 中的插件类型不匹配（Vite vs Vitest 版本差异）
 - 这些错误在运行时不会出现
 ### ESLint 错误
 项目中有一些现有的 ESLint 错误需要修复：
 - `src/App.vue`: 3个 `any` 类型错误
 - `src/components/HomeView.vue`: 5个错误（未使用变量、any 类型）
 - `src/components/TopActions.vue`: 1个未使用变量
 这些是原有代码的问题，不是本次整理引入的。
 ## 🚀 下一步建议
 1. **修复 ESLint 错误**
   ```bash
   npm run lint:fix
   ```
 2. **运行测试验证**
   ```bash
   npm run test
   ```
 3. **安装 Playwright 浏览器**
   ```bash
   npx playwright install --with-deps chromium
   ```
 4. **运行 E2E 测试**
   ```bash
   npm run test:e2e
   ```
 5. **提交代码**
   ```bash
   git add .
   git commit -m "chore: add comprehensive documentation and testing infrastructure" -s
   git push origin main
   ```
 ## 📚 文档结构总览
 ```
 apm-app-store/
 ├── AGENTS.md                          # AI 编码指南（中文）
 ├── CONTRIBUTING.md                    # 贡献指南（中文）
 ├── DEVELOPMENT.md                     # 开发文档（中文）
 ├── DEPLOYMENT.md                      # 部署文档（中文）
 ├── TROUBLESHOOTING.md                 # 问题排查（中文）
 ├── FAQ.md                             # 常见问题（中文）
 ├── TESTING.md                         # 测试文档（中文）
 ├── README.md                          # 项目说明（已存在）
 ├── CHANGELOG.md                       # 变更日志（已存在）
 ├── SECURITY.md                        # 安全政策（已存在）
 ├── LICENSE.md                         # 许可证（已存在）
 ├── CREDITS.md                         # 致谢（已存在）
 ├── vitest.config.ts                   # Vitest 配置
 ├── playwright.config.ts               # Playwright 配置
 ├── .agents/
 │   └── workflows/
 │       ├── feature-development.md     # 新功能开发
 │       ├── bug-fix.md                 # Bug 修复
 │       ├── code-review.md             # 代码审查
 │       ├── testing.md                 # 测试编写
 │       ├── release.md                 # 发布流程
 │       ├── refactoring.md             # 代码重构
 │       ├── documentation.md           # 文档更新
 │       ├── performance-optimization.md # 性能优化
 │       └── security-audit.md          # 安全审计
 ├── .github/
 │   ├── workflows/
 │   │   ├── test.yml                   # 测试 CI（新建）
 │   │   └── build.yml                  # 构建 CI（更新）
 │   └── ISSUE_TEMPLATE/
 │       ├── bug_report.md              # Bug 报告模板（更新）
 │       └── help_wanted.md             # 功能请求模板（更新）
 ├── src/
 │   └── __tests__/
 │       ├── setup.ts                   # 测试设置
 │       └── unit/
 │           └── downloadStatus.test.ts # 示例测试
 └── e2e/
    └── basic.spec.ts                 # E2E 测试示例
 ```
 ## 🎯 项目成熟度提升
 整理前：
 - ❌ 缺少完整的开发文档
 - ❌ 缺少测试基础设施
 - ❌ 工作流文档简单
 - ❌ 没有自动化测试 CI
 整理后：
 - ✅ 完整的中文开发文档
 - ✅ 完整的测试基础设施（Vitest + Playwright）
 - ✅ 9个详细的 AI 工作流
 - ✅ 自动化测试 CI/CD
 - ✅ 标准化的 Issue 模板
 - ✅ 完善的部署和问题排查文档
 ---
 **整理完成时间:** 2026-03-10
 **整理执行者:** OpenCode AI Assistant
 **文档版本:** 1.0
@@ -1,79 +1,22 @@
-# 星火应用商店
+# deepin-community-store
-<div align="center">
+#### 介绍
 deepin社区商店，由社区维护
 web页面部分正在开发当中
-<img src="icons/spark-store.svg" alt="APM Logo" width="200" height="200" />
+#### 说明
-**星火应用商店**
+需要在运行目录下放置服务器线路列表`server.list`，每行一个，在末尾需要添加“/”
-## 简介
+当前服务器线路列表（直接复制到相应文件即可）：
-欢迎来到**星火应用商店**！这是一个为 Linux 平台用户设计的应用商店，旨在解决 Linux 生态下应用分散、难以获取的问题。无论您使用什么类型的 Linux 发行版，在这里都有可能找到适合您的软件包。
+```
 http://dcstore.shenmo.tech/
 http://store.shenmo.tech/
 http://store2.shenmo.tech/
 http://store.moshengren.xyz/
 ```
-Linux 应用的数量相对有限，Wine 软件的可获取性也颇为困难。优秀的开发套件和工具资源散布在各大社区和论坛之间，这种分散化让整个生态系统难以得到全面的提升。
+#### 参与贡献
-生态系统的构建并非依赖个体的孤立努力，而需要全社区共同参与。只有当大家的“星火”聚集一处，方可引发“燎原之势”。
+1.  Fork 本仓库
 为了改善这一现状，我们推出了星火应用商店。星火社区广泛地收录了各种用户需求的软件包，汇集了高质量的小工具，并主动对 Wine 应用进行了适配，一切都储存在我们的软件库中，使得用户可以方便地获取这些应用。
 **当前支持的 Linux 发行版包括（但不限于）：**
 - **amd64 架构：** Debian 10+ / Ubuntu 22.04+ / Arch Linux / Fedora / deepin / UOS / 银河麒麟 
 - **arm64 架构：** Debian 10+ / Ubuntu 22.04+ / Arch Linux / deepin / UOS / 银河麒麟 
 - **loong64 架构：** deepin 23/25
 对于不同平台，商店展示的应用列表不同，如有需要请提交应用需求，我们会尽快添加。
 </div>
 ## 🚀 快速开始
 ### 安装应用商店
 * Debian(包括Ubuntu、deepin、银河麒麟、UOS)
 1. 从 Release 下载最新版本的应用商店客户端。
 2. 从启动器中打开并使用
 * Fedora
 1. `sudo dnf copr enable xmp360/spark-store`
 2. `sudo dnf install spark-store`
 * Arch Linux
 1. `paru -S spark-store`
 ---
 <div align="center">
 <img src="./galleries/image.png" alt="APM Screenshot" width="90%"  />
 </div>
 ## 📦 关于 APM
 **APM (AmberPM)** 是基于 `fuse-overlayfs` + `dpkg` + `AmberCE` 的容器化兼容层，为多发行版提供轻量级的应用运行方案。星火的 Arch Linux 版本和 Fedora 版本基于APM实现支持。
 ### 核心特性
 ✅ **多发行版兼容** — 完美支持 Arch Linux、Fedora、银河麒麟、统信 UOS 等主流发行版，让星火商店应用随处可用  
 🔄 **智能包转换** — 与 Debian 生态深度兼容，绝大多数 deb 包可一键自动转换为 APM 格式  
 ⚡ **轻量兼容层** — 基于 overlayfs 技术打造，极速启动无负担，告别臃肿容器  
 🎮 **NVIDIA 硬件加速** — 智能识别主机 GPU 驱动，自动配置硬件加速，畅享流畅体验
 APM的源码：[APM Source Code](https://gitee.com/amber-ce/amber-pm)
 ---
 **重要须知：** 本软件无法保证持续可用、无中断运行或满足特定性能要求。星火社区对其功能完整性、稳定性及无错误运行不作任何承诺。例如，若您计划在 UOS 专业版（或其他类似特定平台）上使用，请务必了解并启用“开发者模式”相关功能。请确保您具备基础的故障排查能力。需要明确的是，星火社区无法在部分特殊平台上进行广泛测试。因此，在这些平台上使用星火应用商店客户端可能会导致一系列问题，如系统更新失败、数据丢失等；使用该软件，即代表您理解并同意所有风险需由用户自行承担。
 **© 2026 APM / AmberPM | The Spark Project**
 Made with ❤️ by the Spark Store Team
 </div>
@@ -1,71 +0,0 @@
 # Security Policy / 安全策略
 ---
 ## 🌐 English Version
 ### Supported Versions
 The following versions currently receive security updates:
 | Version | Supported          |
 |---------|--------------------|
 | > 1.0.4   | :white_check_mark: |
 | < 1.0.4   | :x:                |
 > **Note**: Only versions marked with ✅ receive security patches. Upgrade to a supported version immediately if using an unsupported release.
 ### Reporting a Vulnerability
 We deeply appreciate your efforts to responsibly disclose security issues. Please follow these guidelines:
 #### 📬 How to Report
 - **Preferred**: Use GitHub's [Private Vulnerability Reporting](https://docs.github.com/en/code-security/security-advisories/guidance-on-reporting-and-writing-information-about-vulnerabilities)
 #### 📋 Report Should Include
 - Clear description of the vulnerability and potential impact
 - Affected component/version
 - Steps to reproduce (PoC code appreciated but optional)
 - Suggested mitigation (if known)
 - Contact information and preferred disclosure timeline
 #### ⚠️ Important Notes
 - **DO NOT** disclose publicly before coordination
 - Avoid intrusive testing (e.g., data exfiltration, DoS)
 - We comply with [ISO/IEC 29147](https://www.iso.org/standard/45173.html) vulnerability disclosure standards
 - Good-faith researchers acting responsibly will not face legal action
 Thank you for helping keep our community safe! 🛡️
 ---
 ## 🇨🇳 中文版本
 ### 支持的版本
 以下版本当前接收安全更新：
 | 版本   | 是否支持          |
 |--------|-------------------|
 | > 1.0.4   | :white_check_mark: |
 | < 1.0.4   | :x:                |
 > **提示**：仅标记 ✅ 的版本接收安全补丁。如使用不受支持的版本，请立即升级至受支持版本。
 ### 漏洞报告流程
 感谢您负责任地披露安全问题。请遵循以下指南：
 #### 📬 报告方式
 - **首选**：使用 GitHub [私有漏洞报告](https://docs.github.com/zh/code-security/security-advisories/guidance-on-reporting-and-writing-information-about-vulnerabilities) 功能
 #### 📋 报告内容建议包含
 - 漏洞清晰描述及潜在影响
 - 受影响组件/版本
 - 复现步骤（提供验证代码更佳，非必需）
 - 建议的缓解措施（如已知）
 - 联系方式及期望的披露时间
 #### ⚠️ 重要提示
 - 修复完成前**请勿公开披露**
 - 避免侵入性测试（如数据窃取、拒绝服务攻击）
 - 本流程遵循 [ISO/IEC 29147](https://www.iso.org/standard/45173.html) 漏洞披露国际标准
 - 本着善意负责任研究的安全研究员将不会面临法律追责
 感谢您为社区安全贡献力量！🛡️
@@ -1,436 +0,0 @@
 # 测试文档
 ## 📋 目录
 - [测试框架](#测试框架)
 - [测试规范](#测试规范)
 - [编写测试](#编写测试)
 - [运行测试](#运行测试)
 - [测试覆盖率](#测试覆盖率)
 - [Mock 数据](#mock-数据)
 - [E2E 测试](#e2e-测试)
 ## 测试框架
 ### Vitest（单元测试）
 Vitest 是 Vite 原生的测试框架，提供快速的开发体验。
 **特点:**
 - 与 Vite 配置共享
 - 极快的测试执行速度
 - 内置 TypeScript 支持
 - Jest 兼容的 API
 **配置文件:** `vitest.config.ts`
 ### Playwright（E2E 测试）
 Playwright 用于端到端测试，模拟真实用户操作。
 **特点:**
 - 支持多浏览器（Chromium, Firefox, WebKit）
 - 自动等待
 - 网络拦截和 mock
 - 可视化测试运行
 **配置文件:** `playwright.config.ts`
 ## 测试规范
 ### 命名规范
 **测试文件:** `*.test.ts` 或 `*.spec.ts`
 **测试目录结构:**
 ```
 src/
 ├── __tests__/
 │   ├── unit/           # 单元测试
 │   │   ├── downloadStatus.test.ts
 │   │   └── storeConfig.test.ts
 │   ├── integration/    # 集成测试
 │   │   └── installFlow.test.ts
 │   └── setup.ts        # 测试设置
 └── components/
    └── AppCard.test.ts  # 组件测试
 e2e/
 ├── install.spec.ts     # E2E 测试
 └── download.spec.ts
 ```
 ### 测试分组
 使用 `describe` 分组相关测试：
 ```typescript
 describe("ComponentName", () => {
  describe("method", () => {
    it("should do something", () => {
      // ...
    });
  });
 });
 ```
 ### 测试命名
 使用清晰的描述性名称：
 ```typescript
 ✅ 好的:
 it('should return true when app is installed')
 it('should throw error when package not found')
 ❌ 不好的:
 it('test1')
 it('works')
 ```
 ## 编写测试
 ### 单元测试
 **测试纯函数:**
 ```typescript
 import { describe, it, expect } from "vitest";
 import { parseInstalledList } from "@/modules/parse";
 describe("parseInstalledList", () => {
  it("should parse installed list correctly", () => {
    const output = "code/stable,1.108.2 amd64 [installed]";
    const result = parseInstalledList(output);
    expect(result).toHaveLength(1);
    expect(result[0].pkgname).toBe("code");
    expect(result[0].version).toBe("1.108.2");
  });
 });
 ```
 **测试 Vue 组件:**
 ```typescript
 import { describe, it, expect } from "vitest";
 import { mount } from "@vue/test-utils";
 import AppCard from "@/components/AppCard.vue";
 import type { App } from "@/global/typedefinition";
 describe("AppCard", () => {
  const mockApp: App = {
    name: "Test App",
    pkgname: "test-app",
    version: "1.0.0",
    filename: "test.deb",
    torrent_address: "",
    author: "Test",
    contributor: "Test",
    website: "https://example.com",
    update: "2024-01-01",
    size: "100M",
    more: "Test app",
    tags: "",
    img_urls: [],
    icons: "",
    category: "test",
    currentStatus: "not-installed",
  };
  it("should render app name", () => {
    const wrapper = mount(AppCard, {
      props: {
        app: mockApp,
      },
    });
    expect(wrapper.text()).toContain("Test App");
  });
  it("should emit install event", async () => {
    const wrapper = mount(AppCard, {
      props: {
        app: mockApp,
      },
    });
    await wrapper.find(".install-button").trigger("click");
    expect(wrapper.emitted("install")).toBeTruthy();
  });
 });
 ```
 ### 集成测试
 测试模块间的交互：
 ```typescript
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import { installPackage } from "@/modules/processInstall";
 import { downloads, addDownload } from "@/global/downloadStatus";
 describe("installPackage integration", () => {
  beforeEach(() => {
    downloads.value = [];
    vi.clearAllMocks();
  });
  it("should add download and send IPC message", () => {
    const pkgname = "test-app";
    installPackage(pkgname);
    expect(downloads.value).toHaveLength(1);
    expect(downloads.value[0].pkgname).toBe(pkgname);
    expect(window.ipcRenderer.send).toHaveBeenCalledWith(
      "queue-install",
      expect.any(String),
    );
  });
 });
 ```
 ## 运行测试
 ### 单元测试
 ```bash
 # 运行所有测试
 npm run test
 # 监听模式（开发时）
 npm run test:watch
 # 运行特定文件
 npm run test src/__tests__/unit/downloadStatus.test.ts
 # 运行匹配模式的测试
 npm run test -- downloadStatus
 ```
 ### 覆盖率
 ```bash
 # 生成覆盖率报告
 npm run test:coverage
 # 报告位置:
 # - 控制台: 文本报告
 # - coverage/ 目录: HTML 报告
 ```
 ### E2E 测试
 ```bash
 # 运行所有 E2E 测试
 npm run test:e2e
 # UI 模式（推荐用于开发）
 npm run test:e2e:ui
 # 调试模式
 npm run test:e2e:debug
 # 运行特定测试
 npm run test:e2e -- install.spec.ts
 ```
 ## 测试覆盖率
 ### 覆盖率目标
 - **语句覆盖率:** ≥ 70%
 - **分支覆盖率:** ≥ 70%
 - **函数覆盖率:** ≥ 70%
 - **行覆盖率:** ≥ 70%
 ### 查看报告
 ```bash
 npm run test:coverage
 # 在浏览器中打开
 open coverage/index.html
 ```
 ### CI 中强制检查
 在 `.github/workflows/test.yml` 中配置覆盖率阈值。
 ## Mock 数据
 ### Mock IPC
 在 `src/__tests__/setup.ts` 中全局 mock：
 ```typescript
 global.window = Object.create(window);
 Object.defineProperty(window, "ipcRenderer", {
  value: {
    send: vi.fn(),
    on: vi.fn(),
    off: vi.fn(),
    invoke: vi.fn(),
    removeListener: vi.fn(),
  },
 });
 ```
 ### Mock API 响应
 ```typescript
 import { vi } from "vitest";
 import axios from "axios";
 vi.mock("axios");
 describe("fetchApps", () => {
  it("should fetch apps from API", async () => {
    const mockApps = [{ name: "Test", pkgname: "test" }];
    axios.get.mockResolvedValue({ data: mockApps });
    const result = await fetchApps();
    expect(result).toEqual(mockApps);
  });
 });
 ```
 ### Mock 文件系统
 ```typescript
 import { vi } from "vitest";
 import fs from "node:fs";
 vi.mock("node:fs");
 describe("readConfig", () => {
  it("should read config file", () => {
    const mockConfig = { theme: "dark" };
    fs.readFileSync.mockReturnValue(JSON.stringify(mockConfig));
    const config = readConfig();
    expect(config).toEqual(mockConfig);
  });
 });
 ```
 ## E2E 测试
 ### 编写 E2E 测试
 ```typescript
 import { test, expect } from "@playwright/test";
 test.describe("App Installation", () => {
  test.beforeEach(async ({ page }) => {
    await page.goto("http://127.0.0.1:3344");
  });
  test("should install an app", async ({ page }) => {
    // 搜索应用
    await page.fill('input[placeholder="搜索应用"]', "Test App");
    await page.press('input[placeholder="搜索应用"]', "Enter");
    // 等待结果
    await expect(page.locator(".app-card")).toBeVisible();
    // 点击安装
    await page.click('.app-card:has-text("Test App") .install-button');
    // 验证下载队列
    await expect(page.locator(".download-queue")).toBeVisible();
    await expect(page.locator(".download-item")).toHaveText("Test App");
  });
  test("should show installation progress", async ({ page }) => {
    // ... 测试进度显示
  });
  test("should handle installation failure", async ({ page }) => {
    // ... 测试失败处理
  });
 });
 ```
 ### E2E 测试最佳实践
 1. **使用选择器**
   ```typescript
   // 推荐：语义化选择器
   await page.click('[data-testid="install-button"]');
   // 避免：脆弱的选择器
   await page.click("button.btn-primary");
   ```
 2. **等待元素**
   ```typescript
   // 自动等待
   await expect(page.locator(".modal")).toBeVisible();
   // 手动等待（必要时）
   await page.waitForSelector(".modal", { state: "visible" });
   ```
 3. **截图和视频**
   - 失败时自动截图
   - 失败时自动录制视频
 4. **网络拦截**
   ```typescript
   await page.route("**/api/**", (route) => {
     route.fulfill({
       status: 200,
       body: JSON.stringify(mockData),
     });
   });
   ```
 ## 常见问题
 ### 测试超时
 ```typescript
 test(
  "slow test",
  async () => {
    // 增加超时时间
  },
  { timeout: 10000 },
 );
 ```
 ### 异步测试
 ```typescript
 it("should handle async operation", async () => {
  await someAsyncOperation();
  expect(result).toBe(expected);
 });
 ```
 ### 清理副作用
 ```typescript
 import { afterEach } from "vitest";
 afterEach(() => {
  // 清理 mock
  vi.restoreAllMocks();
  // 清理状态
  downloads.value = [];
 });
 ```
 ---
 **© 2026 APM 应用商店项目**
@@ -1,160 +0,0 @@
 # 问题排查指南
 ## 📋 目录
 - [常见问题](#常见问题)
 - [调试方法](#调试方法)
 - [日志分析](#日志分析)
 - [性能问题](#性能问题)
 ## 常见问题
 ### 应用无法启动
 **症状:** 双击应用图标后无反应
 **可能原因:**
 1. 依赖包未安装
 2. 配置文件损坏
 3. 权限问题
 **解决方法:**
 ```bash
 # 检查日志
 journalctl -u spark-store
 # 重新安装
 sudo dpkg -i spark-store_*.deb
 # 检查依赖
 sudo apt-get install -f
 ```
 ### 安装失败
 **症状:** 点击安装按钮后无响应或报错
 **可能原因:**
 1. APM 未安装
 2. 权限不足
 3. 网络问题
 **解决方法:**
 ```bash
 # 检查 APM 是否安装
 which apm
 # 检查权限
 pkexec --version
 # 查看 APM 日志
 sudo journalctl -u amber-pm
 ```
 ### 下载速度慢
 **症状:** 下载进度缓慢
 **解决方法:**
 1. 检查网络连接
 2. 更换下载源
 3. 使用代理
 ### 主题切换无效
 **症状:** 切换暗色/亮色主题后无变化
 **解决方法:**
 ```bash
 # 清除本地存储
 rm -rf ~/.config/spark-store/
 ```
 ## 调试方法
 ### 主进程调试
 ```bash
 # 使用命令行启动并查看日志
 spark-store --enable-logging
 ```
 ### 渲染进程调试
 1. 打开应用
 2. 按 `Ctrl+Shift+I` 打开 DevTools
 3. 查看 Console 和 Network 标签
 ### IPC 通信调试
 在 `electron/main/index.ts` 中添加日志：
 ```typescript
 ipcMain.on("test-channel", (event, data) => {
  logger.info("IPC received:", data);
 });
 ```
 ## 日志分析
 ### 日志位置
 - **主进程日志:** `~/.config/spark-store/logs/`
 - **系统日志:** `journalctl -u spark-store`
 ### 日志级别
 - `trace`: 最详细
 - `debug`: 调试信息
 - `info`: 一般信息
 - `warn`: 警告
 - `error`: 错误
 - `fatal`: 致命错误
 ### 查看日志
 ```bash
 # 查看最新日志
 tail -f ~/.config/spark-store/logs/main.log
 # 搜索错误
 grep ERROR ~/.config/spark-store/logs/*.log
 ```
 ## 性能问题
 ### 内存占用高
 **检查方法:**
 1. 打开 DevTools → Performance 标签
 2. 录制并分析内存使用
 **优化建议:**
 - 清理不必要的组件
 - 使用虚拟滚动
 - 避免内存泄漏
 ### 启动慢
 **检查方法:**
 1. 查看 DevTools → Network 标签
 2. 检查加载时间
 **优化建议:**
 - 延迟加载非关键资源
 - 优化 API 请求
 - 减少 HTTP 请求数量
 ---
 **© 2026 APM 应用商店项目**
@@ -1,632 +0,0 @@
 # 标准开发流程
 本文档描述在 APM 应用商店项目中完成代码开发后的标准提交流程。
 ## 📋 目录
 - [开发前准备](#开发前准备)
 - [代码完成后](#代码完成后)
 - [提交流程](#提交流程)
 - [典型场景](#典型场景)
 - [提交流程检查清单](#提交流程检查清单)
 - [常见问题](#常见问题)
 ---
 ## 开发前准备
 在开始开发之前，确保你的开发环境已正确配置：
 ```bash
 # 1. 切换到项目目录
 cd apm-app-store
 # 2. 拉取最新代码
 git pull origin main
 # 3. 创建功能分支
 git checkout -b feature/your-feature-name
 # 或修复分支
 git checkout -b fix/your-bug-fix
 # 4. 确保依赖已安装
 npm install
 ```
 ---
 ## 代码完成后
 ### 1️⃣ 运行代码检查
 首先确保代码符合项目规范：
 ```bash
 # 运行 ESLint 检查
 npm run lint
 # 如果有错误，尝试自动修复
 npm run lint:fix
 # 手动修复无法自动处理的问题
 ```
 **ESLint 错误类型：**
 - `@typescript-eslint/no-explicit-any`: 避免使用 `any` 类型
 - `@typescript-eslint/no-unused-vars`: 未使用的变量
 - 其他代码风格问题
 ### 2️⃣ 格式化代码
 使用 Prettier 格式化代码：
 ```bash
 npm run format
 ```
 ### 3️⃣ 运行测试
 确保所有测试通过：
 ```bash
 # 运行单元测试
 npm run test
 # 生成测试覆盖率报告
 npm run test:coverage
 # 运行 E2E 测试（如果需要）
 npm run test:e2e
 # 运行所有测试
 npm run test:all
 ```
 **测试覆盖率要求：**
 - 语句覆盖率: ≥ 70%
 - 分支覆盖率: ≥ 70%
 - 函数覆盖率: ≥ 70%
 - 行覆盖率: ≥ 70%
 ### 4️⃣ 构建验证
 验证代码可以成功构建：
 ```bash
 # 仅构建前端代码（快速）
 npm run build:vite
 ```
 如果构建失败，检查 TypeScript 错误并修复。
 ---
 ## 提交流程
 ### 5️⃣ 提交代码
 #### 查看变更
 ```bash
 # 查看所有变更文件
 git status
 # 查看具体变更
 git diff
 ```
 #### 添加文件
 ```bash
 # 添加所有变更文件
 git add .
 # 或添加特定文件
 git add path/to/file.ts
 ```
 #### 提交信息
 遵循 [Conventional Commits](https://www.conventionalcommits.org/) 规范：
 ```
 type(scope): subject
 [可选的正文]
 [可选的脚注]
 ```
 **Type 类型：**
 - `feat`: 新功能
 - `fix`: Bug 修复
 - `docs`: 文档更新
 - `style`: 代码格式（不影响功能）
 - `refactor`: 重构
 - `perf`: 性能优化
 - `test`: 测试相关
 - `chore`: 构建/工具相关
 **Scope 范围：**
 - `app`: 应用核心
 - `install`: 安装/卸载
 - `ui`: UI 组件
 - `ipc`: IPC 通信
 - `api`: API 集成
 - `theme`: 主题
 - `build`: 构建
 - `docs`: 文档
 **Subject 主题：**
 - 使用现在时态（"add" 而非 "added"）
 - 首字母小写
 - 不以句号结尾
 **示例：**
 ```bash
 # 新功能
 git commit -m "feat(install): add retry mechanism for failed installations" -s
 # Bug 修复
 git commit -m "fix(ui): correct dark mode toggle persistence" -s
 # 文档更新
 git commit -m "docs(readme): update build instructions" -s
 # 重构
 git commit -m "refactor(ipc): simplify install manager event handling" -s
 # 测试
 git commit -m "test(download): add unit tests for download queue" -s
 ```
 **添加签名：**
 ```bash
 # 使用 -s 添加签名
 git commit -m "feat(example): add new feature" -s
 # 或在 ~/.gitconfig 中配置
 # [commit]
 #     gpgsign = true
 ```
 #### 执行提交
 ```bash
 git commit -m "type(scope): description" -s
 ```
 ### 6️⃣ 推送到远程仓库
 ```bash
 # 推送当前分支
 git push origin feature/your-feature-name
 # 或使用简写
 git push -u origin feature/your-feature-name
 ```
 ### 7️⃣ 创建 Pull Request
 #### 访问 GitHub
 1. 访问仓库页面
 2. 点击 "New Pull Request"
 3. 选择你的分支 → main 分支
 #### 填写 PR 模板
 使用 PR 模板填写信息：
 **变更类型：**
 - [ ] `feat` - 新功能
 - [ ] `fix` - Bug 修复
 - [ ] `refactor` - 重构
 - [ ] `docs` - 文档更新
 - [ ] `test` - 测试相关
 - [ ] `chore` - 构建/工具相关
 **变更描述：**
 清晰简洁地说明你做了什么，为什么这么做。
 **相关 Issue：**
 引用相关的 Issue 编号，例如 `Fixes #123` 或 `Closes #123`。
 **测试说明：**
 如何测试这些变更？包括：
 - 测试步骤
 - 预期结果
 - 测试环境
 **截图/录屏：**
 如果涉及 UI 变更，添加截图或录屏。
 **检查清单：**
 - [ ] 代码通过 `npm run lint`
 - [ ] 代码通过 `npm run format`
 - [ ] 所有测试通过 (`npm run test`)
 - [ ] 新功能包含测试
 - [ ] 文档已更新（如需要）
 #### 提交 PR
 点击 "Create Pull Request"。
 ### 8️⃣ 代码审查
 #### 等待审查
 - 至少一位维护者会审查你的 PR
 - CI 会自动运行测试和检查
 - 确保所有 CI 检查通过（绿色 ✅）
 #### 响应审查意见
 - 阅审审查者提出的意见
 - 进行必要的修改
 - 提交更改到你的分支
 - 在 PR 中评论说明修改内容
 #### 更新 PR
 ```bash
 # 修改代码后
 git add .
 git commit -m "address review feedback" -s
 git push origin feature/your-feature-name
 ```
 ### 9️⃣ 合并 PR
 #### 合并条件
 - 至少一次审查批准
 - 所有 CI 检查通过
 - 无冲突
 - 分支最新
 #### 合并方式
 - 使用 "Squash and merge" 将提交压缩为一个
 - 或使用 "Merge commit" 保留提交历史
 #### 删除分支
 合并后删除你的功能分支：
 ```bash
 # 删除本地分支
 git branch -d feature/your-feature-name
 # 删除远程分支
 git push origin --delete feature/your-feature-name
 ```
 ---
 ## 典型场景
 ### 场景 1: 开发新功能
 ```bash
 # 1. 创建功能分支
 git checkout -b feature/add-search-filters
 # 2. 开发代码...
 # （编写代码）
 # 3. 运行检查
 npm run lint
 npm run lint:fix
 npm run format
 npm run test
 # 4. 构建验证
 npm run build:vite
 # 5. 提交代码
 git add .
 git commit -m "feat(search): add advanced search filters with category filtering" -s
 # 6. 推送
 git push -u origin feature/add-search-filters
 # 7. 创建 PR
 # （在 GitHub 上创建 PR）
 ```
 ### 场景 2: 修复 Bug
 ```bash
 # 1. 创建修复分支
 git checkout -b fix/fix-download-timeout
 # 2. 修复代码...
 # 3. 运行检查
 npm run lint
 npm run format
 npm run test
 # 4. 提交代码
 git add .
 git commit -m "fix(download): resolve timeout issue with retry logic" -m "Fixes #123" -s
 # 5. 推送
 git push -u origin fix/fix-download-timeout
 # 6. 创建 PR
 ```
 ### 场景 3: 更新文档
 ```bash
 # 1. 创建文档分支
 git checkout -b docs/update-api-docs
 # 2. 更新文档...
 # 3. 提交代码
 git add .
 git commit -m "docs(api): update installation API documentation" -s
 # 4. 推送
 git push -u origin docs/update-api-docs
 # 5. 创建 PR
 ```
 ### 场景 4: 重构代码
 ```bash
 # 1. 创建重构分支
 git checkout -b refactor/simplify-download-manager
 # 2. 重构代码...
 # 3. 运行检查
 npm run lint
 npm run format
 npm run test
 # 4. 提交代码
 git add .
 git commit -m "refactor(download): simplify download manager event handling" -s
 # 5. 推送
 git push -u origin refactor/simplify-download-manager
 # 6. 创建 PR
 ```
 ---
 ## 提交流程检查清单
 在创建 PR 前，确保完成以下检查：
 ### 代码质量
 - [ ] ESLint 检查通过 (`npm run lint`)
 - [ ] 代码已格式化 (`npm run format`)
 - [ ] 没有 `any` 类型（除非必要并添加注释）
 - [ ] 遵循代码规范（见 [AGENTS.md](./AGENTS.md)）
 - [ ] TypeScript 严格模式通过
 ### 测试
 - [ ] 单元测试通过 (`npm run test`)
 - [ ] 新功能包含测试
 - [ ] 测试覆盖率 ≥ 70%
 - [ ] E2E 测试通过（如需要，`npm run test:e2e`）
 - [ ] 没有测试回归
 ### 文档
 - [ ] 更新了相关文档（如需要）
 - [ ] 更新了 CHANGELOG.md（如需要）
 - [ ] API 文档更新（如需要）
 - [ ] README.md 更新（如需要）
 ### 功能验证
 - [ ] 本地测试通过
 - [ ] 没有引入新 Bug
 - [ ] 边界情况已处理
 - [ ] 错误处理完善
 - [ ] 性能未下降
 ### 提交信息
 - [ ] 遵循 Conventional Commits 规范
 - [ ] 添加了签名（`-s`）
 - [ ] 引用相关 Issue（如适用）
 - [ ] 提交信息清晰明确
 ---
 ## 快速提交命令
 如果你想快速提交所有检查，可以使用以下命令：
 ```bash
 # 完整流程（一行命令）
 npm run lint && npm run format && npm run test && git add . && git commit -m "type(scope): description" -s && git push -u origin $(git branch --show-current)
 ```
 ### 创建便捷脚本
 在 `scripts/` 目录下创建 `commit.sh`:
 ```bash
 #!/bin/bash
 # 检查参数
 if [ -z "$1" ]; then
  echo "❌ 错误: 请提供提交信息"
  echo "使用方法: ./scripts/commit.sh \"type(scope): description\""
  exit 1
 fi
 echo "🔍 Running lint..."
 npm run lint
 if [ $? -ne 0 ]; then
  echo "❌ ESLint 检查失败，请修复错误后重试"
  exit 1
 fi
 echo "🎨 Formatting code..."
 npm run format
 echo "🧪 Running tests..."
 npm run test
 if [ $? -ne 0 ]; then
  echo "❌ 测试失败，请修复测试后重试"
  exit 1
 fi
 echo "📝 Committing changes..."
 git add .
 git commit -m "$1" -s
 if [ $? -ne 0 ]; then
  echo "❌ 提交失败"
  exit 1
 fi
 echo "🚀 Pushing to remote..."
 BRANCH_NAME=$(git branch --show-current)
 git push -u origin $BRANCH_NAME
 if [ $? -ne 0 ]; then
  echo "❌ 推送失败"
  exit 1
 fi
 echo ""
 echo "✅ 提交成功！"
 echo "📌 分支: $BRANCH_NAME"
 echo "📝 提交信息: $1"
 echo "🔗 请创建 Pull Request: https://github.com/elysia-best/apm-app-store/compare/main...$BRANCH_NAME"
 ```
 使用方法：
 ```bash
 # 给脚本添加执行权限
 chmod +x scripts/commit.sh
 # 使用脚本提交
 ./scripts/commit.sh "feat(search): add advanced search filters"
 ```
 ---
 ## 常见问题
 ### Q: ESLint 检查失败怎么办？
 **A:**
 1. 运行 `npm run lint:fix` 自动修复
 2. 手动修复无法自动处理的问题
 3. 如果确实需要使用 `any`，添加 `// eslint-disable-next-line @typescript-eslint/no-explicit-any`
 ### Q: 测试失败怎么办？
 **A:**
 1. 查看测试失败信息
 2. 修复代码或测试
 3. 确保测试覆盖所有情况
 4. 运行 `npm run test` 重新验证
 ### Q: 构建失败怎么办？
 **A:**
 1. 查看 TypeScript 错误
 2. 修复类型错误
 3. 确保类型定义正确
 4. 运行 `npm run build:vite` 重新验证
 ### Q: 如何修复合并冲突？
 **A:**
 ```bash
 # 1. 拉取最新代码
 git fetch origin
 # 2. 合并 main 分支到你的分支
 git merge origin/main
 # 3. 解决冲突
 # （编辑冲突文件，选择正确的代码）
 # 4. 标记冲突已解决
 git add .
 # 5. 提交合并
 git commit -m "merge: resolve conflicts with main" -s
 # 6. 推送
 git push origin feature/your-feature-name
 ```
 ### Q: 如何修改已提交的代码？
 **A:**
 ```bash
 # 1. 修改代码...
 # 2. 添加到暂存区
 git add .
 # 3. 提交到分支
 git commit -m "address review feedback" -s
 # 4. 推送
 git push origin feature/your-feature-name
 ```
 ### Q: 如何撤回错误的提交？
 **A:**
 ```bash
 # 如果还未推送
 git reset --soft HEAD~1
 # 重新提交
 git commit -m "correct message" -s
 # 如果已推送（需要强制推送，谨慎使用）
 git reset --soft HEAD~1
 git commit -m "correct message" -s
 git push origin feature/your-feature-name --force
 ```
 **注意:** 避免在已公开的分支上使用强制推送。
 ---
 ## 📚 相关文档
 - **开发指南:** [DEVELOPMENT.md](./DEVELOPMENT.md)
 - **贡献指南:** [CONTRIBUTING.md](./CONTRIBUTING.md)
 - **测试文档:** [TESTING.md](./TESTING.md)
 - **AI 编码指南:** [AGENTS.md](./AGENTS.md)
 - **部署文档:** [DEPLOYMENT.md](./DEPLOYMENT.md)
 ---
 **© 2026 APM 应用商店项目**
@@ -0,0 +1,42 @@
 #-------------------------------------------------
 #
 # Project created by QtCreator 2019-06-30T12:53:03
 #
 #-------------------------------------------------
 QT       += core gui webkitwidgets network concurrent
 greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
 TARGET = deepin-community-store
 TEMPLATE = app
 # The following define makes your compiler emit warnings if you use
 # any feature of Qt which as been marked as deprecated (the exact warnings
 # depend on your compiler). Please consult the documentation of the
 # deprecated API in order to know how to port your code away from it.
 DEFINES += QT_DEPRECATED_WARNINGS
 # You can also make your code fail to compile if you use deprecated APIs.
 # In order to do so, uncomment the following line.
 # You can also select to disable deprecated APIs only up to a certain version of Qt.
 #DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
 SOURCES += main.cpp\
        mainwindow.cpp \
    widget.cpp \
    downloadlist.cpp
 HEADERS  += mainwindow.h \
    widget.h \
    downloadlist.h
 CONFIG += link_pkgconfig
 PKGCONFIG += dtkwidget
 CONFIG += c++11
 FORMS += \
    widget.ui \
    downloadlist.ui
@@ -1,801 +0,0 @@
 # Update Center Icon Fallback Implementation Plan
 > **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
 **Goal:** Change Electron update-center icons to load in the order `localIcon -> remoteIcon -> placeholder`, so a successful local icon never triggers remote/default loading, but failed local loads still fall through to the remote icon.
 **Architecture:** Split the current single `icon` field into two explicit sources resolved in the main process: `localIcon` and `remoteIcon`. Keep URL/path resolution in `electron/main/backend/update-center/icons.ts`, pass both fields through the service snapshot, and let `UpdateCenterItem.vue` own the runtime fallback state when `img` emits `error`.
 **Tech Stack:** Electron main process, Node.js `fs`/`path`, Vue 3 `<script setup>`, TypeScript strict mode, Vitest, Testing Library Vue.
 ---
 ## File Map
 - Modify: `electron/main/backend/update-center/types.ts` - replace the single update-center icon field with `localIcon` and `remoteIcon`.
 - Modify: `electron/main/backend/update-center/icons.ts` - keep local/remote resolution helpers and return both candidates via `resolveUpdateItemIcons()`.
 - Modify: `electron/main/backend/update-center/index.ts` - enrich loaded update items with the two icon fields instead of one final `icon`.
 - Modify: `electron/main/backend/update-center/service.ts` - expose `localIcon` and `remoteIcon` to renderer item/task snapshots.
 - Modify: `src/global/typedefinition.ts` - update renderer-facing update-center item/task types.
 - Modify: `src/components/update-center/UpdateCenterItem.vue` - render the current icon candidate and advance from local to remote to placeholder on load failures.
 - Modify: `src/__tests__/unit/update-center/icons.test.ts` - verify icon helper output is now `{ localIcon?, remoteIcon? }`.
 - Modify: `src/__tests__/unit/update-center/load-items.test.ts` - verify loaded items receive `remoteIcon` instead of the old `icon` field.
 - Modify: `src/__tests__/unit/update-center/registerUpdateCenter.test.ts` - verify service task snapshots preserve both icon fields.
 - Modify: `src/__tests__/unit/update-center/UpdateCenterItem.test.ts` - verify the renderer fallback order.
 ### Task 1: Split Backend Icon Resolution Into Local And Remote Sources
 **Files:**
 - Modify: `electron/main/backend/update-center/types.ts`
 - Modify: `electron/main/backend/update-center/icons.ts`
 - Test: `src/__tests__/unit/update-center/icons.test.ts`
 - [ ] **Step 1: Write the failing test**
 Replace the single-icon assertions in `src/__tests__/unit/update-center/icons.test.ts` with these four tests:
 ```ts
 it("returns both localIcon and remoteIcon when an aptss desktop icon resolves", async () => {
  const pkgname = "spark-weather";
  const applicationsDirectory = "/usr/share/applications";
  const desktopPath = `${applicationsDirectory}/weather-launcher.desktop`;
  const iconPath = `/usr/share/pixmaps/${pkgname}.png`;
  const { resolveUpdateItemIcons } = await loadIconsModule({
    directories: {
      [applicationsDirectory]: ["weather-launcher.desktop"],
    },
    files: {
      [desktopPath]: `[Desktop Entry]\nName=Spark Weather\nIcon=${iconPath}\n`,
      [iconPath]: "png",
    },
    packageFiles: {
      [pkgname]: [desktopPath],
    },
  });
  expect(
    resolveUpdateItemIcons({
      pkgname,
      source: "aptss",
      currentVersion: "1.0.0",
      nextVersion: "2.0.0",
      category: "tools",
      arch: "amd64",
    }),
  ).toEqual({
    localIcon: iconPath,
    remoteIcon:
      "https://erotica.spark-app.store/amd64-store/tools/spark-weather/icon.png",
  });
 });
 it("returns only remoteIcon when no local icon resolves", async () => {
  const { resolveUpdateItemIcons } = await loadIconsModule({});
  expect(
    resolveUpdateItemIcons({
      pkgname: "spark-clock",
      source: "apm",
      currentVersion: "1.0.0",
      nextVersion: "2.0.0",
      category: "utility",
      arch: "amd64",
    }),
  ).toEqual({
    remoteIcon:
      "https://erotica.spark-app.store/amd64-apm/utility/spark-clock/icon.png",
  });
 });
 it("returns only localIcon when a remote fallback URL cannot be built", async () => {
  const pkgname = "spark-reader";
  const applicationsDirectory = "/usr/share/applications";
  const desktopPath = `${applicationsDirectory}/reader-launcher.desktop`;
  const iconPath = `/usr/share/pixmaps/${pkgname}.png`;
  const { resolveUpdateItemIcons } = await loadIconsModule({
    directories: {
      [applicationsDirectory]: ["reader-launcher.desktop"],
    },
    files: {
      [desktopPath]: `[Desktop Entry]\nName=Spark Reader\nIcon=${iconPath}\n`,
      [iconPath]: "png",
    },
    packageFiles: {
      [pkgname]: [desktopPath],
    },
  });
  expect(
    resolveUpdateItemIcons({
      pkgname,
      source: "aptss",
      currentVersion: "1.0.0",
      nextVersion: "2.0.0",
    }),
  ).toEqual({
    localIcon: iconPath,
  });
 });
 it("returns an empty object when neither local nor remote icons are available", async () => {
  const { resolveUpdateItemIcons } = await loadIconsModule({});
  expect(
    resolveUpdateItemIcons({
      pkgname: "spark-empty",
      source: "aptss",
      currentVersion: "1.0.0",
      nextVersion: "2.0.0",
    }),
  ).toEqual({});
 });
 ```
 - [ ] **Step 2: Run test to verify it fails**
 Run: `npm run test -- --run src/__tests__/unit/update-center/icons.test.ts`
 Expected: FAIL because `resolveUpdateItemIcon()` still returns a string and `resolveUpdateItemIcons()` does not exist yet.
 - [ ] **Step 3: Write minimal implementation**
 Update `electron/main/backend/update-center/types.ts` so the interface defines the two source fields instead of `icon`:
 ```ts
 export interface UpdateCenterItem {
  pkgname: string;
  source: UpdateSource;
  currentVersion: string;
  nextVersion: string;
  arch?: string;
  category?: string;
  localIcon?: string;
  remoteIcon?: string;
  ignored?: boolean;
  downloadUrl?: string;
  fileName?: string;
  size?: number;
  sha512?: string;
  isMigration?: boolean;
  migrationSource?: UpdateSource;
  migrationTarget?: UpdateSource;
  aptssVersion?: string;
 }
 ```
 Replace the old single-result helper at the end of `electron/main/backend/update-center/icons.ts` with this code:
 ```ts
 export interface UpdateItemIcons {
  localIcon?: string;
  remoteIcon?: string;
 }
 export const resolveUpdateItemIcons = (
  item: UpdateCenterItem,
 ): UpdateItemIcons => {
  const localIcon =
    item.source === "aptss"
      ? resolveDesktopIcon(item.pkgname)
      : resolveApmIcon(item.pkgname);
  const remoteIcon =
    buildRemoteFallbackIconUrl({
      pkgname: item.pkgname,
      source: item.source,
      arch: item.arch,
      category: item.category,
    }) || undefined;
  return {
    ...(localIcon ? { localIcon } : {}),
    ...(remoteIcon ? { remoteIcon } : {}),
  };
 };
 ```
 Keep `resolveDesktopIcon()`, `resolveApmIcon()`, and `buildRemoteFallbackIconUrl()` unchanged.
 - [ ] **Step 4: Run test to verify it passes**
 Run: `npm run test -- --run src/__tests__/unit/update-center/icons.test.ts`
 Expected: PASS with the updated icon helper tests green.
 - [ ] **Step 5: Commit**
 ```bash
 git add electron/main/backend/update-center/types.ts electron/main/backend/update-center/icons.ts src/__tests__/unit/update-center/icons.test.ts
 git commit -m "fix(update-center): split local and remote icon sources"
 ```
 ### Task 2: Propagate Icon Sources Through Loaded Items And Service Snapshots
 **Files:**
 - Modify: `electron/main/backend/update-center/index.ts`
 - Modify: `electron/main/backend/update-center/service.ts`
 - Modify: `src/global/typedefinition.ts`
 - Test: `src/__tests__/unit/update-center/load-items.test.ts`
 - Test: `src/__tests__/unit/update-center/registerUpdateCenter.test.ts`
 - [ ] **Step 1: Write the failing tests**
 Update the expected item snapshots in `src/__tests__/unit/update-center/load-items.test.ts` from `icon` to `remoteIcon`:
 ```ts
 expect(result.items).toContainEqual({
  pkgname: "spark-weather",
  source: "apm",
  currentVersion: "1.5.0",
  nextVersion: "3.0.0",
  arch: "amd64",
  category: "tools",
  remoteIcon:
    "https://erotica.spark-app.store/amd64-apm/tools/spark-weather/icon.png",
  downloadUrl: "https://example.invalid/spark-weather_3.0.0_amd64.deb",
  fileName: "spark-weather_3.0.0_amd64.deb",
  size: 123456,
  sha512: "deadbeef",
  isMigration: true,
  migrationSource: "aptss",
  migrationTarget: "apm",
  aptssVersion: "2.0.0",
 });
 ```
 ```ts
 expect(result.items).toEqual([
  {
    pkgname: "spark-notes",
    source: "aptss",
    currentVersion: "1.0.0",
    nextVersion: "2.0.0",
    arch: "amd64",
    category: "office",
    remoteIcon:
      "https://erotica.spark-app.store/amd64-store/office/spark-notes/icon.png",
  },
 ]);
 ```
 ```ts
 expect(secondResult.items).toEqual([
  {
    pkgname: "spark-notes",
    source: "aptss",
    currentVersion: "1.0.0",
    nextVersion: "2.0.0",
    arch: "amd64",
    category: "office",
    remoteIcon:
      "https://erotica.spark-app.store/amd64-store/office/spark-notes/icon.png",
  },
 ]);
 ```
 ```ts
 expect(result.items).toEqual([
  {
    pkgname: "spark-notes",
    source: "aptss",
    currentVersion: "1.0.0",
    nextVersion: "2.0.0",
    arch: "amd64",
    category: "office",
    remoteIcon:
      "https://erotica.spark-app.store/amd64-store/office/spark-notes/icon.png",
  },
 ]);
 ```
 Replace the icon-preservation test in `src/__tests__/unit/update-center/registerUpdateCenter.test.ts` with:
 ```ts
 it("service task snapshots keep localIcon and remoteIcon for queued work", async () => {
  const service = createUpdateCenterService({
    loadItems: async () => [
      {
        ...createItem(),
        localIcon: "/icons/weather.png",
        remoteIcon: "https://example.com/weather.png",
      },
    ],
    createTaskRunner: (queue: UpdateCenterQueue) => ({
      cancelActiveTask: vi.fn(),
      runNextTask: async () => {
        const task = queue.getNextQueuedTask();
        if (!task) {
          return null;
        }
        queue.markActiveTask(task.id, "installing");
        queue.finishTask(task.id, "completed");
        return task;
      },
    }),
  });
  await service.refresh();
  await service.start(["aptss:spark-weather"]);
  expect(service.getState().tasks).toMatchObject([
    {
      taskKey: "aptss:spark-weather",
      localIcon: "/icons/weather.png",
      remoteIcon: "https://example.com/weather.png",
      status: "completed",
    },
  ]);
 });
 ```
 - [ ] **Step 2: Run tests to verify they fail**
 Run: `npm run test -- --run src/__tests__/unit/update-center/load-items.test.ts src/__tests__/unit/update-center/registerUpdateCenter.test.ts`
 Expected: FAIL because the loader and service snapshots still publish `icon` instead of `localIcon` / `remoteIcon`.
 - [ ] **Step 3: Write minimal implementation**
 Update the icon enrichment function in `electron/main/backend/update-center/index.ts`:
 ```ts
 import { resolveUpdateItemIcons } from "./icons";
 const enrichItemIcons = (items: UpdateCenterItem[]): UpdateCenterItem[] => {
  return items.map((item) => {
    const { localIcon, remoteIcon } = resolveUpdateItemIcons(item);
    if (!localIcon && !remoteIcon) {
      return item;
    }
    return {
      ...item,
      ...(localIcon ? { localIcon } : {}),
      ...(remoteIcon ? { remoteIcon } : {}),
    };
  });
 };
 ```
 Update the renderer-facing item/task types and `toState()` mapping in `electron/main/backend/update-center/service.ts`:
 ```ts
 export interface UpdateCenterServiceItem {
  taskKey: string;
  packageName: string;
  displayName: string;
  currentVersion: string;
  newVersion: string;
  source: UpdateSource;
  localIcon?: string;
  remoteIcon?: string;
  ignored?: boolean;
  downloadUrl?: string;
  fileName?: string;
  size?: number;
  sha512?: string;
  isMigration?: boolean;
  migrationSource?: UpdateSource;
  migrationTarget?: UpdateSource;
  aptssVersion?: string;
 }
 export interface UpdateCenterServiceTask {
  taskKey: string;
  packageName: string;
  source: UpdateSource;
  localIcon?: string;
  remoteIcon?: string;
  status: UpdateCenterQueueSnapshot["tasks"][number]["status"];
  progress: number;
  logs: UpdateCenterQueueSnapshot["tasks"][number]["logs"];
  errorMessage: string;
 }
 const toState = (
  snapshot: UpdateCenterQueueSnapshot,
 ): UpdateCenterServiceState => ({
  items: snapshot.items.map((item) => ({
    taskKey: getTaskKey(item),
    packageName: item.pkgname,
    displayName: item.pkgname,
    currentVersion: item.currentVersion,
    newVersion: item.nextVersion,
    source: item.source,
    localIcon: item.localIcon,
    remoteIcon: item.remoteIcon,
    ignored: item.ignored,
    downloadUrl: item.downloadUrl,
    fileName: item.fileName,
    size: item.size,
    sha512: item.sha512,
    isMigration: item.isMigration,
    migrationSource: item.migrationSource,
    migrationTarget: item.migrationTarget,
    aptssVersion: item.aptssVersion,
  })),
  tasks: snapshot.tasks.map((task) => ({
    taskKey: getTaskKey(task.item),
    packageName: task.pkgname,
    source: task.item.source,
    localIcon: task.item.localIcon,
    remoteIcon: task.item.remoteIcon,
    status: task.status,
    progress: task.progress,
    logs: task.logs.map((log) => ({ ...log })),
    errorMessage: task.error ?? "",
  })),
  warnings: [...snapshot.warnings],
  hasRunningTasks: snapshot.hasRunningTasks,
 });
 ```
 Update the update-center renderer types in `src/global/typedefinition.ts`:
 ```ts
 export interface UpdateCenterItem {
  taskKey: string;
  packageName: string;
  displayName: string;
  currentVersion: string;
  newVersion: string;
  source: UpdateSource;
  localIcon?: string;
  remoteIcon?: string;
  ignored?: boolean;
  downloadUrl?: string;
  fileName?: string;
  size?: number;
  sha512?: string;
  isMigration?: boolean;
  migrationSource?: UpdateSource;
  migrationTarget?: UpdateSource;
  aptssVersion?: string;
 }
 export interface UpdateCenterTaskState {
  taskKey: string;
  packageName: string;
  source: UpdateSource;
  localIcon?: string;
  remoteIcon?: string;
  status: UpdateCenterTaskStatus;
  progress: number;
  logs: Array<{ time: number; message: string }>;
  errorMessage: string;
 }
 ```
 - [ ] **Step 4: Run tests to verify they pass**
 Run: `npm run test -- --run src/__tests__/unit/update-center/load-items.test.ts src/__tests__/unit/update-center/registerUpdateCenter.test.ts`
 Expected: PASS with the loader and service tests green.
 - [ ] **Step 5: Commit**
 ```bash
 git add electron/main/backend/update-center/index.ts electron/main/backend/update-center/service.ts src/global/typedefinition.ts src/__tests__/unit/update-center/load-items.test.ts src/__tests__/unit/update-center/registerUpdateCenter.test.ts
 git commit -m "refactor(update-center): propagate icon fallback fields"
 ```
 ### Task 3: Implement Renderer Fallback Order In UpdateCenterItem.vue
 **Files:**
 - Modify: `src/components/update-center/UpdateCenterItem.vue`
 - Test: `src/__tests__/unit/update-center/UpdateCenterItem.test.ts`
 - [ ] **Step 1: Write the failing test**
 Replace the contents of `src/__tests__/unit/update-center/UpdateCenterItem.test.ts` with:
 ```ts
 import { fireEvent, render, screen } from "@testing-library/vue";
 import { describe, expect, it } from "vitest";
 import UpdateCenterItem from "@/components/update-center/UpdateCenterItem.vue";
 import type {
  UpdateCenterItem as UpdateCenterItemData,
  UpdateCenterTaskState,
 } from "@/global/typedefinition";
 const createItem = (
  overrides: Partial<UpdateCenterItemData> = {},
 ): UpdateCenterItemData => ({
  taskKey: "aptss:spark-weather",
  packageName: "spark-weather",
  displayName: "Spark Weather",
  currentVersion: "1.0.0",
  newVersion: "2.0.0",
  source: "aptss",
  ...overrides,
 });
 const createTask = (
  overrides: Partial<UpdateCenterTaskState> = {},
 ): UpdateCenterTaskState => ({
  taskKey: "aptss:spark-weather",
  packageName: "spark-weather",
  source: "aptss",
  status: "downloading",
  progress: 42,
  logs: [],
  errorMessage: "",
  ...overrides,
 });
 describe("UpdateCenterItem", () => {
  it("renders localIcon first when both icon sources exist", () => {
    render(UpdateCenterItem, {
      props: {
        item: createItem({
          localIcon: "/usr/share/pixmaps/spark-weather.png",
          remoteIcon: "https://example.com/spark-weather.png",
        }),
        task: createTask(),
        selected: false,
      },
    });
    const icon = screen.getByRole("img", { name: "Spark Weather 图标" });
    expect(icon).toHaveAttribute(
      "src",
      "file:///usr/share/pixmaps/spark-weather.png",
    );
  });
  it("falls back to remoteIcon when localIcon fails", async () => {
    render(UpdateCenterItem, {
      props: {
        item: createItem({
          localIcon: "/usr/share/pixmaps/spark-weather.png",
          remoteIcon: "https://example.com/spark-weather.png",
        }),
        task: createTask(),
        selected: false,
      },
    });
    const icon = screen.getByRole("img", { name: "Spark Weather 图标" });
    await fireEvent.error(icon);
    expect(icon).toHaveAttribute(
      "src",
      "https://example.com/spark-weather.png",
    );
  });
  it("falls back to the placeholder after localIcon and remoteIcon both fail", async () => {
    render(UpdateCenterItem, {
      props: {
        item: createItem({
          localIcon: "/usr/share/pixmaps/spark-weather.png",
          remoteIcon: "https://example.com/spark-weather.png",
        }),
        task: createTask(),
        selected: false,
      },
    });
    const icon = screen.getByRole("img", { name: "Spark Weather 图标" });
    await fireEvent.error(icon);
    await fireEvent.error(icon);
    expect(icon.getAttribute("src")).toContain("data:image/svg+xml");
    expect(icon.getAttribute("src")).not.toContain(
      "https://example.com/spark-weather.png",
    );
  });
  it("restarts from localIcon when a new item is rendered", async () => {
    const { rerender } = render(UpdateCenterItem, {
      props: {
        item: createItem({
          localIcon: "/usr/share/pixmaps/spark-weather.png",
          remoteIcon: "https://example.com/spark-weather.png",
        }),
        task: createTask(),
        selected: false,
      },
    });
    const firstIcon = screen.getByRole("img", { name: "Spark Weather 图标" });
    await fireEvent.error(firstIcon);
    expect(firstIcon).toHaveAttribute(
      "src",
      "https://example.com/spark-weather.png",
    );
    await rerender({
      item: createItem({
        taskKey: "aptss:spark-clock",
        packageName: "spark-clock",
        displayName: "Spark Clock",
        localIcon: "/usr/share/pixmaps/spark-clock.png",
        remoteIcon: "https://example.com/spark-clock.png",
      }),
      task: createTask({
        taskKey: "aptss:spark-clock",
        packageName: "spark-clock",
      }),
      selected: false,
    });
    const nextIcon = screen.getByRole("img", { name: "Spark Clock 图标" });
    expect(nextIcon).toHaveAttribute(
      "src",
      "file:///usr/share/pixmaps/spark-clock.png",
    );
  });
 });
 ```
 - [ ] **Step 2: Run test to verify it fails**
 Run: `npm run test -- --run src/__tests__/unit/update-center/UpdateCenterItem.test.ts`
 Expected: FAIL because the component still reads `item.icon` and goes straight from a single failed image to the placeholder.
 - [ ] **Step 3: Write minimal implementation**
 Replace the `<script setup>` block in `src/components/update-center/UpdateCenterItem.vue` with:
 ```ts
 <script setup lang="ts">
 import { computed, ref, watch } from "vue";
 import type {
  UpdateCenterItem,
  UpdateCenterTaskState,
 } from "@/global/typedefinition";
 const props = defineProps<{
  item: UpdateCenterItem;
  task?: UpdateCenterTaskState;
  selected: boolean;
 }>();
 const PLACEHOLDER_ICON =
  'data:image/svg+xml,%3Csvg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48"%3E%3Crect width="48" height="48" rx="12" fill="%23e2e8f0"/%3E%3Cpath d="M17 31h14v2H17zm3-12h8a2 2 0 0 1 2 2v8H18v-8a2 2 0 0 1 2-2" fill="%2394a3b8"/%3E%3C/svg%3E';
 const currentIconIndex = ref(0);
 const allCandidatesFailed = ref(false);
 defineEmits<{
  (e: "toggle-selection"): void;
 }>();
 const normalizeIconSrc = (icon: string): string => {
  if (/^[a-z]+:\/\//i.test(icon)) {
    return icon;
  }
  return icon.startsWith("/") ? `file://${icon}` : icon;
 };
 const iconCandidates = computed(() => {
  return [props.item.localIcon, props.item.remoteIcon]
    .filter((icon): icon is string => Boolean(icon && icon.trim().length > 0))
    .map((icon) => normalizeIconSrc(icon));
 });
 const resetIconFallback = () => {
  currentIconIndex.value = 0;
  allCandidatesFailed.value = false;
 };
 const handleIconError = () => {
  if (currentIconIndex.value < iconCandidates.value.length - 1) {
    currentIconIndex.value += 1;
    return;
  }
  allCandidatesFailed.value = true;
 };
 watch(
  () => props.item,
  () => {
    resetIconFallback();
  },
 );
 const iconSrc = computed(() => {
  if (allCandidatesFailed.value || iconCandidates.value.length === 0) {
    return PLACEHOLDER_ICON;
  }
  return iconCandidates.value[currentIconIndex.value] ?? PLACEHOLDER_ICON;
 });
 const sourceLabel = computed(() => {
  return props.item.source === "apm" ? "APM" : "传统deb";
 });
 const statusLabel = computed(() => {
  switch (props.task?.status) {
    case "downloading":
      return "下载中";
    case "installing":
      return "安装中";
    case "completed":
      return "已完成";
    case "failed":
      return "失败";
    case "cancelled":
      return "已取消";
    default:
      return "待处理";
  }
 });
 const showProgress = computed(() => {
  return (
    props.task?.status === "downloading" || props.task?.status === "installing"
  );
 });
 const progressText = computed(() => `${props.task?.progress ?? 0}%`);
 const progressStyle = computed(() => ({ width: progressText.value }));
 </script>
 ```
 - [ ] **Step 4: Run test to verify it passes**
 Run: `npm run test -- --run src/__tests__/unit/update-center/UpdateCenterItem.test.ts`
 Expected: PASS with all fallback-order component tests green.
 - [ ] **Step 5: Commit**
 ```bash
 git add src/components/update-center/UpdateCenterItem.vue src/__tests__/unit/update-center/UpdateCenterItem.test.ts
 git commit -m "fix(update-center): cascade icon fallback in renderer"
 ```
 ### Task 4: Verify The Full Change Set
 **Files:**
 - Verify only: `electron/main/backend/update-center/types.ts`
 - Verify only: `electron/main/backend/update-center/icons.ts`
 - Verify only: `electron/main/backend/update-center/index.ts`
 - Verify only: `electron/main/backend/update-center/service.ts`
 - Verify only: `src/global/typedefinition.ts`
 - Verify only: `src/components/update-center/UpdateCenterItem.vue`
 - Verify only: `src/__tests__/unit/update-center/icons.test.ts`
 - Verify only: `src/__tests__/unit/update-center/load-items.test.ts`
 - Verify only: `src/__tests__/unit/update-center/registerUpdateCenter.test.ts`
 - Verify only: `src/__tests__/unit/update-center/UpdateCenterItem.test.ts`
 - [ ] **Step 1: Run the focused update-center test suite**
 Run: `npm run test -- --run src/__tests__/unit/update-center/icons.test.ts src/__tests__/unit/update-center/load-items.test.ts src/__tests__/unit/update-center/registerUpdateCenter.test.ts src/__tests__/unit/update-center/UpdateCenterItem.test.ts`
 Expected: PASS with all four update-center suites green.
 - [ ] **Step 2: Run the formatter**
 Run: `npm run format`
 Expected: command exits 0 after formatting the touched files.
 - [ ] **Step 3: Run lint**
 Run: `npm run lint`
 Expected: PASS with no ESLint or Prettier violations.
 - [ ] **Step 4: Run the production build**
 Run: `npm run build`
 Expected: PASS with Vite/Electron build output generated successfully and no TypeScript errors.
@@ -1,674 +0,0 @@
 # Update Center Icons Implementation Plan
 > **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
 **Goal:** Add icons to the Electron update-center list using local icon resolution first, remote URL fallback second, and a frontend placeholder last.
 **Architecture:** Add a focused `icons.ts` helper in the update-center backend to resolve icon paths/URLs while loading update items, then pass the single `icon` field through the service snapshot into the renderer. Keep the Vue side minimal by rendering a fixed icon slot in `UpdateCenterItem.vue` and falling back to a placeholder icon on `img` load failure.
 **Tech Stack:** Electron main process, Node.js `fs`/`path`, Vue 3 `<script setup>`, Tailwind CSS 4, Vitest, Testing Library Vue, TypeScript strict mode.
 ---
 ## File Map
 - Create: `electron/main/backend/update-center/icons.ts` — resolves update-item icons from local desktop/APM metadata and remote fallback URLs.
 - Modify: `electron/main/backend/update-center/types.ts` — add backend `icon?: string` field.
 - Modify: `electron/main/backend/update-center/index.ts` — enrich loaded update items with resolved icons.
 - Modify: `electron/main/backend/update-center/service.ts` — expose `icon` in renderer-facing snapshots.
 - Modify: `src/global/typedefinition.ts` — add renderer-facing `icon?: string` field.
 - Modify: `src/components/update-center/UpdateCenterItem.vue` — render icon slot and placeholder fallback.
 - Test: `src/__tests__/unit/update-center/icons.test.ts` — backend icon-resolution tests.
 - Modify: `src/__tests__/unit/update-center/load-items.test.ts` — verify loaded update items include icon data when available.
 - Create: `src/__tests__/unit/update-center/UpdateCenterItem.test.ts` — component-level icon rendering and fallback tests.
 ### Task 1: Add Backend Icon Resolution Helpers
 **Files:**
 - Create: `electron/main/backend/update-center/icons.ts`
 - Modify: `electron/main/backend/update-center/types.ts`
 - Test: `src/__tests__/unit/update-center/icons.test.ts`
 - [ ] **Step 1: Write the failing test**
 ```ts
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import {
  buildRemoteFallbackIconUrl,
  resolveApmIcon,
  resolveDesktopIcon,
 } from "../../../../electron/main/backend/update-center/icons";
 describe("update-center icons", () => {
  beforeEach(() => {
    vi.restoreAllMocks();
  });
  it("prefers local desktop icon paths for aptss items", () => {
    const existsSync = vi.spyOn(require("node:fs"), "existsSync");
    const readdirSync = vi.spyOn(require("node:fs"), "readdirSync");
    const readFileSync = vi.spyOn(require("node:fs"), "readFileSync");
    existsSync.mockImplementation((target) =>
      String(target).includes("/usr/share/applications"),
    );
    readdirSync.mockReturnValue(["spark-weather.desktop"]);
    readFileSync.mockReturnValue(
      "Name=Spark Weather\nIcon=/usr/share/icons/hicolor/128x128/apps/spark-weather.png\n",
    );
    expect(resolveDesktopIcon("spark-weather")).toBe(
      "/usr/share/icons/hicolor/128x128/apps/spark-weather.png",
    );
  });
  it("resolves APM icon names from entries/icons when desktop icon is not absolute", () => {
    const existsSync = vi.spyOn(require("node:fs"), "existsSync");
    const readdirSync = vi.spyOn(require("node:fs"), "readdirSync");
    const readFileSync = vi.spyOn(require("node:fs"), "readFileSync");
    existsSync.mockImplementation(
      (target) =>
        String(target).includes(
          "/var/lib/apm/apm/files/ace-env/var/lib/apm/com.qihoo.360zip/entries/icons/hicolor/48x48/apps/360zip.png",
        ) ||
        String(target).includes(
          "/var/lib/apm/apm/files/ace-env/var/lib/apm/com.qihoo.360zip/entries/applications",
        ),
    );
    readdirSync.mockReturnValue(["360zip.desktop"]);
    readFileSync.mockReturnValue("Name=360压缩\nIcon=360zip\n");
    expect(resolveApmIcon("com.qihoo.360zip")).toBe(
      "/var/lib/apm/apm/files/ace-env/var/lib/apm/com.qihoo.360zip/entries/icons/hicolor/48x48/apps/360zip.png",
    );
  });
  it("builds a remote fallback URL when category and arch are available", () => {
    expect(
      buildRemoteFallbackIconUrl({
        pkgname: "spark-weather",
        source: "aptss",
        arch: "amd64",
        category: "network",
      }),
    ).toBe(
      "https://erotica.spark-app.store/amd64-store/network/spark-weather/icon.png",
    );
  });
  it("returns empty string when neither local nor remote icon can be determined", () => {
    expect(
      buildRemoteFallbackIconUrl({
        pkgname: "spark-weather",
        source: "aptss",
        arch: "amd64",
      }),
    ).toBe("");
  });
 });
 ```
 - [ ] **Step 2: Run test to verify it fails**
 Run: `npm run test -- --run src/__tests__/unit/update-center/icons.test.ts`
 Expected: FAIL with `Cannot find module '../../../../electron/main/backend/update-center/icons'`.
 - [ ] **Step 3: Write minimal implementation**
 ```ts
 // electron/main/backend/update-center/types.ts
 export interface UpdateCenterItem {
  pkgname: string;
  source: UpdateSource;
  currentVersion: string;
  nextVersion: string;
  icon?: string;
  ignored?: boolean;
  downloadUrl?: string;
  fileName?: string;
  size?: number;
  sha512?: string;
  isMigration?: boolean;
  migrationSource?: UpdateSource;
  migrationTarget?: UpdateSource;
  aptssVersion?: string;
 }
 ```
 ```ts
 // electron/main/backend/update-center/icons.ts
 import fs from "node:fs";
 import path from "node:path";
 const APM_STORE_BASE_URL = "https://erotica.spark-app.store";
 const APM_BASE_PATH = "/var/lib/apm/apm/files/ace-env/var/lib/apm";
 export const resolveDesktopIcon = (pkgname: string): string => {
  const desktopRoots = [
    "/usr/share/applications",
    `/opt/apps/${pkgname}/entries/applications`,
  ];
  for (const root of desktopRoots) {
    if (!fs.existsSync(root)) continue;
    for (const file of fs.readdirSync(root)) {
      if (!file.endsWith(".desktop")) continue;
      const content = fs.readFileSync(path.join(root, file), "utf8");
      const match = content.match(/^Icon=(.+)$/m);
      if (!match) continue;
      const iconValue = match[1].trim();
      if (iconValue.startsWith("/")) return iconValue;
    }
  }
  return "";
 };
 export const resolveApmIcon = (pkgname: string): string => {
  const entriesPath = path.join(
    APM_BASE_PATH,
    pkgname,
    "entries",
    "applications",
  );
  if (!fs.existsSync(entriesPath)) return "";
  for (const file of fs.readdirSync(entriesPath)) {
    if (!file.endsWith(".desktop")) continue;
    const content = fs.readFileSync(path.join(entriesPath, file), "utf8");
    const match = content.match(/^Icon=(.+)$/m);
    if (!match) continue;
    const iconValue = match[1].trim();
    if (iconValue.startsWith("/")) return iconValue;
    const iconPath = path.join(
      APM_BASE_PATH,
      pkgname,
      "entries",
      "icons",
      "hicolor",
      "48x48",
      "apps",
      `${iconValue}.png`,
    );
    if (fs.existsSync(iconPath)) return iconPath;
  }
  return "";
 };
 export const buildRemoteFallbackIconUrl = (input: {
  pkgname: string;
  source: "aptss" | "apm";
  arch: string;
  category?: string;
 }): string => {
  if (!input.category) return "";
  const finalArch =
    input.source === "aptss" ? `${input.arch}-store` : `${input.arch}-apm`;
  return `${APM_STORE_BASE_URL}/${finalArch}/${input.category}/${input.pkgname}/icon.png`;
 };
 export const resolveUpdateItemIcon = (item: {
  pkgname: string;
  source: "aptss" | "apm";
  arch?: string;
  category?: string;
 }): string => {
  const localIcon =
    item.source === "apm"
      ? resolveApmIcon(item.pkgname)
      : resolveDesktopIcon(item.pkgname);
  if (localIcon) {
    return localIcon;
  }
  if (!item.arch) {
    return "";
  }
  return buildRemoteFallbackIconUrl({
    pkgname: item.pkgname,
    source: item.source,
    arch: item.arch,
    category: item.category,
  });
 };
 ```
 - [ ] **Step 4: Run test to verify it passes**
 Run: `npm run test -- --run src/__tests__/unit/update-center/icons.test.ts`
 Expected: PASS with 4 tests passed.
 - [ ] **Step 5: Commit**
 ```bash
 git add electron/main/backend/update-center/types.ts electron/main/backend/update-center/icons.ts src/__tests__/unit/update-center/icons.test.ts
 git commit -m "feat(update-center): add icon resolution helpers"
 ```
 ### Task 2: Enrich Loaded Update Items with Icons
 **Files:**
 - Modify: `electron/main/backend/update-center/index.ts`
 - Modify: `electron/main/backend/update-center/service.ts`
 - Modify: `src/global/typedefinition.ts`
 - Modify: `src/__tests__/unit/update-center/load-items.test.ts`
 - [ ] **Step 1: Write the failing test**
 ```ts
 import { describe, expect, it, vi } from "vitest";
 vi.mock("../../../../electron/main/backend/update-center/icons", () => ({
  resolveUpdateItemIcon: vi.fn((item) =>
    item.pkgname === "spark-weather"
      ? "/usr/share/icons/hicolor/128x128/apps/spark-weather.png"
      : "",
  ),
 }));
 import { loadUpdateCenterItems } from "../../../../electron/main/backend/update-center";
 describe("update-center load items", () => {
  it("adds icon data to loaded update items", async () => {
    const result = await loadUpdateCenterItems(async (command, args) => {
      const key = `${command} ${args.join(" ")}`;
      if (key.includes("list --upgradable")) {
        return {
          code: 0,
          stdout: "spark-weather/stable 2.0.0 amd64 [upgradable from: 1.0.0]",
          stderr: "",
        };
      }
      if (key.includes("dpkg-query")) {
        return {
          code: 0,
          stdout: "spark-weather\tinstall ok installed\n",
          stderr: "",
        };
      }
      return { code: 0, stdout: "", stderr: "" };
    });
    expect(result.items).toContainEqual(
      expect.objectContaining({
        pkgname: "spark-weather",
        icon: "/usr/share/icons/hicolor/128x128/apps/spark-weather.png",
      }),
    );
  });
 });
 ```
 - [ ] **Step 2: Run test to verify it fails**
 Run: `npm run test -- --run src/__tests__/unit/update-center/load-items.test.ts`
 Expected: FAIL because loaded items do not yet include `icon`.
 - [ ] **Step 3: Write minimal implementation**
 ```ts
 // electron/main/backend/update-center/index.ts
 import { resolveUpdateItemIcon } from "./icons";
 const withResolvedIcons = (items: UpdateCenterItem[]): UpdateCenterItem[] => {
  return items.map((item) => ({
    ...item,
    icon: resolveUpdateItemIcon(item),
  }));
 };
 export const loadUpdateCenterItems = async (
  runCommand: UpdateCenterCommandRunner = runCommandCapture,
 ): Promise<UpdateCenterLoadItemsResult> => {
  const [aptssResult, apmResult, aptssInstalledResult, apmInstalledResult] =
    await Promise.all([
      runCommand(
        APTSS_LIST_UPGRADABLE_COMMAND.command,
        APTSS_LIST_UPGRADABLE_COMMAND.args,
      ),
      runCommand("apm", ["list", "--upgradable"]),
      runCommand(
        DPKG_QUERY_INSTALLED_COMMAND.command,
        DPKG_QUERY_INSTALLED_COMMAND.args,
      ),
      runCommand("apm", ["list", "--installed"]),
    ]);
  const warnings = [
    getCommandError("aptss upgradable query", aptssResult),
    getCommandError("apm upgradable query", apmResult),
    getCommandError("dpkg installed query", aptssInstalledResult),
    getCommandError("apm installed query", apmInstalledResult),
  ].filter((message): message is string => message !== null);
  const aptssItems =
    aptssResult.code === 0
      ? parseAptssUpgradableOutput(aptssResult.stdout)
      : [];
  const apmItems =
    apmResult.code === 0 ? parseApmUpgradableOutput(apmResult.stdout) : [];
  if (aptssResult.code !== 0 && apmResult.code !== 0) {
    throw new Error(warnings.join("; "));
  }
  const installedSources = buildInstalledSourceMap(
    aptssInstalledResult.code === 0 ? aptssInstalledResult.stdout : "",
    apmInstalledResult.code === 0 ? apmInstalledResult.stdout : "",
  );
  const enrichedApmItems = await enrichApmItems(apmItems, runCommand);
  return {
    items: withResolvedIcons(
      mergeUpdateSources(aptssItems, enrichedApmItems.items, installedSources),
    ),
    warnings: [...warnings, ...enrichedApmItems.warnings],
  };
 };
 ```
 ```ts
 // electron/main/backend/update-center/service.ts
 const toState = (
  snapshot: UpdateCenterQueueSnapshot,
 ): UpdateCenterServiceState => ({
  items: snapshot.items.map((item) => ({
    taskKey: getTaskKey(item),
    packageName: item.pkgname,
    displayName: item.pkgname,
    currentVersion: item.currentVersion,
    newVersion: item.nextVersion,
    source: item.source,
    icon: item.icon,
    ignored: item.ignored,
    downloadUrl: item.downloadUrl,
    fileName: item.fileName,
    size: item.size,
    sha512: item.sha512,
    isMigration: item.isMigration,
    migrationSource: item.migrationSource,
    migrationTarget: item.migrationTarget,
    aptssVersion: item.aptssVersion,
  })),
  tasks: snapshot.tasks.map((task) => ({
    taskKey: getTaskKey(task.item),
    packageName: task.pkgname,
    source: task.item.source,
    status: task.status,
    progress: task.progress,
    logs: task.logs.map((log) => ({ ...log })),
    errorMessage: task.error ?? "",
  })),
  warnings: [...snapshot.warnings],
  hasRunningTasks: snapshot.hasRunningTasks,
 });
 ```
 ```ts
 // src/global/typedefinition.ts
 export interface UpdateCenterItem {
  taskKey: string;
  packageName: string;
  displayName: string;
  currentVersion: string;
  newVersion: string;
  source: UpdateSource;
  icon?: string;
  ignored?: boolean;
  downloadUrl?: string;
  fileName?: string;
  size?: number;
  sha512?: string;
  isMigration?: boolean;
  migrationSource?: UpdateSource;
  migrationTarget?: UpdateSource;
  aptssVersion?: string;
 }
 ```
 - [ ] **Step 4: Run test to verify it passes**
 Run: `npm run test -- --run src/__tests__/unit/update-center/load-items.test.ts`
 Expected: PASS with icon assertions included.
 - [ ] **Step 5: Commit**
 ```bash
 git add electron/main/backend/update-center/index.ts electron/main/backend/update-center/service.ts src/global/typedefinition.ts src/__tests__/unit/update-center/load-items.test.ts
 git commit -m "feat(update-center): pass resolved icons to renderer"
 ```
 ### Task 3: Render Update-List Icons with Placeholder Fallback
 **Files:**
 - Modify: `src/components/update-center/UpdateCenterItem.vue`
 - Create: `src/__tests__/unit/update-center/UpdateCenterItem.test.ts`
 - [ ] **Step 1: Write the failing test**
 ```ts
 import { fireEvent, render, screen } from "@testing-library/vue";
 import { describe, expect, it } from "vitest";
 import UpdateCenterItem from "@/components/update-center/UpdateCenterItem.vue";
 const item = {
  taskKey: "aptss:spark-weather",
  packageName: "spark-weather",
  displayName: "Spark Weather",
  currentVersion: "1.0.0",
  newVersion: "2.0.0",
  source: "aptss" as const,
  icon: "/usr/share/icons/hicolor/128x128/apps/spark-weather.png",
 };
 describe("UpdateCenterItem", () => {
  it("renders an icon image when item.icon exists", () => {
    render(UpdateCenterItem, {
      props: { item, selected: false },
    });
    const image = screen.getByRole("img", { name: "Spark Weather 图标" });
    expect(image.getAttribute("src")).toBe(
      "file:///usr/share/icons/hicolor/128x128/apps/spark-weather.png",
    );
  });
  it("falls back to a placeholder icon when the image fails", async () => {
    render(UpdateCenterItem, {
      props: { item, selected: false },
    });
    const image = screen.getByRole("img", { name: "Spark Weather 图标" });
    await fireEvent.error(image);
    expect(screen.getByTestId("update-center-icon-fallback")).toBeTruthy();
  });
 });
 ```
 - [ ] **Step 2: Run test to verify it fails**
 Run: `npm run test -- --run src/__tests__/unit/update-center/UpdateCenterItem.test.ts`
 Expected: FAIL because `UpdateCenterItem.vue` does not render icon markup yet.
 - [ ] **Step 3: Write minimal implementation**
 ```vue
 <!-- src/components/update-center/UpdateCenterItem.vue -->
 <template>
  <label
    class="flex flex-col gap-4 rounded-2xl border border-slate-200/70 bg-white/90 p-4 shadow-sm dark:border-slate-800/70 dark:bg-slate-900/70"
  >
    <div class="flex items-start gap-3">
      <input
        type="checkbox"
        class="mt-1 h-4 w-4 rounded border-slate-300 accent-brand focus:ring-brand"
        :checked="selected"
        :disabled="item.ignored === true"
        @change="$emit('toggle-selection')"
      />
      <div
        class="flex h-10 w-10 shrink-0 items-center justify-center rounded-xl bg-slate-100 dark:bg-slate-800"
      >
        <img
          v-if="resolvedIcon && !iconFailed"
          :src="resolvedIcon"
          :alt="`${item.displayName} 图标`"
          class="h-8 w-8 object-contain"
          @error="iconFailed = true"
        />
        <i
          v-else
          data-testid="update-center-icon-fallback"
          class="fas fa-cube text-lg text-slate-400"
        ></i>
      </div>
      <div class="min-w-0 flex-1">
        <div class="flex flex-wrap items-center gap-2">
          <p class="font-semibold text-slate-900 dark:text-white">
            {{ item.displayName }}
          </p>
          <span
            class="rounded-full bg-slate-100 px-2.5 py-1 text-xs font-semibold text-slate-600 dark:bg-slate-800 dark:text-slate-200"
          >
            {{ sourceLabel }}
          </span>
          <span
            v-if="item.isMigration"
            class="rounded-full bg-brand/10 px-2.5 py-1 text-xs font-semibold text-brand"
          >
            将迁移到 APM
          </span>
          <span
            v-if="item.ignored === true"
            class="rounded-full bg-slate-200 px-2.5 py-1 text-xs font-semibold text-slate-500 dark:bg-slate-800 dark:text-slate-300"
          >
            已忽略
          </span>
        </div>
        <p class="mt-1 text-sm text-slate-500 dark:text-slate-400">
          {{ item.packageName }} · 当前 {{ item.currentVersion }} · 更新至
          {{ item.newVersion }}
        </p>
        <p
          v-if="item.ignored === true"
          class="mt-2 text-xs font-medium text-slate-500 dark:text-slate-400"
        >
          已忽略的更新不会加入本次任务。
        </p>
      </div>
      <div
        v-if="task"
        class="text-right text-sm font-semibold text-slate-600 dark:text-slate-300"
      >
        <p>{{ statusLabel }}</p>
        <p v-if="showProgress" class="mt-1">{{ progressText }}</p>
      </div>
    </div>
    <div v-if="showProgress" class="space-y-2">
      <div
        class="h-2 overflow-hidden rounded-full bg-slate-200 dark:bg-slate-800"
      >
        <div
          class="h-full rounded-full bg-gradient-to-r from-brand to-brand-dark"
          :style="progressStyle"
        ></div>
      </div>
    </div>
  </label>
 </template>
 <script setup lang="ts">
 import { computed, ref } from "vue";
 import type {
  UpdateCenterItem,
  UpdateCenterTaskState,
 } from "@/global/typedefinition";
 const props = defineProps<{
  item: UpdateCenterItem;
  task?: UpdateCenterTaskState;
  selected: boolean;
 }>();
 const iconFailed = ref(false);
 const resolvedIcon = computed(() => {
  if (!props.item.icon) return "";
  return props.item.icon.startsWith("/")
    ? `file://${props.item.icon}`
    : props.item.icon;
 });
 </script>
 ```
 - [ ] **Step 4: Run test to verify it passes**
 Run: `npm run test -- --run src/__tests__/unit/update-center/UpdateCenterItem.test.ts`
 Expected: PASS with 2 tests passed.
 - [ ] **Step 5: Commit**
 ```bash
 git add src/components/update-center/UpdateCenterItem.vue src/__tests__/unit/update-center/UpdateCenterItem.test.ts
 git commit -m "feat(update-center): render update item icons"
 ```
 ### Task 4: Verify the Icon Feature End-to-End
 **Files:**
 - Modify: `electron/main/backend/update-center/icons.ts`
 - Modify: `electron/main/backend/update-center/index.ts`
 - Modify: `electron/main/backend/update-center/service.ts`
 - Modify: `src/global/typedefinition.ts`
 - Modify: `src/components/update-center/UpdateCenterItem.vue`
 - Modify: `src/__tests__/unit/update-center/icons.test.ts`
 - Modify: `src/__tests__/unit/update-center/load-items.test.ts`
 - Modify: `src/__tests__/unit/update-center/UpdateCenterItem.test.ts`
 - [ ] **Step 1: Format the changed files**
 Run: `npm run format`
 Expected: Prettier rewrites changed `src/` and `electron/` files without errors.
 - [ ] **Step 2: Run lint and the targeted update-center suite**
 Run: `npm run lint && npm run test -- --run src/__tests__/unit/update-center/icons.test.ts src/__tests__/unit/update-center/load-items.test.ts src/__tests__/unit/update-center/UpdateCenterItem.test.ts`
 Expected: ESLint exits 0 and the new icon-related tests pass.
 - [ ] **Step 3: Run the complete unit suite and production build**
 Run: `npm run test -- --run && npm run build:vite`
 Expected: all existing unit tests remain green and `vue-tsc` plus Vite production build complete successfully.
 - [ ] **Step 4: Commit the verified icon feature**
 ```bash
 git add electron/main/backend/update-center/types.ts electron/main/backend/update-center/icons.ts electron/main/backend/update-center/index.ts electron/main/backend/update-center/service.ts src/global/typedefinition.ts src/components/update-center/UpdateCenterItem.vue src/__tests__/unit/update-center/icons.test.ts src/__tests__/unit/update-center/load-items.test.ts src/__tests__/unit/update-center/UpdateCenterItem.test.ts
 git commit -m "feat(update-center): show icons in update list"
 ```
@@ -1,529 +0,0 @@
 # Update Center Migration Strategy Implementation Plan
 > **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
 **Goal:** Make update-center behavior follow installed-source-aware rules, including aptss-to-apm migration as a single visible update that removes the aptss package before installing the apm version.
 **Architecture:** Keep the existing update-center pipeline, but change it at three narrow seams: source merging in `query.ts`, task payload creation in `service.ts`, and migration execution in the main-process install path. The renderer keeps showing update items and download queue entries, while the main process becomes the only place that performs the ordered `aptss remove -> apm install` migration.
 **Tech Stack:** TypeScript, Electron IPC, Vue 3, Vitest
 ---
 ### Task 1: Installed-Source Merge Rules
 **Files:**
 - Modify: `electron/main/backend/update-center/query.ts:325-374`
 - Test: `src/__tests__/unit/update-center/query.test.ts`
 - [ ] **Step 1: Write the failing merge-rule tests**
 Add these tests to `src/__tests__/unit/update-center/query.test.ts` next to the existing `mergeUpdateSources()` coverage:
 ```ts
 it("returns only the migration item when only aptss is installed and apm has a higher version", () => {
  const merged = mergeUpdateSources(
    [
      {
        pkgname: "spark-weather",
        source: "aptss",
        currentVersion: "1.9.0",
        nextVersion: "2.0.0",
      },
    ],
    [
      {
        pkgname: "spark-weather",
        source: "apm",
        currentVersion: "1.8.0",
        nextVersion: "3.0.0",
      },
    ],
    new Map([["spark-weather", { aptss: true, apm: false }]]),
  );
  expect(merged).toEqual([
    {
      pkgname: "spark-weather",
      source: "apm",
      currentVersion: "1.8.0",
      nextVersion: "3.0.0",
      isMigration: true,
      migrationSource: "aptss",
      migrationTarget: "apm",
      aptssVersion: "2.0.0",
    },
  ]);
 });
 it("returns only the aptss item when only aptss is installed and apm is not newer", () => {
  const merged = mergeUpdateSources(
    [
      {
        pkgname: "spark-notes",
        source: "aptss",
        currentVersion: "1.0.0",
        nextVersion: "2.0.0",
      },
    ],
    [
      {
        pkgname: "spark-notes",
        source: "apm",
        currentVersion: "1.0.0",
        nextVersion: "1.5.0",
      },
    ],
    new Map([["spark-notes", { aptss: true, apm: false }]]),
  );
  expect(merged).toEqual([
    {
      pkgname: "spark-notes",
      source: "aptss",
      currentVersion: "1.0.0",
      nextVersion: "2.0.0",
    },
  ]);
 });
 it("returns only the apm item when only apm is installed", () => {
  const merged = mergeUpdateSources(
    [
      {
        pkgname: "spark-player",
        source: "aptss",
        currentVersion: "1.0.0",
        nextVersion: "2.0.0",
      },
    ],
    [
      {
        pkgname: "spark-player",
        source: "apm",
        currentVersion: "1.1.0",
        nextVersion: "3.0.0",
      },
    ],
    new Map([["spark-player", { aptss: false, apm: true }]]),
  );
  expect(merged).toEqual([
    {
      pkgname: "spark-player",
      source: "apm",
      currentVersion: "1.1.0",
      nextVersion: "3.0.0",
    },
  ]);
 });
 it("returns both items when aptss and apm are both installed", () => {
  const merged = mergeUpdateSources(
    [
      {
        pkgname: "spark-browser",
        source: "aptss",
        currentVersion: "10.0",
        nextVersion: "11.0",
      },
    ],
    [
      {
        pkgname: "spark-browser",
        source: "apm",
        currentVersion: "11.0",
        nextVersion: "12.0",
      },
    ],
    new Map([["spark-browser", { aptss: true, apm: true }]]),
  );
  expect(merged).toEqual([
    {
      pkgname: "spark-browser",
      source: "aptss",
      currentVersion: "10.0",
      nextVersion: "11.0",
    },
    {
      pkgname: "spark-browser",
      source: "apm",
      currentVersion: "11.0",
      nextVersion: "12.0",
    },
  ]);
 });
 ```
 - [ ] **Step 2: Run test to verify it fails**
 Run: `npm run test -- --run src/__tests__/unit/update-center/query.test.ts`
 Expected: FAIL because the current implementation still returns both the migration item and the aptss item for the aptss-only migration case, and still returns both sources in the apm-only case.
 - [ ] **Step 3: Write the minimal merge logic**
 Update `electron/main/backend/update-center/query.ts` so `mergeUpdateSources()` uses installed-source-aware branching instead of unconditional double inclusion. Replace the body with this implementation shape:
 ```ts
 export const mergeUpdateSources = (
  aptssItems: UpdateCenterItem[],
  apmItems: UpdateCenterItem[],
  installedSources: Map<string, InstalledSourceState>,
 ): UpdateCenterItem[] => {
  const aptssMap = new Map(aptssItems.map((item) => [item.pkgname, item]));
  const apmMap = new Map(apmItems.map((item) => [item.pkgname, item]));
  const pkgnames = new Set([...aptssMap.keys(), ...apmMap.keys()]);
  const merged: UpdateCenterItem[] = [];
  for (const pkgname of pkgnames) {
    const aptssItem = aptssMap.get(pkgname);
    const apmItem = apmMap.get(pkgname);
    const installedState = installedSources.get(pkgname);
    if (installedState?.aptss === true && installedState.apm === false) {
      if (aptssItem && apmItem) {
        if (compareVersions(apmItem.nextVersion, aptssItem.nextVersion) > 0) {
          merged.push({
            ...apmItem,
            isMigration: true,
            migrationSource: "aptss",
            migrationTarget: "apm",
            aptssVersion: aptssItem.nextVersion,
          });
        } else {
          merged.push(aptssItem);
        }
        continue;
      }
      if (aptssItem) {
        merged.push(aptssItem);
      }
      continue;
    }
    if (installedState?.aptss === false && installedState.apm === true) {
      if (apmItem) {
        merged.push(apmItem);
      }
      continue;
    }
    if (installedState?.aptss === true && installedState.apm === true) {
      if (aptssItem) merged.push(aptssItem);
      if (apmItem) merged.push(apmItem);
      continue;
    }
    if (aptssItem) merged.push(aptssItem);
    if (apmItem) merged.push(apmItem);
  }
  return merged;
 };
 ```
 - [ ] **Step 4: Run test to verify it passes**
 Run: `npm run test -- --run src/__tests__/unit/update-center/query.test.ts`
 Expected: PASS
 - [ ] **Step 5: Commit**
 ```bash
 git add src/__tests__/unit/update-center/query.test.ts electron/main/backend/update-center/query.ts
 git commit -m "fix(update-center): apply installed-source merge rules"
 ```
 ### Task 2: Migration Payload and Main-Process Execution
 **Files:**
 - Modify: `electron/main/backend/update-center/service.ts:191-245`
 - Modify: `src/global/typedefinition.ts:29-54`
 - Modify: `src/modules/updateCenter.ts:148-205`
 - Modify: `electron/main/backend/install-manager.ts:251-299`
 - Test: `src/__tests__/unit/update-center/registerUpdateCenter.test.ts`
 - Test: `src/__tests__/unit/update-center/task-runner.test.ts`
 - [ ] **Step 1: Write the failing IPC payload test**
 Add this test to `src/__tests__/unit/update-center/registerUpdateCenter.test.ts` near the existing `service.start()` coverage:
 ```ts
 it("sends migration metadata to the main install queue", async () => {
  const send = vi.fn();
  electronMock.getAllWindows.mockReturnValue([{ webContents: { send } }]);
  const service = createUpdateCenterService({
    loadItems: async () => [
      {
        ...createItem(),
        source: "apm",
        isMigration: true,
        migrationSource: "aptss",
        migrationTarget: "apm",
        fileName: "spark-weather_3.0.0_amd64.deb",
        downloadUrl: "https://example.invalid/spark-weather_3.0.0_amd64.deb",
      },
    ],
  });
  await service.refresh();
  await service.start(["apm:spark-weather"]);
  expect(send).toHaveBeenCalledWith(
    "queue-install",
    JSON.stringify(
      expect.objectContaining({
        pkgname: "spark-weather",
        origin: "apm",
        upgradeOnly: true,
        isMigration: true,
        migrationSource: "aptss",
        migrationTarget: "apm",
      }),
    ),
  );
 });
 ```
 - [ ] **Step 2: Write the failing migration install test**
 Add this test to `src/__tests__/unit/update-center/task-runner.test.ts` after the direct install command tests:
 ```ts
 it("runs aptss remove before apm ssinstall for migration items", async () => {
  childProcessMock.spawnCalls.length = 0;
  await installUpdateItem({
    item: {
      ...createApmItem(),
      isMigration: true,
      migrationSource: "aptss",
      migrationTarget: "apm",
    },
    filePath: "/tmp/spark-player.deb",
    superUserCmd: "/usr/bin/pkexec",
  });
  expect(childProcessMock.spawnCalls).toEqual([
    {
      command: "/usr/bin/pkexec",
      args: [
        "/opt/spark-store/extras/shell-caller.sh",
        "aptss",
        "remove",
        "spark-player",
      ],
    },
    {
      command: "/usr/bin/pkexec",
      args: [
        "/opt/spark-store/extras/shell-caller.sh",
        "apm",
        "ssinstall",
        "/tmp/spark-player.deb",
      ],
    },
  ]);
 });
 ```
 - [ ] **Step 3: Run tests to verify they fail**
 Run: `npm run test -- --run src/__tests__/unit/update-center/registerUpdateCenter.test.ts src/__tests__/unit/update-center/task-runner.test.ts`
 Expected: FAIL because the queue-install payload does not include migration metadata yet, and the install path still runs only the apm install command.
 - [ ] **Step 4: Extend the task payload types**
 Add these optional fields to `DownloadItem`-adjacent transport types in `src/global/typedefinition.ts` or the local payload interface that already carries queue-install data:
 ```ts
  isMigration?: boolean;
  migrationSource?: "aptss" | "apm";
  migrationTarget?: "aptss" | "apm";
 ```
 If the queue payload is not typed centrally, create a narrow local type in `electron/main/backend/update-center/service.ts` and a matching parsing shape in `electron/main/backend/install-manager.ts`.
 - [ ] **Step 5: Send migration metadata from the update-center service**
 Change `installTaskData` in `electron/main/backend/update-center/service.ts` to include the migration fields when present:
 ```ts
 const installTaskData = {
  id: updateTaskId,
  pkgname: item.pkgname,
  metalinkUrl,
  filename: item.fileName,
  upgradeOnly: true,
  origin: item.source === "apm" ? "apm" : "spark",
  retry: false,
  isMigration: item.isMigration === true,
  migrationSource: item.migrationSource,
  migrationTarget: item.migrationTarget,
 };
 ```
 - [ ] **Step 6: Preserve migration state in the renderer queue item**
 Extend the temporary queue item created in `src/modules/updateCenter.ts` so migration items show up as migration work instead of generic updates:
 ```ts
          logs: [
            {
              time: Date.now(),
              message: item.isMigration === true ? "开始迁移到 APM..." : "开始更新...",
            },
          ],
 ```
 Also carry the same optional migration flags if the renderer-side queue type supports them.
 - [ ] **Step 7: Implement ordered migration execution in the main process**
 In the main install path used by update-center file installs, add a migration branch before the normal `origin === "apm"` handling. The shape should be:
 ```ts
 if (isMigration === true && migrationSource === "aptss" && origin === "apm") {
  const removeCommand = superUserCmd || SHELL_CALLER_PATH;
  const removeParams: string[] = [];
  if (superUserCmd) {
    removeParams.push(SHELL_CALLER_PATH);
  }
  removeParams.push("aptss", "remove", pkgname);
  await runInstallCommand({
    command: removeCommand,
    args: removeParams,
    webContents,
    id,
    stageLabel: "迁移卸载旧版本",
  });
 }
 ```
 Then fall through to the existing apm install branch so the next command remains:
 ```ts
 execParams.push("apm");
 execParams.push("ssinstall", `${downloadDir}/${filename}`);
 ```
 Use the existing install-log/install-complete reporting path rather than inventing a second event system.
 - [ ] **Step 8: Run tests to verify they pass**
 Run: `npm run test -- --run src/__tests__/unit/update-center/registerUpdateCenter.test.ts src/__tests__/unit/update-center/task-runner.test.ts`
 Expected: PASS for the new migration payload and command-order tests
 - [ ] **Step 9: Commit**
 ```bash
 git add electron/main/backend/update-center/service.ts src/global/typedefinition.ts src/modules/updateCenter.ts electron/main/backend/install-manager.ts src/__tests__/unit/update-center/registerUpdateCenter.test.ts src/__tests__/unit/update-center/task-runner.test.ts
 git commit -m "feat(update-center): run aptss-to-apm migrations"
 ```
 ### Task 3: Migration Confirmation Copy and Renderer Regression
 **Files:**
 - Modify: `src/components/update-center/UpdateCenterMigrationConfirm.vue`
 - Test: `src/__tests__/unit/update-center/UpdateCenterModal.test.ts`
 - [ ] **Step 1: Write the failing migration-copy test**
 Update `src/__tests__/unit/update-center/UpdateCenterModal.test.ts` so the migration confirmation assertion expects the new copy:
 ```ts
 it("renders migration confirmation copy explaining aptss removal and apm install", () => {
  const store = createStore({ hasRunningTasks: false });
  store.showMigrationConfirm.value = true;
  render(UpdateCenterModal, {
    props: {
      show: true,
      store,
    },
  });
  expect(screen.getByText("迁移确认")).toBeTruthy();
  expect(
    screen.getByText(/会先卸载现有 aptss 版本，再安装 APM 版本/),
  ).toBeTruthy();
  expect(screen.getByText(/后续更新将由 APM 管理/)).toBeTruthy();
 });
 ```
 - [ ] **Step 2: Run test to verify it fails**
 Run: `npm run test -- --run src/__tests__/unit/update-center/UpdateCenterModal.test.ts`
 Expected: FAIL because the current modal copy only says that some deb updates will migrate to APM.
 - [ ] **Step 3: Update the modal copy with the approved behavior**
 Change the body text in `src/components/update-center/UpdateCenterMigrationConfirm.vue` to this:
 ```vue
 <p class="mt-2 text-sm text-slate-500 dark:text-slate-400">
        该应用将从传统 aptss 管理迁移到 APM 管理。迁移过程会先卸载现有 aptss 版本，再安装 APM 版本；迁移完成后，后续更新将由 APM 管理。
      </p>
 ```
 - [ ] **Step 4: Run test to verify it passes**
 Run: `npm run test -- --run src/__tests__/unit/update-center/UpdateCenterModal.test.ts`
 Expected: PASS
 - [ ] **Step 5: Commit**
 ```bash
 git add src/components/update-center/UpdateCenterMigrationConfirm.vue src/__tests__/unit/update-center/UpdateCenterModal.test.ts
 git commit -m "docs(update-center): clarify migration confirmation"
 ```
 ### Task 4: Final Verification
 **Files:**
 - Modify: none
 - Test: `src/__tests__/unit/update-center/query.test.ts`
 - Test: `src/__tests__/unit/update-center/registerUpdateCenter.test.ts`
 - Test: `src/__tests__/unit/update-center/task-runner.test.ts`
 - Test: `src/__tests__/unit/update-center/UpdateCenterModal.test.ts`
 - [ ] **Step 1: Run focused regression suite**
 Run:
 ```bash
 npm run test -- --run src/__tests__/unit/update-center/query.test.ts src/__tests__/unit/update-center/registerUpdateCenter.test.ts src/__tests__/unit/update-center/task-runner.test.ts src/__tests__/unit/update-center/UpdateCenterModal.test.ts
 ```
 Expected: PASS
 - [ ] **Step 2: Run lint if the touched files are lint-clean**
 Run: `npm run lint`
 Expected: either PASS or the same known unrelated pre-existing lint failures already present in the branch. Do not claim a clean lint run unless the command output is actually clean.
 - [ ] **Step 3: Review the final diff**
 Run:
 ```bash
 git diff -- electron/main/backend/update-center/query.ts electron/main/backend/update-center/service.ts electron/main/backend/install-manager.ts src/modules/updateCenter.ts src/components/update-center/UpdateCenterMigrationConfirm.vue src/__tests__/unit/update-center/query.test.ts src/__tests__/unit/update-center/registerUpdateCenter.test.ts src/__tests__/unit/update-center/task-runner.test.ts src/__tests__/unit/update-center/UpdateCenterModal.test.ts
 ```
 Expected: diff only covers merge rules, migration payload/execution, and migration confirmation copy.
 - [ ] **Step 4: Commit final verification state if needed**
 ```bash
 git status --short
 ```
 If uncommitted changes remain from verification-only edits, either commit them with a focused message or fold them into the last task commit before handing off.
@@ -1,996 +0,0 @@
 # Gitee Issue Bot Implementation Plan
 > **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
 **Goal:** Build a user-level `systemd`-driven issue bot that checks Spark Store Gitee issues every 6 hours, stores one ranked candidate locally, and only launches a new opencode window after explicit manual approval.
 **Architecture:** Keep the implementation outside the Electron runtime by adding a small TypeScript script set under `scripts/issue-bot/`, with focused helpers for Gitee fetching, ranking, local state, approval, and opencode launching. Use user-cache state storage plus `systemd --user` service/timer units, and pass the `~/Desktop/spark-store` + `Erotica`-based worktree requirement into the generated opencode prompt instead of creating worktrees during polling.
 **Tech Stack:** Node.js 22 with `--experimental-strip-types`, TypeScript strict mode, built-in `fetch`, Vitest, npm scripts, `systemd --user` units.
 ---
 ## File Map
 - Create: `scripts/issue-bot/lib/types.ts` — shared strict TypeScript types for normalized issues, ranking results, and persisted state.
 - Create: `scripts/issue-bot/lib/state.ts` — state file path resolution, JSON load/save, corruption backup, and default-state initialization.
 - Create: `scripts/issue-bot/lib/ranking.ts` — issue filtering, heuristic scoring, and candidate selection.
 - Create: `scripts/issue-bot/lib/gitee.ts` — fetch open issues from Gitee API first and normalize the response.
 - Create: `scripts/issue-bot/lib/opencode.ts` — build approval prompt and spawn a configured opencode command.
 - Create: `scripts/issue-bot/check-issues.ts` — one-shot polling entrypoint that updates `currentCandidate`.
 - Create: `scripts/issue-bot/approve-issue.ts` — manual approval entrypoint that launches opencode and marks the approved issue.
 - Create: `src/__tests__/unit/issue-bot/state.test.ts` — state initialization, backup, and save/load tests.
 - Create: `src/__tests__/unit/issue-bot/ranking.test.ts` — scoring, filtering, and candidate selection tests.
 - Create: `src/__tests__/unit/issue-bot/check-issues.test.ts` — polling orchestration tests using mocked fetch/state.
 - Create: `src/__tests__/unit/issue-bot/approve-issue.test.ts` — approval and opencode-launch orchestration tests.
 - Create: `src/__tests__/unit/issue-bot/packaging.test.ts` — npm script and systemd unit smoke tests.
 - Modify: `package.json` — add `issue-bot:check` and `issue-bot:approve` scripts.
 - Modify: `tsconfig.node.json` — include `scripts` for type-check coverage in build tooling.
 - Create: `extras/systemd/spark-store-issue-bot.service` — `oneshot` user service for polling.
 - Create: `extras/systemd/spark-store-issue-bot.timer` — six-hour persistent timer.
 ### Task 1: Add Shared Types and Local State Storage
 **Files:**
 - Create: `scripts/issue-bot/lib/types.ts`
 - Create: `scripts/issue-bot/lib/state.ts`
 - Test: `src/__tests__/unit/issue-bot/state.test.ts`
 - [ ] **Step 1: Write the failing test**
 ```ts
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { afterEach, describe, expect, it, vi } from "vitest";
 import {
  createDefaultIssueBotState,
  getIssueBotStatePath,
  loadIssueBotState,
  saveIssueBotState,
 } from "../../../../scripts/issue-bot/lib/state";
 describe("issue-bot state", () => {
  afterEach(() => {
    vi.restoreAllMocks();
    delete process.env.XDG_CACHE_HOME;
  });
  it("uses the XDG cache directory when available", () => {
    process.env.XDG_CACHE_HOME = "/tmp/spark-cache";
    expect(getIssueBotStatePath()).toBe(
      "/tmp/spark-cache/spark-store/issue-bot/state.json",
    );
  });
  it("returns a default state when the file does not exist", () => {
    vi.spyOn(fs, "existsSync").mockReturnValue(false);
    expect(loadIssueBotState()).toEqual(createDefaultIssueBotState());
  });
  it("backs up invalid JSON and resets to the default state", () => {
    vi.spyOn(fs, "existsSync").mockReturnValue(true);
    vi.spyOn(fs, "readFileSync").mockReturnValue("not-json");
    const renameSync = vi.spyOn(fs, "renameSync").mockImplementation(() => {});
    expect(loadIssueBotState()).toEqual(createDefaultIssueBotState());
    expect(renameSync).toHaveBeenCalledWith(
      expect.stringContaining("state.json"),
      expect.stringContaining("state.json.bak-"),
    );
  });
  it("creates parent directories before saving state", () => {
    const mkdirSync = vi
      .spyOn(fs, "mkdirSync")
      .mockImplementation(() => undefined);
    const writeFileSync = vi
      .spyOn(fs, "writeFileSync")
      .mockImplementation(() => undefined);
    saveIssueBotState({
      ...createDefaultIssueBotState(),
      lastRunStatus: "success",
      lastRunMessage: "candidate updated",
    });
    expect(mkdirSync).toHaveBeenCalledWith(
      path.dirname(getIssueBotStatePath()),
      { recursive: true },
    );
    expect(writeFileSync).toHaveBeenCalledWith(
      getIssueBotStatePath(),
      expect.stringContaining('"lastRunStatus": "success"'),
      "utf8",
    );
  });
 });
 ```
 - [ ] **Step 2: Run test to verify it fails**
 Run: `npm run test -- --run src/__tests__/unit/issue-bot/state.test.ts`
 Expected: FAIL with `Cannot find module '../../../../scripts/issue-bot/lib/state'`.
 - [ ] **Step 3: Write minimal implementation**
 ```ts
 // scripts/issue-bot/lib/types.ts
 export interface NormalizedIssue {
  id: number;
  number: string;
  title: string;
  url: string;
  state: "open" | "closed";
  createdAt: string;
  updatedAt: string;
  labels: string[];
  bodyPreview: string;
 }
 export interface RankedIssue extends NormalizedIssue {
  score: number;
  rankingReasons: string[];
 }
 export interface ApprovedIssue {
  id: number;
  title: string;
  url: string;
  approvedAt: string;
 }
 export interface IssueBotState {
  currentCandidate: RankedIssue | null;
  approvedIssue: ApprovedIssue | null;
  seenIssueIds: number[];
  lastRunAt: string | null;
  lastRunStatus: "idle" | "success" | "network-error" | "parse-error";
  lastRunMessage: string | null;
 }
 ```
 ```ts
 // scripts/issue-bot/lib/state.ts
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import type { IssueBotState } from "./types";
 export const createDefaultIssueBotState = (): IssueBotState => ({
  currentCandidate: null,
  approvedIssue: null,
  seenIssueIds: [],
  lastRunAt: null,
  lastRunStatus: "idle",
  lastRunMessage: null,
 });
 export const getIssueBotStatePath = (): string => {
  const cacheRoot =
    process.env.XDG_CACHE_HOME || path.join(os.homedir(), ".cache");
  return path.join(cacheRoot, "spark-store", "issue-bot", "state.json");
 };
 export const loadIssueBotState = (): IssueBotState => {
  const filePath = getIssueBotStatePath();
  if (!fs.existsSync(filePath)) return createDefaultIssueBotState();
  try {
    const raw = fs.readFileSync(filePath, "utf8");
    return {
      ...createDefaultIssueBotState(),
      ...(JSON.parse(raw) as Partial<IssueBotState>),
    };
  } catch {
    const backupPath = `${filePath}.bak-${Date.now()}`;
    fs.renameSync(filePath, backupPath);
    return createDefaultIssueBotState();
  }
 };
 export const saveIssueBotState = (state: IssueBotState): void => {
  const filePath = getIssueBotStatePath();
  fs.mkdirSync(path.dirname(filePath), { recursive: true });
  fs.writeFileSync(filePath, `${JSON.stringify(state, null, 2)}\n`, "utf8");
 };
 ```
 - [ ] **Step 4: Run test to verify it passes**
 Run: `npm run test -- --run src/__tests__/unit/issue-bot/state.test.ts`
 Expected: PASS with 4 tests passed.
 - [ ] **Step 5: Commit**
 ```bash
 git add scripts/issue-bot/lib/types.ts scripts/issue-bot/lib/state.ts src/__tests__/unit/issue-bot/state.test.ts
 git commit -m "feat(issue-bot): add local state storage"
 ```
 ### Task 2: Add Ranking Rules and Candidate Selection
 **Files:**
 - Create: `scripts/issue-bot/lib/ranking.ts`
 - Test: `src/__tests__/unit/issue-bot/ranking.test.ts`
 - [ ] **Step 1: Write the failing test**
 ```ts
 import { describe, expect, it } from "vitest";
 import {
  rankIssues,
  selectTopIssueCandidate,
 } from "../../../../scripts/issue-bot/lib/ranking";
 import type { NormalizedIssue } from "../../../../scripts/issue-bot/lib/types";
 const makeIssue = (overrides: Partial<NormalizedIssue>): NormalizedIssue => ({
  id: 1,
  number: "I123",
  title: "示例 issue",
  url: "https://gitee.com/spark-store-project/spark-store/issues/I123",
  state: "open",
  createdAt: "2026-04-14T00:00:00.000Z",
  updatedAt: "2026-04-14T00:00:00.000Z",
  labels: [],
  bodyPreview: "用户反馈应用无法安装，并附上了复现步骤和日志。",
  ...overrides,
 });
 describe("issue-bot ranking", () => {
  it("prioritizes install failures with actionable details", () => {
    const ranked = rankIssues([
      makeIssue({ id: 1, title: "应用无法安装，附日志" }),
      makeIssue({ id: 2, title: "建议增加分类筛选", bodyPreview: "功能建议" }),
    ]);
    expect(ranked[0].id).toBe(1);
    expect(ranked[0].score).toBeGreaterThan(ranked[1].score);
    expect(ranked[0].rankingReasons).toContain(
      "contains high-impact keyword: 无法安装",
    );
  });
  it("filters out closed issues and already-approved issues", () => {
    const candidate = selectTopIssueCandidate(
      [
        makeIssue({ id: 3, state: "closed", title: "已关闭问题" }),
        makeIssue({ id: 4, title: "白屏并卡死" }),
      ],
      { approvedIssueId: 4 },
    );
    expect(candidate).toBeNull();
  });
  it("prefers more recently updated issues when scores otherwise match", () => {
    const candidate = selectTopIssueCandidate(
      [
        makeIssue({
          id: 5,
          title: "启动白屏",
          updatedAt: "2026-04-14T08:00:00.000Z",
        }),
        makeIssue({
          id: 6,
          title: "启动白屏",
          updatedAt: "2026-04-14T09:00:00.000Z",
        }),
      ],
      { approvedIssueId: null },
    );
    expect(candidate?.id).toBe(6);
  });
 });
 ```
 - [ ] **Step 2: Run test to verify it fails**
 Run: `npm run test -- --run src/__tests__/unit/issue-bot/ranking.test.ts`
 Expected: FAIL with `Cannot find module '../../../../scripts/issue-bot/lib/ranking'`.
 - [ ] **Step 3: Write minimal implementation**
 ```ts
 // scripts/issue-bot/lib/ranking.ts
 import type { NormalizedIssue, RankedIssue } from "./types";
 const HIGH_IMPACT_KEYWORDS = [
  "崩溃",
  "打不开",
  "无法安装",
  "升级失败",
  "卡死",
  "白屏",
  "闪退",
 ];
 const CORE_FLOW_KEYWORDS = ["安装", "卸载", "更新", "启动", "搜索", "加载"];
 const hasActionableDetail = (issue: NormalizedIssue): boolean =>
  /复现|日志|截图|error|错误/i.test(issue.bodyPreview);
 const scoreIssue = (issue: NormalizedIssue): RankedIssue => {
  const reasons: string[] = [];
  let score = 0;
  const haystack = `${issue.title}\n${issue.bodyPreview}`;
  for (const keyword of HIGH_IMPACT_KEYWORDS) {
    if (haystack.includes(keyword)) {
      score += 10;
      reasons.push(`contains high-impact keyword: ${keyword}`);
    }
  }
  for (const keyword of CORE_FLOW_KEYWORDS) {
    if (haystack.includes(keyword)) {
      score += 4;
      reasons.push(`touches core flow: ${keyword}`);
      break;
    }
  }
  if (hasActionableDetail(issue)) {
    score += 6;
    reasons.push("includes actionable detail");
  }
  if (/建议|需求|希望/.test(haystack)) {
    score -= 4;
    reasons.push("looks like feature discussion");
  }
  return {
    ...issue,
    score,
    rankingReasons: reasons,
  };
 };
 export const rankIssues = (issues: NormalizedIssue[]): RankedIssue[] =>
  [...issues]
    .filter((issue) => issue.state === "open")
    .map(scoreIssue)
    .sort((left, right) => {
      if (right.score !== left.score) return right.score - left.score;
      return Date.parse(right.updatedAt) - Date.parse(left.updatedAt);
    });
 export const selectTopIssueCandidate = (
  issues: NormalizedIssue[],
  options: { approvedIssueId: number | null },
 ): RankedIssue | null => {
  const ranked = rankIssues(issues).filter(
    (issue) => issue.id !== options.approvedIssueId,
  );
  return ranked[0] ?? null;
 };
 ```
 - [ ] **Step 4: Run test to verify it passes**
 Run: `npm run test -- --run src/__tests__/unit/issue-bot/ranking.test.ts`
 Expected: PASS with 3 tests passed.
 - [ ] **Step 5: Commit**
 ```bash
 git add scripts/issue-bot/lib/ranking.ts src/__tests__/unit/issue-bot/ranking.test.ts
 git commit -m "feat(issue-bot): rank candidate issues"
 ```
 ### Task 3: Add Gitee Fetching and Polling Entrypoint
 **Files:**
 - Create: `scripts/issue-bot/lib/gitee.ts`
 - Create: `scripts/issue-bot/check-issues.ts`
 - Test: `src/__tests__/unit/issue-bot/check-issues.test.ts`
 - [ ] **Step 1: Write the failing test**
 ```ts
 import { beforeEach, describe, expect, it, vi } from "vitest";
 import type {
  IssueBotState,
  NormalizedIssue,
 } from "../../../../scripts/issue-bot/lib/types";
 const loadState = vi.fn();
 const saveState = vi.fn();
 const listOpenIssues = vi.fn();
 vi.mock("../../../../scripts/issue-bot/lib/state", () => ({
  createDefaultIssueBotState: () => ({
    currentCandidate: null,
    approvedIssue: null,
    seenIssueIds: [],
    lastRunAt: null,
    lastRunStatus: "idle",
    lastRunMessage: null,
  }),
  loadIssueBotState: loadState,
  saveIssueBotState: saveState,
 }));
 vi.mock("../../../../scripts/issue-bot/lib/gitee", () => ({
  listOpenIssues,
 }));
 describe("check-issues", () => {
  beforeEach(() => {
    vi.resetModules();
    loadState.mockReset();
    saveState.mockReset();
    listOpenIssues.mockReset();
  });
  it("stores the top-ranked issue candidate", async () => {
    const baseState: IssueBotState = {
      currentCandidate: null,
      approvedIssue: null,
      seenIssueIds: [],
      lastRunAt: null,
      lastRunStatus: "idle",
      lastRunMessage: null,
    };
    loadState.mockReturnValue(baseState);
    listOpenIssues.mockResolvedValue([
      {
        id: 10,
        number: "I10",
        title: "应用无法安装并白屏",
        url: "https://gitee.com/spark-store-project/spark-store/issues/I10",
        state: "open",
        createdAt: "2026-04-14T00:00:00.000Z",
        updatedAt: "2026-04-14T09:00:00.000Z",
        labels: ["bug"],
        bodyPreview: "复现步骤：1. 打开商店 2. 点击安装。附日志。",
      },
    ] satisfies NormalizedIssue[]);
    const { runIssueBotCheck } =
      await import("../../../../scripts/issue-bot/check-issues");
    await runIssueBotCheck();
    expect(saveState).toHaveBeenCalledWith(
      expect.objectContaining({
        currentCandidate: expect.objectContaining({
          id: 10,
          title: "应用无法安装并白屏",
        }),
        lastRunStatus: "success",
      }),
    );
  });
  it("keeps the previous candidate when fetching issues fails", async () => {
    loadState.mockReturnValue({
      currentCandidate: {
        id: 99,
        number: "I99",
        title: "旧候选",
        url: "https://gitee.com/spark-store-project/spark-store/issues/I99",
        state: "open",
        createdAt: "2026-04-14T00:00:00.000Z",
        updatedAt: "2026-04-14T00:00:00.000Z",
        labels: [],
        bodyPreview: "旧摘要",
        score: 12,
        rankingReasons: ["legacy candidate"],
      },
      approvedIssue: null,
      seenIssueIds: [],
      lastRunAt: null,
      lastRunStatus: "idle",
      lastRunMessage: null,
    });
    listOpenIssues.mockRejectedValue(new Error("network down"));
    const { runIssueBotCheck } =
      await import("../../../../scripts/issue-bot/check-issues");
    await runIssueBotCheck();
    expect(saveState).toHaveBeenCalledWith(
      expect.objectContaining({
        currentCandidate: expect.objectContaining({ id: 99 }),
        lastRunStatus: "network-error",
        lastRunMessage: "network down",
      }),
    );
  });
 });
 ```
 - [ ] **Step 2: Run test to verify it fails**
 Run: `npm run test -- --run src/__tests__/unit/issue-bot/check-issues.test.ts`
 Expected: FAIL with `Cannot find module '../../../../scripts/issue-bot/check-issues'`.
 - [ ] **Step 3: Write minimal implementation**
 ```ts
 // scripts/issue-bot/lib/gitee.ts
 import type { NormalizedIssue } from "./types";
 interface GiteeIssueApiResponse {
  id: number;
  number: string;
  title: string;
  state: "open" | "closed";
  created_at: string;
  updated_at: string;
  body?: string;
  html_url: string;
  labels?: Array<{ name?: string }>;
 }
 const GITEE_ISSUES_API_URL =
  "https://gitee.com/api/v5/repos/spark-store-project/spark-store/issues?state=open&sort=updated&direction=desc&page=1&per_page=50";
 export const listOpenIssues = async (): Promise<NormalizedIssue[]> => {
  const response = await fetch(GITEE_ISSUES_API_URL);
  if (!response.ok) {
    throw new Error(`Gitee request failed: ${response.status}`);
  }
  const payload = (await response.json()) as GiteeIssueApiResponse[];
  return payload.map((issue) => ({
    id: issue.id,
    number: issue.number,
    title: issue.title,
    url: issue.html_url,
    state: issue.state,
    createdAt: issue.created_at,
    updatedAt: issue.updated_at,
    labels: (issue.labels || [])
      .map((label) => label.name?.trim() || "")
      .filter((label) => label.length > 0),
    bodyPreview: (issue.body || "").slice(0, 500),
  }));
 };
 ```
 ```ts
 // scripts/issue-bot/check-issues.ts
 import { listOpenIssues } from "./lib/gitee";
 import { selectTopIssueCandidate } from "./lib/ranking";
 import { loadIssueBotState, saveIssueBotState } from "./lib/state";
 export const runIssueBotCheck = async (): Promise<void> => {
  const state = loadIssueBotState();
  const now = new Date().toISOString();
  try {
    const issues = await listOpenIssues();
    const candidate = selectTopIssueCandidate(issues, {
      approvedIssueId: state.approvedIssue?.id ?? null,
    });
    saveIssueBotState({
      ...state,
      currentCandidate: candidate,
      seenIssueIds: candidate
        ? Array.from(new Set([...state.seenIssueIds, candidate.id]))
        : state.seenIssueIds,
      lastRunAt: now,
      lastRunStatus: "success",
      lastRunMessage: candidate
        ? `candidate updated: ${candidate.title}`
        : "no candidate issues found",
    });
  } catch (error) {
    saveIssueBotState({
      ...state,
      lastRunAt: now,
      lastRunStatus: "network-error",
      lastRunMessage: error instanceof Error ? error.message : String(error),
    });
  }
 };
 if (import.meta.url === `file://${process.argv[1]}`) {
  runIssueBotCheck().catch((error) => {
    console.error(error);
    process.exitCode = 1;
  });
 }
 ```
 - [ ] **Step 4: Run test to verify it passes**
 Run: `npm run test -- --run src/__tests__/unit/issue-bot/check-issues.test.ts`
 Expected: PASS with 2 tests passed.
 - [ ] **Step 5: Commit**
 ```bash
 git add scripts/issue-bot/lib/gitee.ts scripts/issue-bot/check-issues.ts src/__tests__/unit/issue-bot/check-issues.test.ts
 git commit -m "feat(issue-bot): poll gitee issues"
 ```
 ### Task 4: Add Opencode Prompt Generation and Manual Approval
 **Files:**
 - Create: `scripts/issue-bot/lib/opencode.ts`
 - Create: `scripts/issue-bot/approve-issue.ts`
 - Test: `src/__tests__/unit/issue-bot/approve-issue.test.ts`
 - [ ] **Step 1: Write the failing test**
 ```ts
 import { beforeEach, describe, expect, it, vi } from "vitest";
 const loadState = vi.fn();
 const saveState = vi.fn();
 const launchOpencodeForIssue = vi.fn();
 vi.mock("../../../../scripts/issue-bot/lib/state", () => ({
  loadIssueBotState: loadState,
  saveIssueBotState: saveState,
 }));
 vi.mock("../../../../scripts/issue-bot/lib/opencode", () => ({
  launchOpencodeForIssue,
 }));
 describe("approve-issue", () => {
  beforeEach(() => {
    vi.resetModules();
    loadState.mockReset();
    saveState.mockReset();
    launchOpencodeForIssue.mockReset();
  });
  it("marks the current candidate as approved and launches opencode", async () => {
    loadState.mockReturnValue({
      currentCandidate: {
        id: 42,
        number: "I42",
        title: "应用升级失败并白屏",
        url: "https://gitee.com/spark-store-project/spark-store/issues/I42",
        state: "open",
        createdAt: "2026-04-14T00:00:00.000Z",
        updatedAt: "2026-04-14T00:00:00.000Z",
        labels: ["bug"],
        bodyPreview: "更新后白屏，附日志。",
        score: 20,
        rankingReasons: ["contains high-impact keyword: 升级失败"],
      },
      approvedIssue: null,
      seenIssueIds: [42],
      lastRunAt: "2026-04-14T09:00:00.000Z",
      lastRunStatus: "success",
      lastRunMessage: "candidate updated",
    });
    const { runIssueBotApproval } =
      await import("../../../../scripts/issue-bot/approve-issue");
    await runIssueBotApproval();
    expect(launchOpencodeForIssue).toHaveBeenCalledWith(
      expect.objectContaining({ id: 42, title: "应用升级失败并白屏" }),
    );
    expect(saveState).toHaveBeenCalledWith(
      expect.objectContaining({
        currentCandidate: null,
        approvedIssue: expect.objectContaining({ id: 42 }),
      }),
    );
  });
  it("throws when there is no candidate to approve", async () => {
    loadState.mockReturnValue({
      currentCandidate: null,
      approvedIssue: null,
      seenIssueIds: [],
      lastRunAt: null,
      lastRunStatus: "idle",
      lastRunMessage: null,
    });
    const { runIssueBotApproval } =
      await import("../../../../scripts/issue-bot/approve-issue");
    await expect(runIssueBotApproval()).rejects.toThrow(
      "No current issue candidate to approve.",
    );
  });
 });
 ```
 - [ ] **Step 2: Run test to verify it fails**
 Run: `npm run test -- --run src/__tests__/unit/issue-bot/approve-issue.test.ts`
 Expected: FAIL with `Cannot find module '../../../../scripts/issue-bot/approve-issue'`.
 - [ ] **Step 3: Write minimal implementation**
 ```ts
 // scripts/issue-bot/lib/opencode.ts
 import { spawn } from "node:child_process";
 import type { RankedIssue } from "./types";
 export const buildOpencodePrompt = (
  issue: RankedIssue,
 ): string => `请处理以下 Spark Store issue：
 标题：${issue.title}
 链接：${issue.url}
 摘要：${issue.bodyPreview}
 优先级原因：${issue.rankingReasons.join("；")}
 要求：先分析根因，再开始修复。默认基仓库必须使用 ~/Desktop/spark-store。
 如果开始修改代码，必须先使用 git worktree，从 Erotica 分支开出新的工作分支，并在该 worktree 中实施改动，不要直接在主工作区修改。`;
 export const launchOpencodeForIssue = async (
  issue: RankedIssue,
 ): Promise<void> => {
  const configuredCommand = process.env.SPARK_STORE_OPENCODE_CMD || "opencode";
  const child = spawn(configuredCommand, [buildOpencodePrompt(issue)], {
    detached: true,
    stdio: "ignore",
    shell: true,
  });
  child.unref();
 };
 ```
 ```ts
 // scripts/issue-bot/approve-issue.ts
 import { launchOpencodeForIssue } from "./lib/opencode";
 import { loadIssueBotState, saveIssueBotState } from "./lib/state";
 export const runIssueBotApproval = async (): Promise<void> => {
  const state = loadIssueBotState();
  const candidate = state.currentCandidate;
  if (!candidate) {
    throw new Error("No current issue candidate to approve.");
  }
  await launchOpencodeForIssue(candidate);
  saveIssueBotState({
    ...state,
    currentCandidate: null,
    approvedIssue: {
      id: candidate.id,
      title: candidate.title,
      url: candidate.url,
      approvedAt: new Date().toISOString(),
    },
  });
 };
 if (import.meta.url === `file://${process.argv[1]}`) {
  runIssueBotApproval().catch((error) => {
    console.error(error);
    process.exitCode = 1;
  });
 }
 ```
 - [ ] **Step 4: Run test to verify it passes**
 Run: `npm run test -- --run src/__tests__/unit/issue-bot/approve-issue.test.ts`
 Expected: PASS with 2 tests passed.
 - [ ] **Step 5: Commit**
 ```bash
 git add scripts/issue-bot/lib/opencode.ts scripts/issue-bot/approve-issue.ts src/__tests__/unit/issue-bot/approve-issue.test.ts
 git commit -m "feat(issue-bot): approve candidates and launch opencode"
 ```
 ### Task 5: Wire npm Scripts and systemd Units
 **Files:**
 - Modify: `package.json`
 - Modify: `tsconfig.node.json`
 - Create: `extras/systemd/spark-store-issue-bot.service`
 - Create: `extras/systemd/spark-store-issue-bot.timer`
 - Create: `src/__tests__/unit/issue-bot/packaging.test.ts`
 - [ ] **Step 1: Write the failing test**
 ```ts
 import { describe, expect, it } from "vitest";
 import pkg from "../../../../package.json";
 import serviceUnit from "../../../../extras/systemd/spark-store-issue-bot.service?raw";
 import timerUnit from "../../../../extras/systemd/spark-store-issue-bot.timer?raw";
 describe("issue-bot packaging", () => {
  it("adds npm scripts for polling and approval", () => {
    expect(pkg.scripts["issue-bot:check"]).toBe(
      "node --experimental-strip-types scripts/issue-bot/check-issues.ts",
    );
    expect(pkg.scripts["issue-bot:approve"]).toBe(
      "node --experimental-strip-types scripts/issue-bot/approve-issue.ts",
    );
  });
  it("installs a six-hour persistent user timer", () => {
    expect(serviceUnit).toContain("Type=oneshot");
    expect(serviceUnit).toContain(
      "ExecStart=/usr/bin/env npm run issue-bot:check",
    );
    expect(timerUnit).toContain("OnUnitActiveSec=6h");
    expect(timerUnit).toContain("Persistent=true");
  });
 });
 ```
 - [ ] **Step 2: Run test to verify it fails**
 Run: `npm run test -- --run src/__tests__/unit/issue-bot/packaging.test.ts`
 Expected: FAIL with `Failed to resolve import '../../../../extras/systemd/spark-store-issue-bot.service?raw'` and missing package scripts.
 - [ ] **Step 3: Write minimal implementation**
 ```json
 // package.json
 {
  "scripts": {
    "issue-bot:check": "node --experimental-strip-types scripts/issue-bot/check-issues.ts",
    "issue-bot:approve": "node --experimental-strip-types scripts/issue-bot/approve-issue.ts"
  }
 }
 ```
 ```json
 // tsconfig.node.json
 {
  "include": ["vite.config.ts", "package.json", "electron", "scripts"]
 }
 ```
 ```ini
 ; extras/systemd/spark-store-issue-bot.service
 [Unit]
 Description=Spark Store issue bot poller
 [Service]
 Type=oneshot
 WorkingDirectory=%h/Desktop/spark-store
 ExecStart=/usr/bin/env npm run issue-bot:check
 ```
 ```ini
 ; extras/systemd/spark-store-issue-bot.timer
 [Unit]
 Description=Run Spark Store issue bot every 6 hours
 [Timer]
 OnBootSec=15m
 OnUnitActiveSec=6h
 Persistent=true
 Unit=spark-store-issue-bot.service
 [Install]
 WantedBy=timers.target
 ```
 - [ ] **Step 4: Run test to verify it passes**
 Run: `npm run test -- --run src/__tests__/unit/issue-bot/packaging.test.ts`
 Expected: PASS with 2 tests passed.
 - [ ] **Step 5: Commit**
 ```bash
 git add package.json tsconfig.node.json extras/systemd/spark-store-issue-bot.service extras/systemd/spark-store-issue-bot.timer src/__tests__/unit/issue-bot/packaging.test.ts
 git commit -m "chore(issue-bot): wire scripts and timer units"
 ```
 ### Task 6: Run End-to-End Verification
 **Files:**
 - Modify: `scripts/issue-bot/check-issues.ts`
 - Modify: `scripts/issue-bot/approve-issue.ts`
 - Modify: `scripts/issue-bot/lib/gitee.ts`
 - Modify: `scripts/issue-bot/lib/opencode.ts`
 - Modify: `scripts/issue-bot/lib/ranking.ts`
 - Modify: `scripts/issue-bot/lib/state.ts`
 - Modify: `package.json`
 - Modify: `tsconfig.node.json`
 - Create: `extras/systemd/spark-store-issue-bot.service`
 - Create: `extras/systemd/spark-store-issue-bot.timer`
 - Test: `src/__tests__/unit/issue-bot/state.test.ts`
 - Test: `src/__tests__/unit/issue-bot/ranking.test.ts`
 - Test: `src/__tests__/unit/issue-bot/check-issues.test.ts`
 - Test: `src/__tests__/unit/issue-bot/approve-issue.test.ts`
 - Test: `src/__tests__/unit/issue-bot/packaging.test.ts`
 - [ ] **Step 1: Run focused issue-bot tests**
 Run: `npm run test -- --run src/__tests__/unit/issue-bot/state.test.ts src/__tests__/unit/issue-bot/ranking.test.ts src/__tests__/unit/issue-bot/check-issues.test.ts src/__tests__/unit/issue-bot/approve-issue.test.ts src/__tests__/unit/issue-bot/packaging.test.ts`
 Expected: PASS with all issue-bot tests green.
 - [ ] **Step 2: Run lint**
 Run: `npm run lint`
 Expected: PASS with no ESLint errors in `scripts/issue-bot`, `src/__tests__/unit/issue-bot`, and touched config files.
 - [ ] **Step 3: Run build verification**
 Run: `npm run build:vite`
 Expected: PASS with Electron/Vite bundles generated and no TypeScript errors after adding `scripts` to `tsconfig.node.json`.
 - [ ] **Step 4: Manually verify CLI entrypoints**
 Run: `npm run issue-bot:check`
 Expected: `~/.cache/spark-store/issue-bot/state.json` exists and contains either a populated `currentCandidate` or a `lastRunMessage` of `no candidate issues found`.
 Run: `SPARK_STORE_OPENCODE_CMD='printf' npm run issue-bot:approve`
 Expected: command exits successfully and prints the generated prompt containing both `~/Desktop/spark-store` and `Erotica`.
 - [ ] **Step 5: Manually verify systemd units**
 Run: `systemctl --user start spark-store-issue-bot.service`
 Expected: service runs once without unit-file syntax errors.
 Run: `systemctl --user enable --now spark-store-issue-bot.timer`
 Expected: timer is enabled, active, and reports the next run roughly 6 hours later.
 - [ ] **Step 6: Commit**
 ```bash
 git add scripts/issue-bot package.json tsconfig.node.json extras/systemd/spark-store-issue-bot.service extras/systemd/spark-store-issue-bot.timer src/__tests__/unit/issue-bot
 git commit -m "feat(issue-bot): add automated issue polling workflow"
 ```
 ## Self-Review
 ### Spec coverage
 - `systemd --user` timer requirement: covered by Task 5 and Task 6.
 - One-candidate ranking with explainable reasons: covered by Task 2 and Task 3.
 - Manual approval before opencode launch: covered by Task 4.
 - Local cache-backed state with failure retention: covered by Task 1 and Task 3.
 - `~/Desktop/spark-store` + `Erotica` worktree rule in the launch prompt: covered by Task 4 and manual verification in Task 6.
 ### Placeholder scan
 - No `TBD`, `TODO`, or “implement later” placeholders remain.
 - All code-changing steps include concrete code blocks.
 - All verification steps include exact commands and expected outcomes.
 ### Type consistency
 - `NormalizedIssue`, `RankedIssue`, `ApprovedIssue`, and `IssueBotState` are defined in Task 1 and reused consistently in Tasks 2-4.
 - `runIssueBotCheck`, `runIssueBotApproval`, and `launchOpencodeForIssue` names stay unchanged across tests and implementation steps.
@@ -1,152 +0,0 @@
 # Installed Apps Modal Actions Implementation Plan
 > **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
 **Goal:** Restore launch and detail entry points from the installed-apps modal by wiring explicit `打开` and `查看详情` actions back to the existing parent handlers.
 **Architecture:** Keep the fix local to the installed-apps modal and `App.vue`. Add two emitted events from `InstalledAppsModal.vue`, conditionally render the detail action when the app has usable store metadata, and connect those events to the existing `openDownloadedApp()` and `openDetail()` logic in the parent.
 **Tech Stack:** Vue 3, TypeScript, Vitest, Testing Library Vue
 ---
 ## File Structure
 - Modify: `src/components/InstalledAppsModal.vue`
  Responsibility: render open/detail actions for installed app rows and emit events upward.
 - Modify: `src/App.vue`
  Responsibility: wire modal events to existing launch/detail handlers.
 - Modify: `src/__tests__/unit/InstalledAppsModal.test.ts`
  Responsibility: prove action buttons render and emit correctly.
 ### Task 1: Add Failing Modal Tests
 **Files:**
 - Modify: `src/__tests__/unit/InstalledAppsModal.test.ts`
 - [ ] **Step 1: Write failing tests for open/detail actions**
 ```ts
 it("renders open and detail actions for a store-backed installed app", async () => {
  // render with one installed app whose category is not unknown
  // expect 打开 and 查看详情 buttons to exist
 });
 it("emits open-app when clicking 打开", async () => {
  // click open button
  // expect emitted()['open-app']
 });
 it("emits open-detail when clicking 查看详情", async () => {
  // click detail button
  // expect emitted()['open-detail']
 });
 it("hides 查看详情 for unknown-category apps", () => {
  // render app with category unknown
  // expect no 查看详情 button
 });
 ```
 - [ ] **Step 2: Run test to verify it fails**
 Run: `npx vitest run src/__tests__/unit/InstalledAppsModal.test.ts`
 Expected: FAIL because the modal does not yet render or emit the new actions
 ### Task 2: Implement Modal Actions
 **Files:**
 - Modify: `src/components/InstalledAppsModal.vue`
 - Modify: `src/App.vue`
 - [ ] **Step 1: Add minimal modal action rendering and emits**
 ```ts
 defineEmits<{
  (e: "close"): void;
  (e: "refresh"): void;
  (e: "uninstall", app: App): void;
  (e: "switch-origin", origin: "apm" | "spark"): void;
  (e: "open-app", app: App): void;
  (e: "open-detail", app: App): void;
 }>();
 ```
 - [ ] **Step 2: Add a simple detail-eligibility helper**
 ```ts
 const canOpenDetail = (app: App) => {
  return (
    app.category !== "unknown" ||
    Boolean(app.more) ||
    Boolean(app.website) ||
    Boolean(app.author) ||
    (app.img_urls?.length ?? 0) > 0
  );
 };
 ```
 - [ ] **Step 3: Add 打开 / 查看详情 buttons to each row**
 ```vue
 <button type="button" @click="$emit('open-app', app)">打开</button>
 <button
  v-if="canOpenDetail(app)"
  type="button"
  @click="$emit('open-detail', app)"
 >
  查看详情
 </button>
 ```
 - [ ] **Step 4: Wire parent events to existing handlers**
 ```vue
 <InstalledAppsModal
  ...
  @open-app="openDownloadedApp($event.pkgname, $event.origin)"
  @open-detail="openDetail"
 />
 ```
 - [ ] **Step 5: Run test to verify it passes**
 Run: `npx vitest run src/__tests__/unit/InstalledAppsModal.test.ts`
 Expected: PASS
 ### Task 3: Verification And Commit
 **Files:**
 - Modify: `src/components/InstalledAppsModal.vue`
 - Modify: `src/App.vue`
 - Modify: `src/__tests__/unit/InstalledAppsModal.test.ts`
 - [ ] **Step 1: Run focused modal test**
 Run: `npx vitest run src/__tests__/unit/InstalledAppsModal.test.ts`
 Expected: PASS
 - [ ] **Step 2: Run repository lint**
 Run: `npm run lint`
 Expected: exit 0
 - [ ] **Step 3: Run repository build**
 Run: `npm run build:vite`
 Expected: exit 0
 - [ ] **Step 4: Review final diff**
 Run: `git diff -- src/components/InstalledAppsModal.vue src/App.vue src/__tests__/unit/InstalledAppsModal.test.ts docs/superpowers/specs/2026-04-15-installed-apps-modal-actions-design.md docs/superpowers/plans/2026-04-15-installed-apps-modal-actions.md`
 Expected: only installed-app actions and docs changes appear
 - [ ] **Step 5: Commit**
 ```bash
 git add src/components/InstalledAppsModal.vue src/App.vue src/__tests__/unit/InstalledAppsModal.test.ts docs/superpowers/specs/2026-04-15-installed-apps-modal-actions-design.md docs/superpowers/plans/2026-04-15-installed-apps-modal-actions.md
 git commit -m "fix(installed-apps): restore open and detail actions"
 ```
@@ -1,105 +0,0 @@
 # Update Ignore Configuration Implementation Plan
 > **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
 **Goal:** Move update-ignore persistence to user config, add ignore and unignore controls to the Electron update center, and make the legacy Qt updater plus root notifier honor the same `pkg|newVersion` rules.
 **Architecture:** Keep the existing text config format and IPC channels. Change the default config path in the Electron backend, expose ignore actions in the renderer store and item component, align the Qt updater with the same new-version key semantics, and teach the notifier to discover user config files without trusting root `HOME`.
 **Tech Stack:** TypeScript, Vue 3, Electron IPC, Vitest, Qt/C++, POSIX shell
 ---
 ## File Structure
 - Modify: `electron/main/backend/update-center/ignore-config.ts`
  Responsibility: switch the default ignore config path to the user config directory and keep exact `pkg|version` matching.
 - Modify: `electron/main/backend/update-center/service.ts`
  Responsibility: apply ignored sorting after refresh.
 - Modify: `src/modules/updateCenter.ts`
  Responsibility: expose ignore and unignore actions to the renderer.
 - Modify: `src/components/update-center/UpdateCenterItem.vue`
  Responsibility: render ignore and unignore controls for each item.
 - Modify: `src/components/update-center/UpdateCenterList.vue`
  Responsibility: bubble ignore and unignore item events upward.
 - Modify: `src/components/UpdateCenterModal.vue`
  Responsibility: wire ignore and unignore item events to the store.
 - Modify: `src/__tests__/unit/update-center/ignore-config.test.ts`
  Responsibility: prove the new default path resolves to the user config directory.
 - Modify: `src/__tests__/unit/update-center/store.test.ts`
  Responsibility: prove ignore and unignore call the preload bridge and refresh state.
 - Modify: `src/__tests__/unit/update-center/UpdateCenterModal.test.ts`
  Responsibility: prove ignore-state actions render correctly.
 - Modify: `spark-update-tool/src/ignoreconfig.cpp`
  Responsibility: move the Qt config path to the user config directory.
 - Modify: `spark-update-tool/src/ignoreconfig.h`
  Responsibility: support exact unignore by package plus version.
 - Modify: `spark-update-tool/src/appdelegate.cpp`
  Responsibility: emit the target new version when ignoring or unignoring.
 - Modify: `spark-update-tool/src/appdelegate.h`
  Responsibility: update the unignore signal signature.
 - Modify: `spark-update-tool/src/mainwindow.cpp`
  Responsibility: match ignored state against new versions and remove exact entries.
 - Modify: `spark-update-tool/src/mainwindow.h`
  Responsibility: update slot signatures.
 - Modify: `tool/update-upgrade/ss-update-notifier.sh`
  Responsibility: locate user config files from a root service context and filter exact `pkg|newVersion` matches.
 ## Task 1: Electron Ignore Path And Renderer Actions
 **Files:**
 - Modify: `electron/main/backend/update-center/ignore-config.ts`
 - Modify: `electron/main/backend/update-center/service.ts`
 - Modify: `src/modules/updateCenter.ts`
 - Modify: `src/components/update-center/UpdateCenterItem.vue`
 - Modify: `src/components/update-center/UpdateCenterList.vue`
 - Modify: `src/components/UpdateCenterModal.vue`
 - Modify: `src/__tests__/unit/update-center/ignore-config.test.ts`
 - Modify: `src/__tests__/unit/update-center/store.test.ts`
 - Modify: `src/__tests__/unit/update-center/UpdateCenterModal.test.ts`
 - [ ] Write failing tests for the new user config path, ignore/unignore store methods, and item actions.
 - [ ] Run `npx vitest run src/__tests__/unit/update-center/ignore-config.test.ts src/__tests__/unit/update-center/store.test.ts src/__tests__/unit/update-center/UpdateCenterModal.test.ts` and confirm they fail for the expected reasons.
 - [ ] Implement the minimal backend path change, item sorting, renderer store methods, and modal wiring.
 - [ ] Re-run the same Vitest command and confirm it passes.
 ## Task 2: Legacy Qt Updater Alignment
 **Files:**
 - Modify: `spark-update-tool/src/ignoreconfig.cpp`
 - Modify: `spark-update-tool/src/ignoreconfig.h`
 - Modify: `spark-update-tool/src/appdelegate.cpp`
 - Modify: `spark-update-tool/src/appdelegate.h`
 - Modify: `spark-update-tool/src/mainwindow.cpp`
 - Modify: `spark-update-tool/src/mainwindow.h`
 - [ ] Change Qt config path resolution to `QStandardPaths::ConfigLocation/spark-store/ignored_apps.conf`.
 - [ ] Switch ignore and unignore to use `packageName + newVersion` exact entries.
 - [ ] Build-check the Qt target if a local build command is available.
 ## Task 3: Root Notifier User Config Discovery
 **Files:**
 - Modify: `tool/update-upgrade/ss-update-notifier.sh`
 - [ ] Add shell helpers to detect a desktop user home when possible.
 - [ ] Add fallback scanning across `/home/*/.config/spark-store/ignored_apps.conf`.
 - [ ] Merge all discovered config files into one ignore set.
 - [ ] Filter updates by exact `pkg|newVersion` instead of package-only.
 - [ ] Run `bash -n tool/update-upgrade/ss-update-notifier.sh` and confirm syntax is valid.
 ## Task 4: Verification And Commit
 **Files:**
 - Modify: tracked files from Tasks 1-3
 - [ ] Run `npx vitest run src/__tests__/unit/update-center/ignore-config.test.ts src/__tests__/unit/update-center/store.test.ts src/__tests__/unit/update-center/UpdateCenterModal.test.ts`.
 - [ ] Run `npm run lint`.
 - [ ] Run `npm run build`.
 - [ ] Run `bash -n tool/update-upgrade/ss-update-notifier.sh`.
 - [ ] Review the final diff.
 - [ ] Create a commit with a message in repository style.
@@ -1,157 +0,0 @@
 # Update Notifier APM Aggregation Implementation Plan
 > **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
 **Goal:** Extend `tool/update-upgrade/ss-update-notifier.sh` so one notifier aggregates effective Spark and APM updates, honoring `hold` status and shared ignored entries while skipping the Spark branch when `aptss` is unavailable.
 **Architecture:** Keep the current notifier script as the single entrypoint and add a second APM counting branch beside the existing Spark branch. Reuse the existing ignored-entry loading logic, count Spark and APM updates independently after source-specific filtering, then combine the remaining counts into one notification.
 **Tech Stack:** Bash, aptss, apm, amber-pm-debug, dpkg-query
 ---
 ## File Structure
 - Modify: `tool/update-upgrade/ss-update-notifier.sh`
  Responsibility: add APM update parsing and counting, guard Spark execution behind `aptss` availability, reuse ignored-entry filtering for both branches, and keep one aggregated notification path.
 ### Task 1: Add Source-Specific Counting Helpers
 **Files:**
 - Modify: `tool/update-upgrade/ss-update-notifier.sh`
 - [ ] **Step 1: Write the failing shell behavior expectation as comments in the plan**
 ```bash
 # Expected behavior after implementation:
 # 1. If aptss is missing, the script does not call aptss update/ssupdate.
 # 2. If apm reports upgradable apps, ignored pkg|newVersion entries suppress them.
 # 3. Spark and APM effective counts are added into one final count.
 ```
 - [ ] **Step 2: Run syntax check before changes**
 Run: `bash -n tool/update-upgrade/ss-update-notifier.sh`
 Expected: exit 0
 - [ ] **Step 3: Add minimal helper functions for APM parsing and per-source counting**
 ```bash
 function has-command() {
    command -v "$1" >/dev/null 2>&1
 }
 function get_apm_upgradable_list() {
    local output
    output=$(env LANGUAGE=en_US apm list --upgradable 2>/dev/null | awk 'NR>1')
    local ifs_old="$IFS"
    IFS=$'\n'
    for line in $output; do
        local pkg_name
        local pkg_new_ver
        local pkg_cur_ver
        pkg_name=$(echo "$line" | awk -F '/' '{print $1}')
        pkg_new_ver=$(echo "$line" | awk '{print $2}')
        pkg_cur_ver=$(printf '%s\n' "$line" | sed -n 's/.*\[\(upgradable from\|from\):[[:space:]]*\([^]]*\)\].*/\2/p')
        if [ -n "$pkg_name" ] && [ -n "$pkg_new_ver" ] && [ -n "$pkg_cur_ver" ]; then
            echo "$pkg_name $pkg_new_ver $pkg_cur_ver"
        fi
    done
    IFS="$ifs_old"
 }
 ```
 - [ ] **Step 4: Re-run syntax check after helper changes**
 Run: `bash -n tool/update-upgrade/ss-update-notifier.sh`
 Expected: exit 0
 ### Task 2: Aggregate Spark And APM Effective Counts
 **Files:**
 - Modify: `tool/update-upgrade/ss-update-notifier.sh`
 - [ ] **Step 1: Guard Spark refresh and counting behind aptss availability**
 ```bash
 spark_update_count=0
 if has-command aptss; then
    # existing aptss update / aptss ssupdate logic
    # existing spark upgradable counting logic
 fi
 ```
 - [ ] **Step 2: Add APM refresh and counting branch with hold + ignored filtering**
 ```bash
 apm_update_count=0
 if has-command apm; then
    updatetext=$(LANGUAGE=en_US apm update 2>&1)
    # retry loop matching current script style
    apm clean
    PKG_LIST="$(get_apm_upgradable_list)"
    apm_update_count=$(printf '%s\n' "$PKG_LIST" | awk 'NF { count++ } END { print count + 0 }')
    # for each package:
    # - skip if new <= current
    # - skip if amber-pm-debug dpkg-query says hold
    # - skip if ignored_apps["$PKG_NAME|$PKG_NEW_VER"] exists
    # - otherwise increment apm_update_count
 fi
 ```
 - [ ] **Step 3: Replace single-source final count with aggregated count**
 ```bash
 update_app_number=$((spark_update_count + apm_update_count))
 if [ "$update_app_number" -le 0 ]; then
    exit 0
 fi
 ```
 - [ ] **Step 4: Keep one final notification path**
 ```bash
 notify-send -a spark-store \
  "${TRANSHELL_CONTENT_SPARK_STORE_UPGRADE_NOTIFY}" \
  "${TRANSHELL_CONTENT_THERE_ARE_APPS_TO_UPGRADE}" || true
 ```
 - [ ] **Step 5: Re-run syntax check after aggregation changes**
 Run: `bash -n tool/update-upgrade/ss-update-notifier.sh`
 Expected: exit 0
 ### Task 3: Verification And Commit
 **Files:**
 - Modify: `tool/update-upgrade/ss-update-notifier.sh`
 - [ ] **Step 1: Run notifier syntax verification**
 Run: `bash -n tool/update-upgrade/ss-update-notifier.sh`
 Expected: exit 0
 - [ ] **Step 2: Run repository lint**
 Run: `npm run lint`
 Expected: exit 0
 - [ ] **Step 3: Run repository build**
 Run: `npm run build:vite`
 Expected: exit 0
 - [ ] **Step 4: Review final diff**
 Run: `git diff -- tool/update-upgrade/ss-update-notifier.sh docs/superpowers/specs/2026-04-15-update-notifier-apm-aggregation-design.md docs/superpowers/plans/2026-04-15-update-notifier-apm-aggregation.md`
 Expected: only notifier aggregation and spec/plan changes appear
 - [ ] **Step 5: Commit**
 ```bash
 git add tool/update-upgrade/ss-update-notifier.sh docs/superpowers/specs/2026-04-15-update-notifier-apm-aggregation-design.md docs/superpowers/plans/2026-04-15-update-notifier-apm-aggregation.md
 git commit -m "fix(update): 聚合 Spark 和 APM 升级通知"
 ```
@@ -1,229 +0,0 @@
 # 更新中心图标逐级回退设计
 ## 背景
 当前更新中心的图标解析分成两段：
 1. 主进程 `electron/main/backend/update-center/icons.ts` 会优先解析本地图标，解析不到时再直接返回线上图标 URL。
 2. 渲染层 `src/components/update-center/UpdateCenterItem.vue` 只接收单个 `icon` 字段，图片加载失败后直接回退到默认占位图。
 这个结构已经满足“本地优先”的静态选择，但不能满足新的行为要求：
 1. 当本地图标成功加载时，不再请求线上图标和默认图标。
 2. 当本地图标路径虽然存在、但实际加载失败时，继续尝试线上图标。
 3. 当线上图标也失败时，最后才回退到默认占位图。
 问题根因不是路径优先级判断错误，而是当前前后端只传递了一个最终 `icon` 值，导致前端无法在运行时根据真实加载结果继续尝试下一层来源。
 ## 目标
 1. 更新中心图标加载顺序固定为：`localIcon -> remoteIcon -> placeholder`。
 2. 本地图标加载成功时，不再加载线上图标和默认图标。
 3. 本地图标加载失败时，自动切换到线上图标。
 4. 线上图标也失败时，才显示默认占位图。
 5. 保持当前更新中心列表布局、图标尺寸和已有解析路径规则不变。
 ## 非目标
 1. 不改动主商店、已安装列表或其他页面的图标逻辑。
 2. 不增加新的网络探测请求，也不预检远程图标是否可访问。
 3. 不重构现有本地图标解析算法，只调整数据结构和回退链路。
 4. 不引入通用的图标来源数组或复杂图标对象。
 ## 方案选择
 本次考虑过三种方案：
 1. 后端透传 `localIcon` 和 `remoteIcon` 两个字段，前端顺序尝试。
 2. 后端透传 `iconCandidates: string[]`，前端按数组顺序尝试。
 3. 继续只传一个 `icon`，前端根据 `pkgname/category/arch` 自己重新拼线上图标地址。
 最终选择方案 1。
 原因：
 1. 它刚好对应本次明确的三级回退需求，最小且直接。
 2. 后端继续掌握图标来源规则，避免前端复制商店 URL 规则。
 3. 相比数组方案，双字段更易读、更容易在 IPC 类型中维护。
 4. 前端只负责“加载失败后切换到下一来源”，职责边界清晰。
 ## 设计概览
 更新中心改为“主进程解析来源，渲染层控制加载顺序”的结构：
 1. 主进程为每个更新项分别计算 `localIcon` 和 `remoteIcon`。
 2. 服务层和前端类型透传这两个字段。
 3. `UpdateCenterItem.vue` 按 `localIcon -> remoteIcon -> placeholder` 的顺序逐级尝试。
 4. 候选图标一旦成功加载，组件不再切换到后续来源。
 ## 数据结构变更
 ### 主进程类型
 修改：`electron/main/backend/update-center/types.ts`
 将：
 ```ts
 icon?: string;
 ```
 改为：
 ```ts
 localIcon?: string;
 remoteIcon?: string;
 ```
 ### Service Snapshot
 修改：`electron/main/backend/update-center/service.ts`
 更新 renderer-facing item/task 类型，并在 `toState()` 中透传：
 ```ts
 localIcon?: string;
 remoteIcon?: string;
 ```
 ### 渲染层类型
 修改：`src/global/typedefinition.ts`
 更新 `UpdateCenterItem` 和 `UpdateCenterTaskState`：
 ```ts
 localIcon?: string;
 remoteIcon?: string;
 ```
 ## 模块边界
 ### `electron/main/backend/update-center/icons.ts`
 保留现有职责，但返回内容从“单个最终图标”调整为“两种候选来源”：
 1. `resolveDesktopIcon(pkgname)`：解析传统 deb / aptss 更新项的本地图标。
 2. `resolveApmIcon(pkgname)`：解析 APM 更新项的本地图标。
 3. `buildRemoteFallbackIconUrl(item)`：拼接远程商店图标地址。
 4. `resolveUpdateItemIcons(item)`：组合出 `{ localIcon?, remoteIcon? }`。
 这里不再提前做“本地失败就直接放弃线上”的最终决策，而是把两个候选来源都准备好交给前端。
 ### `electron/main/backend/update-center/index.ts`
 在更新项 enrichment 阶段，将：
 1. 现有的单 `icon` 注入逻辑。
 调整为：
 1. 读取 `resolveUpdateItemIcons(item)` 的结果。
 2. 仅在字段存在时把 `localIcon` / `remoteIcon` 写回更新项。
 ### `src/components/update-center/UpdateCenterItem.vue`
 组件不再把单个 `item.icon` 当成最终地址，而是：
 1. 从 `item.localIcon` 和 `item.remoteIcon` 派生候选列表。
 2. 使用当前索引决定 `img.src`。
 3. 失败时切到下一候选项。
 4. 候选项耗尽后切到占位图。
 ## 详细数据流
 ### 主进程加载更新项
 1. 更新中心主进程加载更新项。
 2. 现有逻辑继续补齐 `category`、`arch` 等字段。
 3. 图标模块为每个项分别解析：
   - `localIcon`：本地图标路径。
   - `remoteIcon`：线上图标 URL。
 4. enrichment 后的更新项通过 service snapshot 发送到渲染层。
 ### 渲染层展示更新项
 1. 组件收到 `item.localIcon` / `item.remoteIcon`。
 2. 组件构造一个有序候选列表：
   - 本地路径转换为 `file://` URL。
   - 远程 URL 原样使用。
 3. 初始渲染第 1 个候选图标。
 4. 如果 `img` 加载成功，流程结束，不再切换到下一项。
 5. 如果 `img` 触发 `error`，索引递增，继续尝试下一候选图标。
 6. 如果所有候选都失败，切换到占位图。
 ## 前端行为细节
 ### 候选列表生成规则
 候选列表只包含存在且非空的来源：
 1. `localIcon` 存在时放在第 1 位。
 2. `remoteIcon` 存在时放在第 2 位。
 3. 占位图不放入候选列表，而是在候选耗尽后单独回退。
 这样可以避免：
 1. 本地图标成功时还额外发起线上请求。
 2. 图标字段为空时出现无意义的重试。
 ### 状态重置规则
 当 `props.item` 变为新的更新项对象时：
 1. 重置当前候选索引到第 1 项。
 2. 清空“候选已耗尽”的状态。
 3. 重新开始本地优先的尝试流程。
 这样可确保列表复用或重新渲染时，新条目不会继承上一条目的失败状态。
 ### 占位图规则
 保留当前组件内默认占位 SVG，不改样式和尺寸。
 只有在以下情况下才使用占位图：
 1. `localIcon` 和 `remoteIcon` 都不存在。
 2. `localIcon` 加载失败且 `remoteIcon` 不存在。
 3. `localIcon` 和 `remoteIcon` 都加载失败。
 ## 错误处理
 1. 本地图标路径不存在或不可读：允许浏览器触发加载失败，再由前端切到线上图标。
 2. 远程图标返回 404、超时或其他加载错误：前端切到占位图，不向用户弹额外错误。
 3. 后端无法推断 `category` 或 `arch`：允许 `remoteIcon` 为空，前端只尝试本地图标和占位图。
 4. 任一图标来源失败都不能影响更新列表正文、状态标签和进度条显示。
 ## 测试方案
 ### 后端测试
 扩展 `src/__tests__/unit/update-center/icons.test.ts`：
 1. 本地图标可解析时，`resolveUpdateItemIcons()` 返回 `localIcon`，并在条件满足时同时包含 `remoteIcon`。
 2. 本地图标缺失时，仍可返回 `remoteIcon`。
 3. 缺少 `category` 或 `arch` 时，不返回 `remoteIcon`。
 4. 两者都不可得时，返回空对象。
 ### 组件测试
 扩展 `src/__tests__/unit/update-center/UpdateCenterItem.test.ts`：
 1. 有 `localIcon` 时先渲染本地 `file://` 地址。
 2. 本地图标未失败前，不切换到 `remoteIcon`。
 3. 本地图标触发 `error` 后切到 `remoteIcon`。
 4. 本地和线上都触发 `error` 后切到默认占位图。
 5. 切换到新的 `item` 后，回退状态会重置。
 ## 风险与约束
 1. 如果某些包的本地图标路径在后端看来存在，但渲染进程实际不可访问，仍会触发一次失败请求；这是预期行为，因为它正是继续尝试线上图标的触发条件。
 2. 远程图标 URL 继续依赖当前商店路径规则，若个别包没有线上图标，最终仍会使用占位图。
 3. 本次只调整更新中心图标链路，不同步抽象其他页面，避免扩大改动范围。
 ## 决策总结
 1. 用 `localIcon` 和 `remoteIcon` 替代单个 `icon` 字段。
 2. 主进程负责解析来源，渲染层负责按顺序加载和失败回退。
 3. 固定回退顺序为：本地图标 -> 线上图标 -> 默认占位图。
 4. 本地图标成功时，不再加载线上图标和默认图标。
@@ -1,214 +0,0 @@
 # 更新中心列表图标设计
 ## 背景
 当前 Electron 更新中心已经可以展示更新项、来源、迁移标记、进度和日志，但更新列表仍然只有文字信息，没有应用图标。对于 APM 包、传统 deb 包和迁移项，纯文字列表会降低识别效率，尤其在批量更新和搜索场景下不够直观。
 仓库现状里已经存在多套可复用的图标来源逻辑：
 1. 主商店卡片通过远程商店 URL 拼接 `icon.png`。
 2. 已安装应用列表支持本地图标和远程 URL 双来源。
 3. 旧 Qt 更新器会为 APM 更新项解析 desktop 与 entries/icons，并在无本地图标时继续使用其他数据源。
 目标是在更新中心列表中加入应用图标，同时保持最小改动、兼容当前后端结构，并遵循“本地解析优先，其次远程 URL，最后占位图标”的策略。
 ## 目标
 1. 在更新中心列表中为每个更新项展示应用图标。
 2. 图标来源优先级为：本地解析 > 远程 URL > 前端占位图标。
 3. 前后端仅增加一个最小公共字段，不引入复杂的图标对象结构。
 4. 图标缺失或加载失败时，界面仍然保持稳定、整齐、不闪烁。
 ## 非目标
 1. 不为图标来源新增额外网络探测请求。
 2. 不在本次设计中重构应用详情页、已安装列表或主商店卡片的图标逻辑。
 3. 不在 UI 中展示“图标来源”说明文字。
 ## 方案概览
 采用“主进程解析来源、渲染层只展示”的方案：
 1. 更新中心主进程在加载更新项时解析图标来源，并将结果写入更新项的 `icon` 字段。
 2. 渲染层更新列表只消费 `item.icon`，不参与解析来源。
 3. 前端负责单次图片加载失败回退到占位图标。
 ## 数据结构变化
 ### 主进程
 修改：`electron/main/backend/update-center/types.ts`
 为 `UpdateCenterItem` 增加：
 ```ts
 icon?: string;
 ```
 ### 渲染层
 修改：`src/global/typedefinition.ts`
 为 `UpdateCenterItem` 增加：
 ```ts
 icon?: string;
 ```
 ### Service 映射
 修改：`electron/main/backend/update-center/service.ts`
 在主进程 snapshot -> renderer snapshot 的映射中透传 `icon` 字段。
 ## 图标来源策略
 ### 优先级
 每个更新项统一按以下顺序取图标：
 1. 本地图标路径
 2. 远程商店图标 URL
 3. 前端占位图标
 ### 1. 本地图标路径
 #### 传统 deb / Spark 更新项
 优先复用仓库中已有的 desktop 文件扫描与 `Icon=` 解析思路，来源参考：
 - `electron/main/backend/install-manager.ts`
 解析策略：
 1. 从已安装包对应的 desktop 文件中读取 `Icon=`。
 2. 如果解析结果为绝对路径，直接返回。
 3. 如果解析结果为图标名，则尝试根据系统图标路径补全。
 4. 若无法得到有效路径，则继续下一层来源。
 #### APM 更新项
 优先复用旧 Qt 更新器已存在的 APM 图标解析逻辑，来源参考：
 - `spark-update-tool/src/aptssupdater.cpp`
 解析策略：
 1. 查找 APM 包的 `entries/applications/*.desktop`。
 2. 从 desktop 的 `Icon=` 字段中解析图标。
 3. 若 `Icon=` 为绝对路径，直接返回。
 4. 若 `Icon=` 为图标名，则尝试拼接 APM 包内 `entries/icons/...` 路径。
 5. 若仍无结果，则继续下一层来源。
 ### 2. 远程商店图标 URL
 如果本地图标解析失败，则为更新项生成远程图标 URL。
 实现原则：
 1. 不主动探测 URL 是否可用。
 2. 仅按现有商店规则拼接 URL，并交给浏览器加载。
 3. 浏览器加载失败后由前端回退占位图标。
 对 Spark/传统 deb：
 1. 使用当前商店已有的远程图标拼接规则。
 2. 若更新项可以推断出对应 category 和 arch，则拼接：
   `${APM_STORE_BASE_URL}/${arch}/${category}/${pkgname}/icon.png`
 对 APM：
 1. 若仓库中已有 APM 对应商店资源约定，则使用同样的 `icon.png` 规则。
 2. 若当前数据无法可靠推断 category，则允许直接跳过远程 URL，进入前端占位图标。
 ### 3. 占位图标
 如果主进程未能提供 `icon`，或者前端加载失败，则使用统一占位图标。
 占位规则：
 1. 图标尺寸与正常图标一致。
 2. 使用仓库现有品牌资源或统一默认应用图标。
 3. 不因失败状态改变列表布局高度或间距。
 ## 模块边界
 新增：
 - `electron/main/backend/update-center/icons.ts`
 职责：
 1. `resolveUpdateItemIcon()`
 2. `resolveApmIcon()`
 3. `resolveDesktopIcon()`
 4. `buildRemoteFallbackIconUrl()`
 该模块只负责“根据更新项得到一个 `icon?: string`”，不参与更新队列、安装、刷新、忽略等逻辑。
 ## 数据流
 ### 主进程加载更新项
 1. 查询并合并更新项。
 2. 对每个更新项执行图标解析。
 3. 将解析到的 `icon` 字段写入 `UpdateCenterItem`。
 4. 由 `service.ts` 将该字段透传到渲染层 snapshot。
 ### 渲染层展示
 1. `UpdateCenterItem.vue` 读取 `item.icon`。
 2. 如果 `item.icon` 为本地绝对路径，则转成 `file://` URL。
 3. 如果 `item.icon` 为远程 URL，则直接作为图片地址使用。
 4. 若图片加载失败，则切换为占位图标，并记住失败状态避免重复尝试。
 ## UI 设计
 ### 列表项布局
 在更新列表中新增一个固定图标位：
 1. 位置：复选框后、应用信息前。
 2. 尺寸：`40x40`。
 3. 样式：圆角矩形，视觉与商店应用卡片图标一致。
 4. 图标位固定占位，避免有图和无图的项出现布局跳动。
 ### 失败回退
 前端仅做一次失败回退：
 1. 优先渲染 `item.icon`。
 2. 触发 `@error` 后切换为占位图。
 3. 记录该项失败状态，避免反复向无效地址重新请求。
 ## 测试方案
 ### 主进程测试
 新增或扩展测试覆盖：
 1. 本地图标优先于远程 URL。
 2. APM 更新项可解析包内 desktop/icons。
 3. 传统 deb 更新项可解析 desktop `Icon=`。
 4. 无本地图标时能生成远程 URL 或返回空值。
 ### 组件测试
 扩展 `UpdateCenterItem.vue` 组件测试：
 1. 有 `item.icon` 时渲染图片。
 2. 图片加载失败时回退到占位图。
 3. 图标存在时不影响当前状态标签、迁移标签、进度条显示。
 ## 风险与约束
 1. 更新项当前不一定总能推断出 category，因此远程 URL 兜底对部分项可能不可用；这是可接受的，因为前端还有占位图兜底。
 2. 本地图标解析涉及多个来源路径，必须限制在读取路径和拼接路径，不做额外昂贵的同步探测。
 3. APM 图标路径依赖当前系统安装结构，若个别包结构不标准，应直接退回远程或占位图，而不是阻断更新列表。
 ## 决策总结
 1. 更新中心增加单字段 `icon?: string`，不引入复杂图标对象。
 2. 主进程解析图标来源，渲染层只负责展示和失败回退。
 3. 图标来源顺序固定为：本地解析 > 远程 URL > 占位图。
 4. UI 仅新增稳定图标位，不改变现有更新列表信息层级。
@@ -1,169 +0,0 @@
 # 更新中心迁移更新策略设计
 ## 背景
 当前更新中心会同时拉取 `aptss` 和 `apm` 的可更新列表，并按包名合并展示。现有行为中，双源同名更新通常会显示两条记录；即使标记了“迁移”，也不会真正执行“卸载 aptss 后安装 apm”的迁移流程。
 目标是把更新策略调整为以已安装来源为主，并在 `aptss -> apm` 迁移场景中提供明确、单一且可确认的更新入口。
 ## 目标行为
 ### 1. 仅安装了 aptss 版本
 - 同时检查 `aptss` 和 `apm` 是否有同名更新。
 - 如果只有 `aptss` 有更新：显示一条普通 `aptss` 更新记录。
 - 如果 `apm` 也有同名更新，且 `apm` 的目标版本高于 `aptss`：
  - 只显示一条迁移更新记录。
  - 该记录的展示语义为“将迁移到 APM 管理”。
  - 不再显示对应的普通 `aptss` 更新记录。
 - 用户确认迁移后，执行：
  1. `shell-caller.sh aptss remove <pkg>`
  2. 安装 `apm` 版本。
 ### 2. 仅安装了 apm 版本
 - 只检查并展示 `apm` 的同名更新。
 - 即使 `aptss` 存在同名更新，也不在更新中心中展示。
 ### 3. 同时安装了 aptss 与 apm 版本
 - 同时展示两条更新记录。
 - `aptss` 记录更新 `aptss` 安装位置。
 - `apm` 记录更新 `apm` 安装位置。
 - 两条记录互不替代，也不触发迁移逻辑。
 ## 数据模型调整
 ### UpdateCenterItem
 保留现有字段，并继续使用以下迁移字段：
 - `isMigration?: boolean`
 - `migrationSource?: "aptss" | "apm"`
 - `migrationTarget?: "aptss" | "apm"`
 - `aptssVersion?: string`
 迁移记录仍以 `source: "apm"` 表示最终安装来源，但其语义从“推荐迁移”改为“唯一展示的迁移更新入口”。
 ## 列表合并规则
 更新 `mergeUpdateSources()` 的逻辑，使其按安装来源状态决定展示结果，而不是单纯把双源结果并列展示。
 ### 情况 A：仅 aptss 安装
 条件：`installedState.aptss === true && installedState.apm === false`
 - 若只有 `aptss` 更新：返回 `aptss` 记录。
 - 若只有 `apm` 更新：不展示该条记录。
 - 若两者都有：
  - 如果 `apm.nextVersion > aptss.nextVersion`：
    - 只返回一条迁移记录，基于 `apmItem` 构造。
    - 设置 `isMigration: true`、`migrationSource: "aptss"`、`migrationTarget: "apm"`。
    - 保存 `aptssVersion` 供 UI 展示。
  - 否则：只返回 `aptss` 记录。
 ### 情况 B：仅 apm 安装
 条件：`installedState.aptss === false && installedState.apm === true`
 - 若 `apm` 有更新：返回 `apm` 记录。
 - 忽略同名 `aptss` 更新。
 ### 情况 C：同时安装 aptss 与 apm
 条件：`installedState.aptss === true && installedState.apm === true`
 - 若两者都有更新：同时返回两条记录。
 - 若只有其中一方有更新：只返回对应来源的记录。
 ### 情况 D：未识别安装来源
 - 保持保守策略：按现有回退方式展示已有更新项。
 - 这个分支仅用于防止源状态解析异常时整个列表为空。
 ## 前端交互
 ### 迁移确认弹窗
 当用户选择的更新项中包含 `isMigration === true` 的记录时，继续弹出迁移确认框。
 文案需要明确以下信息：
 - 该应用将从传统 `aptss` 管理迁移到 `APM` 管理。
 - 迁移过程会先卸载现有 `aptss` 版本，再安装 `APM` 版本。
 - 迁移后，该应用后续更新将由 `APM` 管理。
 ### 下载队列表现
 - 迁移任务加入下载队列时，名称与图标沿用更新中心项。
 - 队列项可继续显示为 `origin: "apm"`，因为最终安装目标是 `apm`。
 - 日志首条应明确表明这是迁移更新，而不是普通更新。
 ## 执行链路
 ### 当前问题
 当前更新中心点击更新后，只是把任务交给现有下载/安装队列；迁移任务并不会真正先卸载 `aptss`。
 ### 新执行方式
 对于 `isMigration === true` 的任务：
 1. 创建更新任务并进入现有下载/安装队列。
 2. 在主进程的更新中心执行链路中识别该任务为迁移任务。
 3. 先调用：
   - `shell-caller.sh aptss remove <pkg>`
 4. 若卸载成功，再继续现有 `apm` 安装流程。
 5. 若卸载失败：
   - 不进入 `apm` 安装。
   - 将任务标记为失败。
   - 将错误信息推送到下载日志与更新中心状态。
 ### 失败处理
 - `aptss remove` 失败：
  - 整个迁移任务失败。
  - 保留用户现有安装状态，不做后续安装。
 - `aptss remove` 成功但 `apm` 安装失败：
  - 任务失败。
  - 不做自动回滚。
  - 在日志中明确说明：旧版本已卸载，新版本安装失败，需要用户重试。
 本次实现不加入自动回滚，避免在失败分支里引入额外高风险操作。
 ## 受影响模块
 - `electron/main/backend/update-center/query.ts`
  - 重写合并规则。
 - `electron/main/backend/update-center/service.ts`
  - 保持迁移标记透传，并为后续执行提供足够字段。
 - `electron/main/backend/install-manager.ts` 或迁移任务真正进入的主进程安装执行层
  - 为迁移任务增加“先 aptss remove，再 apm install”的顺序执行。
 - `src/components/update-center/UpdateCenterMigrationConfirm.vue`
  - 更新提示文案。
 - `src/modules/updateCenter.ts`
  - 保持迁移项进入下载队列时的展示信息正确。
 ## 测试策略
 需要新增或调整以下测试：
 - `mergeUpdateSources()` 单元测试：
  - 仅 aptss 安装 + apm 更高版本 -> 仅返回一条迁移记录。
  - 仅 aptss 安装 + apm 不更高 -> 仅返回 aptss 记录。
  - 仅 apm 安装 + 双源同名更新 -> 仅返回 apm 记录。
  - 双方都安装 + 双源同名更新 -> 返回两条记录。
 - 更新中心服务/IPC 测试：
  - 迁移任务被正确标记并透传。
 - 安装执行测试：
  - 迁移任务先执行 `shell-caller.sh aptss remove <pkg>`。
  - 卸载失败时不会继续安装 `apm`。
  - 卸载成功后继续执行 `apm` 安装流程。
 - 前端测试：
  - 迁移弹窗文案与触发条件正确。
 ## 非目标
 - 不实现迁移失败后的自动回滚。
 - 不修改普通 `aptss` 或普通 `apm` 更新的现有安装流程。
 - 不改变“双安装”场景下两条记录并存的行为。
@@ -1,196 +0,0 @@
 # 更新中心 Spark 更新命令设计
 ## 背景
 当前 Electron 更新中心对 `aptss` 来源的更新项仍保留一条旧路径：当任务没有本地下载文件时，直接执行 `shell-caller.sh aptss install -y <pkg> --only-upgrade`。这条路径会在宿主系统里直接升级软件包，但不会复用 Qt 更新器已经采用的“先下载 deb，再通过 `ssinstall` 安装”的流程。
 仓库里已经存在一个更贴近更新器预期的行为参考：旧 Qt 更新器在安装 `aptss` 来源更新时，会对下载好的 deb 调用 `ssinstall`，并带上“不创建桌面快捷方式”和“安装后删除下载文件”等参数。
 本次需求是：仅对 Electron 更新中心生效，把 Spark 软件包更新改为走 `shell-caller` 顶层 `ssinstall` 路径，同时避免更新时创建新的桌面项。
 ## 目标
 1. Electron 更新中心处理 `aptss` 更新时，统一改为“下载 deb -> `shell-caller.sh ssinstall` 安装”。
 2. 更新时传入 `ssinstall` 的“不创建桌面项”参数，避免更新流程额外生成桌面快捷方式。
 3. 变更只作用于 Electron 更新中心，不影响普通安装流、APM 更新流和 `extras/shell-caller.sh` 的白名单行为。
 4. 继续沿用现有提权方式：若存在 `pkexec`，仍通过 `pkexec /opt/spark-store/extras/shell-caller.sh ...` 执行。
 ## 非目标
 1. 不修改 `electron/main/backend/install-manager.ts` 的普通安装逻辑。
 2. 不修改 `apm` 来源更新的下载与安装方式。
 3. 不扩展 `extras/shell-caller.sh` 以支持新的 `aptss ssinstall` 子命令形式。
 4. 不修改旧 Qt 更新器行为；它只作为现有参考实现。
 ## 已确认的命令约束
 ### shell-caller 约束
 当前仓库内的 `extras/shell-caller.sh` 只支持 3 个顶层命令类型：
 1. `apm`
 2. `aptss`
 3. `ssinstall`
 其中 `aptss` 仅允许 `install` 和 `remove` 两个子命令，不支持 `aptss ssinstall ...`。因此，本次实现不会尝试新增 `shell-caller aptss ssinstall` 这种调用形式，而是直接使用已存在的顶层 `ssinstall` 入口。
 ### ssinstall 参数名
 本机 `ssinstall --help` 显示的真实参数名是：
 ```bash
 --no-create-desktop-entry
 ```
 因此，需求里口头表达的 `--no-create-desktop` 会在实现中落到 `--no-create-desktop-entry`，避免引入不存在的参数名。
 ## 现状问题
 当前更新中心后端只有 APM 更新项会在刷新阶段补齐 `downloadUrl`、`fileName`、`size` 和 `sha512` 等下载元数据。`aptss` 更新项只来自 `apt list --upgradable` 的文本解析结果，因此：
 1. `aptss` 更新项通常没有可下载 deb 的元数据。
 2. 没有 deb 文件时，安装逻辑会退回旧的 `aptss install --only-upgrade` 命令。
 3. 这使得 Electron 更新中心无法像 Qt 更新器那样稳定走 `ssinstall` 路径。
 ## 方案概览
 采用“刷新阶段补齐 `aptss` 下载元数据，执行阶段统一走 `ssinstall`”的方案。
 整体流程如下：
 1. 刷新更新列表时，继续查询 `aptss` 的可升级包。
 2. 对每个 `aptss` 更新项额外查询 `apt download --print-uris` 元数据。
 3. 只有拿到 `downloadUrl` 和 `fileName` 的 `aptss` 更新项才进入最终更新列表。
 4. 执行更新任务时，先下载对应 deb。
 5. 下载完成后调用 `shell-caller.sh ssinstall <deb> --no-create-desktop-entry --delete-after-install`。
 6. 若存在提权命令，则实际执行 `pkexec /opt/spark-store/extras/shell-caller.sh ssinstall ...`。
 这样可以让 Electron 更新中心的 `aptss` 更新行为与 Qt 更新器保持一致，同时严格限定在更新中心内部，不影响商店其他安装入口。
 ## 模块变更
 ### 1. `electron/main/backend/update-center/index.ts`
 新增 `aptss` 下载元数据补全逻辑，方式与现有 APM 元数据补全保持一致。
 建议变更：
 1. 新增一个 `aptss` 的 `print-uris` 命令构造函数，复用当前 `apt-fast` 配置与源列表参数。
 2. 复用现有 `parsePrintUrisOutput()` 解析函数，不新增第二套解析器。
 3. 为 `aptss` 更新项新增与 APM 相同的元数据补全过程。
 4. 元数据查询失败的 `aptss` 项从最终可更新列表中剔除，并写入 warning。
 这样做的原因是：更新中心一旦展示某个更新项，就应该能够实际完成下载和安装，而不是在任务执行阶段才发现缺少 deb 元数据。
 ### 2. `electron/main/backend/update-center/install.ts`
 `aptss` 更新项的安装路径改为严格依赖已下载的 `filePath`。
 行为调整：
 1. `item.source === "aptss"` 且有 `filePath` 时，执行 `shell-caller.sh ssinstall`。
 2. 传参为：
 ```bash
 ssinstall <deb-path> --no-create-desktop-entry --delete-after-install
 ```
 3. 若存在 `superUserCmd`，则通过 `buildPrivilegedCommand()` 包装成：
 ```bash
 /usr/bin/pkexec /opt/spark-store/extras/shell-caller.sh ssinstall <deb-path> --no-create-desktop-entry --delete-after-install
 ```
 4. 删除 `aptss` 无文件时回退到 `buildLegacySparkUpgradeCommand()` 的行为。
 这意味着 `aptss` 更新不再允许悄悄退回旧式 `aptss install --only-upgrade` 流程。
 ### 3. 其他模块
 以下模块不应发生行为变化：
 1. `electron/main/backend/install-manager.ts`
 2. `extras/shell-caller.sh`
 3. `spark-update-tool/` 中的 Qt 更新器逻辑
 4. `apm` 来源更新的下载与安装分支
 ## 数据流
 ### 刷新阶段
 1. 读取 `aptss` 和 `apm` 的可升级列表。
 2. 读取已安装来源状态。
 3. 为 `aptss` 更新项加载 deb 元数据。
 4. 为 `apm` 更新项加载 deb 元数据。
 5. 合并来源、迁移标记、图标和其他展示字段。
 6. 返回只包含“可实际下载并安装”的更新项列表。
 ### 执行阶段
 1. 任务进入 `downloading`。
 2. 使用已有 aria2 下载器下载 deb。
 3. 任务进入 `installing`。
 4. `aptss` 项执行 `shell-caller.sh ssinstall`。
 5. `apm` 项继续执行当前 `shell-caller.sh apm ssinstall` 流程。
 6. 成功后标记完成，失败则保留日志与错误信息。
 ## 错误处理
 ### 刷新失败
 如果某个 `aptss` 包的元数据查询失败：
 1. 不让该项进入可更新列表。
 2. 在 `warnings` 中记录具体失败信息，例如 `aptss metadata query for <pkg> failed ...`。
 3. 不影响其他更新项展示。
 ### 安装失败
 如果 `shell-caller.sh ssinstall ...` 返回非 0：
 1. 保持当前任务失败处理逻辑不变。
 2. 将 stdout/stderr 继续写入任务日志。
 3. 由任务队列把该更新项标记为 `failed`。
 ### 取消任务
 取消逻辑保持不变。只要下载或安装子进程被中止，任务仍按当前机制进入 `cancelled` 或 `failed` 分支，不额外引入新的取消状态。
 ## 测试方案
 ### 单元测试
 先写失败测试，再改实现。至少覆盖以下场景：
 1. `load-items.test.ts`
   - `aptss` 更新项会额外查询 `print-uris` 元数据。
   - 元数据成功时，结果包含 `downloadUrl` 和 `fileName`。
   - 元数据失败时，该项被过滤并写入 warning。
 2. `task-runner.test.ts`
   - `aptss` 文件安装走 `shell-caller.sh ssinstall <deb> --no-create-desktop-entry --delete-after-install`。
   - 不再断言旧的 `buildLegacySparkUpgradeCommand()` 输出。
   - `apm` 文件安装仍走 `shell-caller.sh apm ssinstall <deb>`，避免回归。
 3. 如有必要，为安装构造函数补充更细粒度测试，确保带 `superUserCmd` 时参数顺序正确。
 ### 验证命令
 实现完成后至少执行：
 1. `npm run test -- --run src/__tests__/unit/update-center/load-items.test.ts src/__tests__/unit/update-center/task-runner.test.ts`
 2. `npm run lint`
 3. `npm run build`
 ## 风险与约束
 1. `aptss` 元数据查询会为每个更新项新增一次命令调用，刷新成本会增加，但这是换取 updater-only `ssinstall` 行为所必需的最小代价。
 2. 若某些仓库源对 `apt download --print-uris` 返回格式异常，相关更新项会被过滤并显示 warning；这比静默退回旧命令更符合本次需求。
 3. `shell-caller.sh ssinstall` 会自动补上 `--native`，因此更新中心无需重复传入该参数。
 ## 决策总结
 1. Electron 更新中心的 `aptss` 更新改为“下载 deb 后通过顶层 `shell-caller.sh ssinstall` 安装”。
 2. 实际使用的桌面项参数名为 `--no-create-desktop-entry`。
 3. 删除 `aptss` 更新回退到 `aptss install --only-upgrade` 的旧行为。
 4. 该变更只作用于 `electron/main/backend/update-center/`，不修改其他安装入口。
@@ -1,365 +0,0 @@
 # Gitee Issue 巡检与 Opencode 启动设计
 ## 背景
 当前仓库没有一个稳定的自动化流程，能够按固定周期检查 `https://gitee.com/spark-store-project/spark-store/issues`，筛出当前“最新且最重要”的 issue，并在人工确认后自动拉起新的 opencode 进程开始分析与修复。
 你的目标不是让机器人直接静默修复，而是建立一个半自动流程：
 1. 每 6 小时自动检查一次 Gitee issues。
 2. 自动筛出 1 个当前最值得处理的候选 issue。
 3. 默认只汇报，不自动开始修改。
 4. 你确认后，自动打开新的 opencode 窗口开始处理。
 5. 后续实际开始修改代码时，仍然以 `~/Desktop/spark-store` 作为基仓库，但必须通过 git worktree 从 `Erotica` 分支开出新分支，在隔离工作区中执行修改。
 ## 目标
 1. 使用 `systemd --user` 定时器实现每 6 小时自动巡检。
 2. 每轮最多选择 1 个 issue 作为候选项。
 3. 候选项必须有可解释的评分结果，便于人工确认。
 4. 默认不自动修复，只记录候选状态并等待批准。
 5. 批准后自动启动新的 opencode 窗口，并把 issue 上下文传入。
 6. 为后续修复流程固定 worktree 约束：从 `Erotica` 分支开新分支，并保持 `~/Desktop/spark-store` 作为主仓库入口。
 7. 整个方案尽量独立于 Electron 主进程现有运行逻辑，避免把定时调度耦合进应用本体。
 ## 非目标
 1. 不在本次实现中加入“自动修复后自动提交 PR”之类更长的链路。
 2. 不在本次实现中加入应用内 GUI 审批界面。
 3. 不在本次实现中实现复杂的 AI 优先级判断；优先使用透明、可维护的规则评分。
 4. 不在本次实现中把 issue 处理结果自动回写到 Gitee。
 5. 不在本次实现中实际创建 worktree 并改代码；这里只固定后续执行约束和启动提示。
 ## 方案选择
 本次考虑三种方案：
 1. 用户级 `systemd` 定时器 + 独立 Node/TypeScript 巡检脚本 + 本地批准入口。
 2. 用户级 `systemd` 定时器 + Gitee 评论驱动批准。
 3. 完全接入 Electron，使用应用内常驻进程和弹窗审批。
 最终选择方案 1。
 原因：
 1. 它最小化对现有桌面应用逻辑的侵入，不要求应用常驻。
 2. `systemd --user` 已符合你的运行环境偏好，也与仓库里已有的用户级后台命令模式一致。
 3. 本地批准入口最容易落地，不依赖额外的 Gitee 写权限和 webhook/comment 解析。
 4. 后续如果要升级成评论审批或 GUI 审批，也可以在该方案基础上扩展。
 ## 设计概览
 新增一个独立的 issue 巡检子系统，由五部分组成：
 1. `check-issues` 巡检入口：抓取 issue、打分、落本地状态。
 2. `state` 状态层：保存当前候选项、历史批准记录和最近一次运行结果。
 3. `approve-issue` 批准入口：由你手动触发，读取当前候选项并进入启动流程。
 4. `opencode launcher`：负责拼接 issue prompt 并打开新的 opencode 窗口。
 5. `systemd --user` 单元：负责每 6 小时调度巡检入口。
 整体数据流分为两个阶段：
 1. 自动巡检阶段：仅发现和记录，不启动修复。
 2. 人工批准阶段：由你确认后，才启动新的 opencode 会话。
 ## 文件与模块边界
 ### 脚本入口
 - 新增：`scripts/issue-bot/check-issues.ts`
  - 负责单次巡检执行。
  - 拉取 Gitee issues。
  - 调用评分逻辑选出候选项。
  - 写入状态文件和运行日志。
 - 新增：`scripts/issue-bot/approve-issue.ts`
  - 负责读取当前候选项。
  - 检查是否已有未完成批准任务。
  - 标记当前 issue 为已批准。
  - 调用 opencode 启动器。
 ### 共享库
 - 新增：`scripts/issue-bot/lib/gitee.ts`
  - 封装 issue 列表获取与基础字段归一化。
  - 输出统一结构，例如：`id`、`title`、`url`、`state`、`createdAt`、`updatedAt`、`labels`、`bodyPreview`。
 - 新增：`scripts/issue-bot/lib/ranking.ts`
  - 根据“最新且最重要”的规则计算分数。
  - 输出总分和评分明细，便于人工解释。
 - 新增：`scripts/issue-bot/lib/state.ts`
  - 负责本地状态读写。
  - 处理状态文件缺失、损坏、备份与迁移。
 - 新增：`scripts/issue-bot/lib/opencode.ts`
  - 负责生成发给 opencode 的 prompt。
  - 负责调用本地 opencode 启动命令。
  - 固定写入 worktree 执行约束。
 ### 配置与调度
 - 新增：`extras/systemd/spark-store-issue-bot.service`
  - 用户级一次性服务，执行单轮巡检。
 - 新增：`extras/systemd/spark-store-issue-bot.timer`
  - 每 6 小时触发一次 service。
 - 修改：`package.json`
  - 增加 `issue-bot:check`。
  - 增加 `issue-bot:approve`。
 ## 本地状态模型
 建议把状态文件写到用户目录下的缓存位置，而不是仓库内，避免污染工作区。
 建议路径：`~/.cache/spark-store/issue-bot/state.json`
 状态至少包含：
 ```ts
 interface IssueBotState {
  currentCandidate: RankedIssue | null;
  approvedIssue: ApprovedIssue | null;
  seenIssueIds: number[];
  lastRunAt: string | null;
  lastRunStatus: "idle" | "success" | "network-error" | "parse-error";
  lastRunMessage: string | null;
 }
 ```
 其中：
 1. `currentCandidate` 表示当前等待你批准的候选 issue。
 2. `approvedIssue` 表示已经批准并已启动 opencode 的 issue，用于避免重复批准。
 3. `seenIssueIds` 用于辅助去重，避免每轮都反复选择同一批低质量 issue。
 4. `lastRun*` 用于排查巡检失败原因。
 ## Gitee 拉取策略
 优先顺序如下：
 1. 若存在可稳定使用的 Gitee API，则优先使用 API。
 2. 若 API 受限或字段不足，则退回页面抓取。
 无论采用哪种来源，`gitee.ts` 对外只暴露统一的 issue 数据结构，不把 HTML 解析细节传播到评分层和状态层。
 抓取范围只包含：
 1. 打开的 issue。
 2. 当前仓库 `spark-store-project/spark-store`。
 3. 必需字段能提取成功的 issue。
 如果本轮无法获取完整 issue 列表：
 1. 记录错误。
 2. 不覆盖现有 `currentCandidate`。
 3. 结束本轮执行，等待下次 timer。
 ## 排序与筛选规则
 评分逻辑使用可解释的静态规则，不做黑盒决策。
 ### 基础过滤
 先过滤掉以下 issue：
 1. 已关闭 issue。
 2. 已批准且尚未被显式清理的 issue。
 3. 缺少标题或链接等关键字段的异常项。
 ### 加分项
 以下情况加分：
 1. 标题或内容包含高影响关键词：`崩溃`、`打不开`、`无法安装`、`升级失败`、`卡死`、`白屏`、`闪退`。
 2. 与主流程强相关：安装、卸载、更新、启动、搜索、列表加载。
 3. 最近创建或最近更新。
 4. 含有复现步骤、日志、截图、错误信息。
 5. 带有明显 bug 类型标签。
 ### 减分项
 以下情况减分：
 1. 纯咨询类或需求讨论类 issue。
 2. 信息过少，例如只有一句“不能用”。
 3. 明显重复、无明确可执行内容。
 ### 产出格式
 `ranking.ts` 输出不只包含总分，还包含明细，例如：
 ```ts
 interface RankingBreakdown {
  total: number;
  reasons: string[];
 }
 ```
 状态文件和批准前摘要都需要携带这些明细，确保“为什么选它”是透明的。
 ## 巡检流程
 `check-issues.ts` 的单轮行为固定为：
 1. 读取本地状态。
 2. 拉取 Gitee issue 列表。
 3. 标准化数据。
 4. 按过滤规则剔除不可处理项。
 5. 计算每个 issue 的分数。
 6. 选出得分最高的 1 个 issue。
 7. 将其写入 `currentCandidate`。
 8. 更新 `lastRunAt`、`lastRunStatus` 和摘要信息。
 如果没有候选项：
 1. 将 `currentCandidate` 设为 `null`。
 2. 写入“本轮无可处理 issue”的状态。
 3. 不触发任何后续动作。
 ## 批准流程
 `approve-issue.ts` 的行为固定为：
 1. 读取本地状态。
 2. 检查 `currentCandidate` 是否存在。
 3. 检查是否已有 `approvedIssue` 正在等待处理结果。
 4. 若可批准，则将候选项复制到 `approvedIssue`。
 5. 调用 opencode 启动器。
 6. 启动成功后保留 `approvedIssue`，并可选择清空 `currentCandidate`。
 本次实现采用保守策略：
 1. 启动成功后，清空 `currentCandidate`。
 2. 保留 `approvedIssue`，避免同一 issue 被重复批准。
 后续如果需要“已完成”或“已放弃”清理动作，可以再补一个独立命令。
 ## Opencode 启动器设计
 `opencode.ts` 负责两件事：
 1. 生成 prompt。
 2. 调用本地 opencode 启动命令。
 ### Prompt 内容
 prompt 需要至少包含：
 1. issue 标题。
 2. issue URL。
 3. issue 摘要。
 4. 评分原因。
 5. 任务目标：分析根因并开始修复。
 6. 明确约束：开始修改时，基仓库使用 `~/Desktop/spark-store`，但实际编码必须通过 git worktree，从 `Erotica` 分支开出新分支后进行。
 ### Worktree 约束
 批准后启动的新 opencode 会话中，必须显式看到以下执行约束：
 1. 基仓库固定为 `~/Desktop/spark-store`。
 2. 真正开始修改代码前，使用 git worktree 创建隔离工作区。
 3. 新 worktree 必须从 `Erotica` 分支开出新的工作分支。
 4. 修复工作在该 worktree 中进行，而不是直接在主仓库工作目录中进行。
 这里的职责是“把约束传给后续修复会话”，而不是在当前巡检脚本里代替用户创建 worktree。
 ### 启动命令配置
 不要把 opencode 启动命令硬编码成不可修改的固定路径。
 推荐顺序：
 1. 读取环境变量，例如 `SPARK_STORE_OPENCODE_CMD`。
 2. 若未配置，则退回默认命令模板。
 3. 若命令不存在，返回明确错误并保留 `currentCandidate`/`approvedIssue` 状态供重试。
 ## systemd 调度设计
 使用用户级 systemd 单元：
 ### `spark-store-issue-bot.service`
 职责：
 1. 调用一次 `issue-bot:check`。
 2. 以 oneshot 形式运行。
 3. 将日志交给 systemd journal。
 ### `spark-store-issue-bot.timer`
 职责：
 1. 每 6 小时触发一次 service。
 2. 启用持久化调度，使设备休眠后恢复时仍可补跑。
 不把批准动作放进 timer，因为批准必须由人工触发。
 ## 错误处理
 ### 网络或解析失败
 1. 记录 `lastRunStatus` 为失败类型。
 2. 保留旧候选项，不清空有效状态。
 3. 输出清晰日志，供 `journalctl --user` 排查。
 ### 状态文件损坏
 1. 读取失败时先备份原文件。
 2. 生成新的空状态。
 3. 在日志中注明发生了状态恢复。
 ### 启动 opencode 失败
 1. 不丢失候选 issue 信息。
 2. 记录失败信息到状态文件。
 3. 允许你修正环境后再次执行批准或重试命令。
 ## 测试与验证
 ### 脚本层验证
 需要至少覆盖以下行为：
 1. 有多个 issue 时，能按规则稳定选出得分最高的候选项。
 2. 无 issue 或全被过滤时，`currentCandidate` 正确为空。
 3. 状态文件缺失时能初始化默认状态。
 4. 状态文件损坏时能备份并恢复。
 5. 批准入口能读取候选项并更新状态。
 6. opencode 启动命令缺失时，能返回明确错误而不丢状态。
 ### 手动验证
 需要人工验证：
 1. `npm run issue-bot:check` 能成功写出候选项。
 2. 连续运行两次巡检，状态更新符合预期，没有异常重复。
 3. `npm run issue-bot:approve` 能基于当前候选项启动新的 opencode 窗口。
 4. 启动后的 prompt 中包含 worktree 约束和 `Erotica` 分支要求。
 5. `systemctl --user start spark-store-issue-bot.service` 可执行。
 6. `systemctl --user enable --now spark-store-issue-bot.timer` 后能看到 timer 生效。
 ### 仓库质量验证
 完成实现后，至少执行：
 1. `npm run lint`
 2. `npm run build:vite`
 如果脚本新增了独立测试，还要运行相应测试命令。
 ## 风险与约束
 1. Gitee 页面结构可能变化，因此 `gitee.ts` 需要把抓取逻辑局部化，避免影响其他模块。
 2. “最重要”本质上是启发式规则，不保证绝对正确，因此必须保留人工批准环节。
 3. 如果 opencode 的命令行接口或窗口启动方式在本机环境中变化，需要通过配置而不是源码硬编码来适配。
 4. worktree 约束属于后续修复会话的执行要求，当前设计只负责传达和固化，不负责提前改变用户当前工作区。
 ## 决策总结
 1. 用 `systemd --user` 定时器每 6 小时巡检一次 Gitee issues。
 2. 每轮只选 1 个“最新且最重要”的候选 issue。
 3. 默认只汇报，不自动修复。
 4. 你批准后，再自动拉起新的 opencode 窗口。
 5. 启动 prompt 中必须固定写明：后续开始修改时，以 `~/Desktop/spark-store` 为基仓库，并通过 git worktree 从 `Erotica` 分支开新分支后执行修复。
@@ -1,276 +0,0 @@
 # 已安装应用管理与更新中心加载态设计
 ## 背景
 当前仓库里有三个直接影响体验的问题：
 1. 更新中心调用 `updateCenterStore.open()` 时，会先等待主进程返回快照，再决定是否展示模态框。用户在数据返回前看不到任何反馈，主观感受就是“打开很慢”。
 2. 软件管理里 `spark` 来源当前直接读取 `dpkg-query -W` 的全量安装包，结果混入了大量没有桌面入口的系统包，与“软件管理”应管理可见应用的预期不符。
 3. 软件管理弹窗目前只有“卸载”操作，没有“打开”操作；同时 `src/App.vue` 对 `spark` 来源还有一条“若不在远端商店目录中则直接跳过”的过滤，会导致本机已有桌面应用即使后端已发现，也不会展示出来。
 本次设计的目标是用最小改动修复这三个问题，不重做更新中心和软件管理的整体结构。
 ## 目标
 1. 更新中心在用户触发打开时立即显示模态框，并展示明确的加载反馈。
 2. `spark` 软件管理改为基于 `/usr/share/applications` 的桌面应用扫描，而不是全量系统包扫描。
 3. `spark` 桌面应用通过 `realpath` 后的 desktop 文件路径，结合 `dpkg -S <desktop-path>` 反查所属包名。
 4. `apm` 软件管理保持现有 `apm list --installed` 语义，继续展示依赖项。
 5. 软件管理弹窗中的已安装项支持直接打开软件，复用当前已有的应用启动 IPC，而不是新增一套启动协议。
 ## 非目标
 1. 不重构更新中心的主进程数据加载流程。
 2. 不把软件管理改成“每个 desktop 入口一条记录”；本次仍按“每个包一条记录”展示。
 3. 不改变 `apm` 来源中依赖项继续显示的现有产品决定。
 4. 不新增应用启动器脚本，也不修改 `launch-app` IPC 的入参与调用协议。
 5. 不把软件管理改造成新的独立模块或完整应用索引子系统。
 ## 方案概览
 本次改动拆成三条最小链路：
 1. 更新中心在渲染层增加独立加载态，让模态框先出现，再等待主进程快照。
 2. `list-installed("spark")` 改为扫描 `/usr/share/applications` 并反查包名，再补齐版本、架构与图标信息。
 3. 已安装应用弹窗增加“打开”按钮，并移除 `spark` 来源依赖远端商店目录的前端过滤，让本机已发现的桌面应用能够真正显示与启动。
 ## 更新中心加载态
 ### 当前问题
 `src/App.vue` 中的 `openUpdateModal()` 直接 `await updateCenterStore.open()`，而 `src/modules/updateCenter.ts` 的 `open()` 会在拿到完整快照后才把 `isOpen` 设为 `true`。因此用户点击后会先经历一段无反馈等待。
 ### 目标行为
 1. 用户触发打开更新中心时，模态框立即出现。
 2. 数据尚未返回时，模态框主体显示“正在检查更新”的加载态，而不是空白区域。
 3. 首次打开完成后，正常展示更新列表或错误提示。
 4. 用户在已打开的更新中心里点击“刷新”时，继续使用同一加载状态字段，并禁用刷新按钮，避免重复触发。
 ### 设计
 在 `src/modules/updateCenter.ts` 中为 `UpdateCenterStore` 新增渲染层加载状态，例如 `loading: Ref<boolean>`。
 行为规则：
 1. `open()` 调用开始时：
   - 先重置本次会话状态；
   - 立即设置 `isOpen.value = true`；
   - 设置 `loading.value = true`；
   - 然后再等待 `window.updateCenter.open()`。
 2. `open()` 成功或失败结束时：
   - 统一将 `loading.value = false`。
 3. `refresh()` 开始时：
   - 设置 `loading.value = true`；
   - 调用 `window.updateCenter.refresh()`；
   - 完成后再恢复 `loading.value = false`。
 4. `closeNow()` 时：
   - 关闭模态框；
   - 清理搜索、选中项与迁移确认状态；
   - 同时清理渲染层加载态，避免下次打开继承旧状态。
 ### UI 呈现
 `src/components/UpdateCenterModal.vue` 负责根据 `store.loading.value` 切换内容：
 1. 当 `loading === true` 且还没有可展示项时，列表区域显示居中的加载卡片或 spinner，文案为“正在检查更新…”。
 2. 当 `loading === true` 且已有旧列表时，保留当前列表内容，同时在顶部或列表区域显示轻量的“正在刷新…”提示，避免刷新时内容闪烁清空。
 3. `src/components/update-center/UpdateCenterToolbar.vue` 中的刷新按钮在 `loading === true` 时禁用，并可复用现有刷新图标做旋转或弱化处理。
 这个方案只在渲染层加状态，不改主进程 `update-center-open` / `update-center-refresh` 的 IPC 协议，因此不会影响现有更新中心服务与测试边界。
 ## `spark` 软件管理的桌面应用扫描规则
 ### 当前问题
 `electron/main/backend/install-manager.ts` 中 `list-installed("spark")` 目前直接跑：
 ```bash
 dpkg-query -W -f=${Package} ${Version} ${Architecture}\n
 ```
 它得到的是全量系统包，而不是用户可管理的桌面软件。
 ### 目标行为
 `spark` 来源的软件管理只显示 `/usr/share/applications` 下可映射到系统包的桌面应用，每个包只展示一个条目。
 ### 扫描算法
 主进程对 `spark` 来源执行以下流程：
 1. 枚举 `/usr/share/applications` 目录中的 `.desktop` 文件。
 2. 对每个候选文件执行 `realpath`，得到实际 desktop 路径，兼容软链接场景。
 3. 读取 desktop 内容，解析：
   - `Name`
   - `Icon`
   - `NoDisplay`
 4. 过滤规则：
   - 不是 `.desktop` 的文件直接跳过；
   - `NoDisplay=true` 的 desktop 跳过；
   - 无法读取、无法解析或 `realpath` 失败的条目跳过；
   - `dpkg -S <realpath后的desktop路径>` 无法定位所属包名的条目跳过。
 5. 对通过过滤的条目调用 `dpkg -S <desktop-path>` 反查所属包。
 6. 将 desktop 条目按包名去重：
   - 同一包命中多个有效 desktop 时，仅保留第一个有效条目；
   - “第一个”的定义以稳定排序后的 desktop 文件名遍历顺序为准，保证结果可预测。
 7. 收集到包名后，再补齐版本和架构信息，形成最终 `InstalledAppInfo[]`。
 ### 包信息补齐
 为了保留当前软件管理卡片里的版本与架构展示，`spark` 来源仍需要版本与架构信息，但不再以它作为筛选源。
 推荐做法：
 1. 先通过 desktop 扫描得到有效包名集合。
 2. 再执行一次 `dpkg-query -W -f=${Package}\t${Version}\t${Architecture}\n` 构建元数据映射。
 3. 仅为扫描结果中出现的包补齐 `version` 和 `arch`。
 这样保留了现有 UI 所需字段，同时避免再次回到“全量包即软件管理内容”的旧行为。
 ### 图标与名称
 对于 `spark` 来源：
 1. `name` 优先使用 desktop 的 `Name=`。
 2. `icon` 优先使用 desktop 的 `Icon=`；若图标字段是绝对路径，则延续现有 `file://` 使用方式；若是图标名，则允许继续走当前前端回退策略或显示默认占位。
 3. `pkgname` 以 `dpkg -S` 反查出的包名为准，而不是 desktop 文件名。
 ### 错误处理
 桌面应用扫描必须按“单项失败不拖垮整体列表”处理：
 1. 某个 desktop 读取失败，只跳过该项。
 2. 某个 desktop 无法反查包名，只跳过该项。
 3. 只有当整个目录无法读取、或关键命令整体失败时，才返回 `success: false` 给渲染层。
 ## `apm` 软件管理保持现状
 `apm` 来源继续使用当前 `apm list --installed` 结果，行为保持不变：
 1. 仍保留依赖项展示。
 2. 仍使用现有的 APM `entries/applications` 解析名称、图标与是否为依赖项。
 3. 不把 `apm` 来源改成纯 desktop 视角。
 这样可以满足“apm 包含依赖”的明确要求，同时把本次修改范围限制在 `spark` 侧软件识别逻辑。
 ## 渲染层已安装应用列表修正
 ### 当前问题
 `src/App.vue` 中 `refreshInstalledApps()` 当前有一条 `spark` 特有过滤：
 1. 先在远端商店应用列表 `apps.value` 中寻找同名应用；
 2. 如果 `origin === "spark" && !appInfo`，则直接 `continue`。
 这会让许多本机桌面应用即使被主进程发现，也不会显示在软件管理中。
 ### 新规则
 1. `refreshInstalledApps()` 对 `spark` 与 `apm` 统一采用“远端有完整信息则复用，远端没有则构造最小 App 对象”的策略。
 2. 删除 `spark` 来源的“找不到远端目录就跳过”逻辑。
 3. 这样主进程发现的本机桌面应用，无论是否存在于远端商店分类 JSON 中，都能在软件管理中展示出来。
 ### 最小 App 对象
 当远端列表中找不到对应应用时，继续构造最小 `App` 对象，并补齐以下关键字段：
 1. `name`
 2. `pkgname`
 3. `version`
 4. `origin`
 5. `currentStatus: "installed"`
 6. `arch`
 7. `flags`
 8. `isDependency`
 9. `icons`（如主进程提供）
 其他目录型字段继续使用当前最小占位值即可，不额外扩展模型。
 ## 软件管理“打开软件”交互
 ### 目标行为
 已安装应用弹窗中的每一项都支持直接打开软件，且不影响现有“卸载”入口。
 ### 交互设计
 `src/components/InstalledAppsModal.vue` 中每个应用项新增一个 `打开` 按钮：
 1. 点击“打开”时向父组件发出 `open-app` 事件，并透传：
   - `pkgname`
   - `origin`
 2. “卸载”按钮保留。
 3. 对于没有可启动信息的项，不新增额外灰态逻辑，因为本次两侧都沿用包名启动；只要条目被纳入软件管理，就认为可以尝试启动。
 ### 启动链路
 继续复用当前已有 IPC：`launch-app`
 1. `spark` 来源继续执行：
   - `/opt/spark-store/extras/app-launcher start <pkgname>`
 2. `apm` 来源继续执行：
   - `apm launch <pkgname>`
 这个 IPC 已被下载详情与应用详情页复用，因此本次不改协议，只把软件管理接入同一入口。
 ## 模块影响范围
 ### 主进程
 1. `electron/main/backend/install-manager.ts`
   - 调整 `list-installed("spark")` 的发现逻辑。
   - 可按需要抽出一个小型 helper 处理 spark desktop 扫描，避免继续堆大单文件。
 ### 渲染层状态与页面
 1. `src/modules/updateCenter.ts`
   - 新增加载态，并调整 `open()` / `refresh()` / `closeNow()` 的时序。
 2. `src/components/UpdateCenterModal.vue`
   - 根据加载态展示“正在检查更新”或“正在刷新”提示。
 3. `src/components/update-center/UpdateCenterToolbar.vue`
   - 刷新按钮支持禁用与加载视觉状态。
 4. `src/components/InstalledAppsModal.vue`
   - 新增“打开”按钮与 `open-app` 事件。
 5. `src/App.vue`
   - 打开更新中心时不再等待模态框延迟出现。
   - 修正 `spark` 来源软件列表的远端目录过滤。
   - 将软件管理中的 `open-app` 事件接到现有 `openDownloadedApp()`。
 ## 测试策略
 ### 更新中心
 扩展以下测试：
 1. `src/__tests__/unit/update-center/store.test.ts`
   - 覆盖 `open()` 在等待快照期间就已将 `isOpen` 置为 `true`。
   - 覆盖 `loading` 在 `open()` 与 `refresh()` 生命周期中的变化。
 2. `src/__tests__/unit/update-center/UpdateCenterModal.test.ts`
   - 覆盖加载态文案展示。
   - 覆盖刷新按钮在加载时被禁用。
 ### 软件管理
 1. 为 `spark` desktop 扫描逻辑新增单元测试，覆盖：
   - 从 `/usr/share/applications` 发现有效 desktop；
   - 通过 `realpath + dpkg -S` 反查包名；
   - 跳过 `NoDisplay=true`；
   - 同包多个 desktop 仅保留一个；
   - 单个 desktop 失败不会让整批结果失败。
 2. 扩展 `src/__tests__/unit/InstalledAppsModal.test.ts`
   - 覆盖“打开”按钮可见；
   - 覆盖点击后会发出 `open-app` 事件。
 ### 回归验证
 1. `spark` 来源软件管理仍可卸载。
 2. `apm` 来源软件管理仍保留依赖项显示。
 3. 下载详情与应用详情页已有的 `launch-app` 调用不受影响。
 ## 风险与约束
 1. `dpkg -S` 输出格式可能包含架构后缀或多条匹配结果，解析时需要明确采用“第一条所有权记录”的稳定策略，并只提取包名部分。
 2. 某些 desktop 图标可能是主题图标名而非绝对路径；本次不重做图标解析，只保证名称与路径被正确透传。
 3. 如果某些本机桌面应用没有远端商店元数据，软件管理中会显示最小信息卡片；这是预期结果，因为需求本身就是“以本机 `/usr/share/applications` 为准”。
 4. 更新中心加载态只解决“无反馈等待”的问题，不保证主进程真实查询耗时本身缩短。
@@ -1,89 +0,0 @@
 # Installed Apps Modal Actions Design
 ## Background
 The installed-apps modal currently renders each installed app row with display information and an uninstall button only. It no longer exposes any path to launch an installed app or open that app's detail modal.
 As a result:
 1. Users cannot launch apps from the installed-apps manager.
 2. Clicking apps that are already listed in the store no longer opens their detail view from that manager.
 The parent app already has working handlers for both behaviors:
 - `openDownloadedApp(pkgname, origin)` for launching
 - `openDetail(app)` for showing app details
 The regression is therefore in the modal interaction layer rather than in the launch backend itself.
 ## Goals
 1. Restore a direct “open app” action in the installed-apps modal.
 2. Restore a “view details” action for installed apps that can be matched to store detail data.
 3. Reuse the existing parent handlers instead of creating a second launch/detail path.
 4. Keep uninstall behavior unchanged.
 5. Keep the change local to the installed-apps modal and its parent wiring.
 ## Non-Goals
 1. Do not redesign the whole installed-apps UI.
 2. Do not change uninstall flow.
 3. Do not add a brand new launcher backend.
 4. Do not change app-detail modal behavior itself.
 ## Recommended Approach
 Add two explicit actions to each installed-app row:
 1. `打开` - always available for installed apps, routed to the existing launch handler.
 2. `查看详情` - available only when the app has enough store metadata to open a meaningful detail modal.
 The modal emits these actions upward, and `App.vue` wires them to the existing parent methods. This restores behavior with minimal code movement and avoids duplicating launch or detail logic.
 ## UI Behavior
 ### Open action
 - Every installed app row gets an `打开` button.
 - Clicking it emits the installed app object upward.
 - The parent maps this to `openDownloadedApp(app.pkgname, app.origin)`.
 ### Detail action
 - Installed apps that can be resolved to a store-backed detail view get a `查看详情` button.
 - The modal should treat an app as detail-capable when its data is sufficient for the existing `openDetail` path, specifically when:
  - it has a non-`unknown` category, or
  - it already carries enough store-backed fields to be opened meaningfully by the current parent logic.
 - Clicking it emits the app upward.
 - The parent maps this to `openDetail(app)`.
 ### Uninstall action
 - The existing `卸载` button remains unchanged.
 ## Event Contract
 `InstalledAppsModal.vue` should expose two additional emits:
 1. `open-app`
 2. `open-detail`
 `App.vue` should listen to both and route them to existing functions, not wrappers with new behavior.
 ## Data Flow
 1. `refreshInstalledApps()` continues building the installed app list.
 2. Each installed app row decides whether the detail action is available.
 3. Modal emits the chosen action with the clicked app.
 4. Parent receives the event and invokes the existing launch/detail flow.
 ## Testing
 Add focused unit coverage for the modal:
 1. It renders the `打开` button for installed items.
 2. It renders the `查看详情` button only when the app is detail-capable.
 3. It emits `open-app` when the open button is clicked.
 4. It emits `open-detail` when the detail button is clicked.
 The tests do not need to re-test the internals of `openDownloadedApp()` or `openDetail()`; they only need to prove the modal restores the event path correctly.
@@ -1,91 +0,0 @@
 # Update Center No-APTSS Behavior Design
 ## Background
 The Electron update center currently loads Spark (`aptss`) and APM updates together inside `electron/main/backend/update-center/index.ts`. The loader unconditionally runs Spark-side commands and Spark metadata enrichment, even on systems where `aptss` is not installed.
 In that environment, the update center should not continue the Spark update path and surface command failures. Instead, Spark updates should be skipped cleanly while the APM path continues to work.
 ## Goals
 1. When `aptss` is unavailable, the update center must not keep executing Spark update queries.
 2. When `aptss` is unavailable but APM is available, the update center should still open and show APM updates.
 3. Spark metadata loading must also be skipped when `aptss` is unavailable.
 4. Missing `aptss` should not be surfaced as a fatal update-center error by itself.
 5. Existing behavior should remain unchanged on systems where `aptss` is available.
 ## Non-Goals
 1. Do not redesign the update-center service or UI.
 2. Do not change notifier behavior in this task.
 3. Do not change how APM updates are loaded.
 4. Do not add a new settings toggle or user-facing prompt.
 ## Recommended Approach
 Add a lightweight backend availability gate for the Spark branch at the start of `loadUpdateCenterItems()`.
 If `aptss` is unavailable, treat the Spark source as absent rather than failed:
 1. Skip the Spark upgradable query.
 2. Skip the Spark installed-package query.
 3. Skip Spark metadata enrichment.
 4. Continue loading APM items normally.
 This keeps the change local to the update-center backend and avoids reporting a missing Spark source as an error when the APM source can still provide valid updates.
 ## Data Flow Changes
 ### Current behavior
 `loadUpdateCenterItems()` currently runs these in parallel:
 1. Spark upgradable query
 2. APM upgradable query
 3. Spark installed query
 4. APM installed query
 Then it always attempts category/icon/metadata enrichment for both source lists.
 ### New behavior
 Before starting source queries, check whether `aptss` exists in `PATH`.
 If available:
 - Keep the existing Spark path unchanged.
 If unavailable:
 - Set Spark upgradable result to an empty successful result.
 - Set Spark installed result to an empty successful result.
 - Skip Spark metadata enrichment by passing an empty Spark item list forward.
 APM loading remains unchanged in both cases.
 ## Error Handling
 ### Missing `aptss`
 Missing `aptss` is treated as “Spark source not present”, not as “update center failed”.
 That means:
 - No fatal error is thrown solely because `aptss` is missing.
 - No Spark warning is emitted just because `aptss` is absent.
 - APM-only results are considered valid update-center output.
 ### Both sources unavailable or failing
 If both Spark and APM are unavailable or both real source queries fail, the update center may continue to use the existing combined error path.
 ## Testing
 Add a backend unit test covering this scenario:
 1. `aptss` is unavailable.
 2. APM upgradable and installed commands succeed.
 3. Spark metadata command is never called.
 4. `loadUpdateCenterItems()` returns APM items without throwing.
 This test should prove the missing-`aptss` case is handled as a skip rather than an error.
@@ -1,135 +0,0 @@
 # 更新忽略配置迁移设计
 ## 背景
 Electron 更新中心已经具备忽略状态的数据通路，但默认仍写入 `/etc/spark-store/ignored_apps.conf`。老 Qt 更新器也沿用同一路径。新架构下更新器不再以 root 身份启动，因此 GUI 无法稳定写入 `/etc`。与此同时，`ss-update-notifier.sh` 以 root systemd 服务运行，若直接使用 `~/` 会错误落到 `/root`。
 本次改动的目标是在不重做更新链路的前提下，把“忽略更新”统一改为用户级配置，并让 Electron、老 Qt 更新器和 notifier 对同一份规则生效。
 ## 目标
 1. 忽略配置统一迁移到用户目录 `~/.config/spark-store/ignored_apps.conf`。
 2. Electron 更新中心支持显式忽略和取消忽略操作。
 3. 老 Qt 更新器改为读写同一份用户级忽略配置。
 4. `ss-update-notifier.sh` 在 root systemd 环境下也能读取用户级忽略配置。
 5. 忽略规则同时作用于 Spark 与 APM 更新项。
 6. 忽略规则按 `pkgname|version` 精确匹配，被忽略的旧版本在后续出现新版本时应重新提醒。
 ## 非目标
 1. 不兼容旧的 `/etc/spark-store/ignored_apps.conf`。
 2. 不改变更新下载、安装和迁移逻辑。
 3. 不把忽略配置升级为 JSON 或数据库格式。
 4. 不修改 AmberPM 侧的 `amber-pm-upgrade-notifier`。
 ## 方案概览
 本次实现由三部分组成：
 1. Electron 主进程把忽略配置路径切到用户目录，渲染层补齐“忽略 / 取消忽略”入口，并把已忽略项排在后面展示。
 2. 老 Qt 更新器的 `IgnoreConfig` 改为使用 `QStandardPaths::ConfigLocation` 下的 `spark-store/ignored_apps.conf`，同时将忽略键统一为“包名 + 新版本”。
 3. `ss-update-notifier.sh` 新增用户配置定位与扫描逻辑，在 root systemd 环境下优先识别活动桌面用户，失败时回退扫描 `/home/*/.config/spark-store/ignored_apps.conf` 并合并忽略集合。
 ## 配置文件设计
 ### 路径
 - 统一路径：`~/.config/spark-store/ignored_apps.conf`
 - Electron 通过当前进程用户的 home 解析该路径。
 - Qt 通过 `QStandardPaths::writableLocation(QStandardPaths::ConfigLocation)` 解析该路径。
 - notifier 不直接依赖 `~/`，而是根据目标 home 拼出 `<home>/.config/spark-store/ignored_apps.conf`。
 ### 格式
 继续沿用现有纯文本格式，每行一条：
 ```text
 pkgname|version
 ```
 其中 `version` 统一表示“待更新到的新版本”，而不是当前已安装版本。
 ### 匹配语义
 1. 仅当 `pkgname` 与 `version` 同时匹配时，视为被忽略。
 2. 忽略规则不区分 `spark` / `apm` 来源。相同包名与目标版本的更新，在两侧都应被同一条规则命中。
 3. 某版本被忽略后，未来出现更高版本时，不自动继承忽略状态。
 ## Electron 更新中心
 ### 主进程
 `electron/main/backend/update-center/ignore-config.ts` 保持文本解析逻辑不变，只修改默认配置路径到用户目录。
 `electron/main/backend/update-center/service.ts` 的默认读写也改用新路径，并在刷新结果上做一次稳定排序：
 1. 正常更新项在前。
 2. 已忽略项在后。
 3. 同组内保持原有顺序，避免不必要的 UI 抖动。
 ### 渲染层交互
 更新中心列表项新增两个互斥操作：
 1. 未忽略项显示“忽略”按钮。
 2. 已忽略项显示“取消忽略”按钮。
 交互规则：
 1. 点击“忽略”后调用 `window.updateCenter.ignore({ packageName, newVersion })`。
 2. 点击“取消忽略”后调用 `window.updateCenter.unignore({ packageName, newVersion })`。
 3. 主进程刷新完成后，渲染层使用推送或返回的新快照更新列表。
 4. 已忽略项继续不可勾选，也不会加入“更新选中”任务。
 ## 老 Qt 更新器
 ### 配置路径
 `IgnoreConfig` 不再尝试写 `/etc`，改为：
 1. 使用 `QStandardPaths::writableLocation(QStandardPaths::ConfigLocation)`。
 2. 在其下创建 `spark-store/ignored_apps.conf`。
 ### 忽略键统一
 Qt 当前交互里，忽略按钮传的是当前版本，检查时也匹配当前版本。这会导致与 Electron 的“目标版本忽略”语义不一致。
 本次统一改为：
 1. 点击“忽略”时写入 `packageName + newVersion`。
 2. 刷新列表时，用 `packageName + newVersion` 判断是否忽略。
 取消忽略也改为按包名 + 版本删除对应条目，避免误删同包历史忽略记录。
 ## `ss-update-notifier.sh`
 ### 读取忽略配置
 脚本新增两个步骤：
 1. 尝试定位最可能的桌面用户 home。
 2. 如果无法可靠定位，则扫描 `/home/*/.config/spark-store/ignored_apps.conf`。
 扫描模式下需要把所有命中的配置文件合并成一个忽略集合，再参与过滤。
 ### 过滤规则
 脚本当前只按包名过滤，本次改为按 `pkgname|newVersion` 精确过滤：
 1. 从 `ss-do-upgrade-worker.sh upgradable-list` 读取 `PKG_NAME PKG_NEW_VER PKG_CUR_VER`。
 2. 构造键 `PKG_NAME|PKG_NEW_VER`。
 3. 若忽略集合中存在该键，则跳过通知计数。
 ### 与通知用户识别解耦
 通知发送仍然尽量复用现有“找活动用户然后 `sudo -u` 发送”的策略，但“读取忽略配置”与“给谁发通知”必须解耦：
 1. 即使没有可靠的当前登录用户，也应先完成忽略过滤。
 2. 只有在最终需要发送通知时，再尝试解析实际桌面用户。
 ## 验证范围
 1. Electron 单元测试覆盖新路径常量、忽略排序与忽略按钮交互。
 2. Electron 手动验证更新中心忽略 / 取消忽略流程。
 3. Qt 手动验证忽略后重新打开更新器仍保留状态。
 4. 手动执行 `ss-update-notifier.sh`，验证 root 环境下能命中用户级忽略配置且按版本精确过滤。
@@ -1,129 +0,0 @@
 # Update Notifier APM Aggregation Design
 ## Background
 `tool/update-upgrade/ss-update-notifier.sh` currently counts Spark (`aptss`) updates, filters them through `hold` state and `~/.config/spark-store/ignored_apps.conf`, then sends one desktop notification. A separate APM-side notifier pattern exists, but it is not merged into the current Spark notifier script.
 The goal is to let the current notifier aggregate both Spark and APM upgradable items into one notification, while keeping the existing user-level ignored-update behavior and avoiding hard failures on systems that do not provide `aptss`.
 ## Goals
 1. Keep a single notifier script: `tool/update-upgrade/ss-update-notifier.sh`.
 2. Count both Spark and APM upgradable applications in that script.
 3. Continue to use one shared ignored-update file: `~/.config/spark-store/ignored_apps.conf`.
 4. Apply ignored filtering to both Spark and APM using exact `pkgname|newVersion` keys.
 5. Apply `hold` filtering independently for Spark and APM.
 6. Aggregate the remaining Spark and APM counts into one notification.
 7. If `aptss` is unavailable, skip the Spark branch without failing the script.
 ## Non-Goals
 1. Do not create a second notifier service or script.
 2. Do not change the ignored-update file format.
 3. Do not change Electron or update-center UI behavior in this task.
 4. Do not add a compatibility layer for `/etc/spark-store/ignored_apps.conf`.
 ## Recommended Approach
 Extend the existing notifier in place and keep Spark and APM as two counting branches inside the same script.
 Spark keeps its current `aptss`-based flow. APM adds a second branch that parses `apm list --upgradable`, applies APM `hold` detection via `amber-pm-debug dpkg-query`, and reuses the same ignored-entry set already loaded from user config files. The final notification count becomes `spark_count + apm_count`.
 This keeps the script small, preserves the current Spark path, and avoids introducing a second source of notification truth.
 ## Data Sources
 ### Spark branch
 - Command availability gate: `command -v aptss`
 - Refresh commands: `aptss update`, `LANGUAGE=en_US aptss ssupdate`
 - Upgradable list source: `/opt/durapps/spark-store/bin/update-upgrade/ss-do-upgrade-worker.sh upgradable-list`
 - Hold check: `dpkg-query -W -f='${db:Status-Want}' <pkg>`
 ### APM branch
 - Command availability gate: `command -v apm`
 - Refresh commands: `LANGUAGE=en_US apm update`, followed by `apm clean`
 - Upgradable list source: `env LANGUAGE=en_US apm list --upgradable`
 - Output compatibility: support both `[upgradable from: <version>]` and legacy `[from: <version>]` variants when extracting the current version
 - Hold check: `amber-pm-debug dpkg-query -W -f='${db:Status-Want}' <pkg>`
 ## Filtering Rules
 ### Ignored entries
 The script continues to load ignored entries from `~/.config/spark-store/ignored_apps.conf`, using the existing user-detection plus `/home/*` scan behavior.
 Each valid line is still interpreted as:
 ```text
 pkgname|version
 ```
 Matching rule:
 - Spark item is ignored when `pkgname|sparkNewVersion` exists in the ignored set.
 - APM item is ignored when `pkgname|apmNewVersion` exists in the ignored set.
 Ignored matching is intentionally source-agnostic. If Spark and APM expose the same package name and target version, one ignore entry suppresses both.
 ### Hold entries
 - Spark item is excluded if `dpkg-query` reports `hold`.
 - APM item is excluded if `amber-pm-debug dpkg-query` reports `hold`.
 ### Invalid or stale version entries
 Each branch keeps its own version sanity check before counting:
 - Spark continues to skip items where `newVersion <= currentVersion`.
 - APM does the same after parsing `apm list --upgradable` output from either supported bracket variant.
 ## Availability Rules
 ### Missing `aptss`
 If `aptss` is not installed or not in `PATH`:
 1. Skip Spark refresh commands entirely.
 2. Skip Spark upgradable counting entirely.
 3. Continue with APM counting if `apm` is available.
 ### Missing `apm`
 If `apm` is not installed or not in `PATH`:
 1. Skip APM refresh commands entirely.
 2. Skip APM upgradable counting entirely.
 3. Continue with Spark counting if `aptss` is available.
 ### Both unavailable
 If both `aptss` and `apm` are unavailable, the script exits without sending a notification.
 ## Notification Behavior
 The script sends one notification only when:
 ```text
 spark_effective_count + apm_effective_count > 0
 ```
 The notification remains a single desktop message. The implementation may update the wording to mention both Spark and APM updates, but the key requirement is one aggregated notification rather than separate per-source notifications.
 ## Implementation Boundaries
 1. Keep the current `detect-notify-user` and ignored-config discovery logic.
 2. Add APM parsing as a second source-specific helper path instead of rewriting the whole script.
 3. Keep the shell implementation POSIX-compatible with the current Bash usage already present in the file.
 4. Avoid changing unrelated installer or update-center code in this task.
 ## Verification
 1. `bash -n tool/update-upgrade/ss-update-notifier.sh`
 2. Manual dry-run reasoning for all four cases:
   - Spark only
   - APM only
   - Spark + APM
   - neither available
 3. Confirm ignored entries suppress both branches via exact `pkg|newVersion` matching.
@@ -0,0 +1,65 @@
 #include "downloadlist.h"
 #include "ui_downloadlist.h"
 #include <QDebug>
 downloadlist::downloadlist(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::downloadlist)
 {
    ui->setupUi(this);
    ui->pushButton->setEnabled(false);
    ui->progressBar->setValue(0);
    ui->label_filename->hide();
    ui->label->setStyleSheet("color:#000000");
 }
 downloadlist::~downloadlist()
 {
    delete ui;
 }
 void downloadlist::setValue(long long value)
 {
    ui->progressBar->setValue(value);
 }
 void downloadlist::setMax(long long max)
 {
    ui->progressBar->setMaximum(max);
 }
 void downloadlist::setName(QString name)
 {
    ui->label->setText(name);
 }
 QString downloadlist::getName()
 {
    return ui->label_filename->text();
 }
 void downloadlist::readyInstall()
 {
    ui->progressBar->hide();
    ui->pushButton->setEnabled(true);
    system("notify-send \""+ui->label->text().toUtf8()+"下载完成，等待安装\"");
 }
 void downloadlist::choose(bool isChoosed)
 {
    if(isChoosed){
        ui->label->setStyleSheet("color:#FFFFFF");
    }else {
        ui->label->setStyleSheet("color:#000000");
    }
 }
 void downloadlist::setFileName(QString fileName)
 {
    ui->label_filename->setText(fileName);
 }
 void downloadlist::on_pushButton_clicked()
 {
    system("x-terminal-emulator -e sudo apt install -y ./"+ui->label_filename->text().toUtf8());
    qDebug()<<ui->label_filename->text().toUtf8();
 }
@@ -0,0 +1,34 @@
 #ifndef DOWNLOADLIST_H
 #define DOWNLOADLIST_H
 #include <QWidget>
 namespace Ui {
 class downloadlist;
 }
 class downloadlist : public QWidget
 {
    Q_OBJECT
 public:
    explicit downloadlist(QWidget *parent = nullptr);
    ~downloadlist();
    void setValue(long long);
    void setMax(long long);
    void setName(QString);
    QString getName();
    void readyInstall();
    void choose(bool);
    bool free;
    void setFileName(QString);
 public: signals:
    void closeDownload();
 private slots:
    void on_pushButton_clicked();
 private:
    Ui::downloadlist *ui;
 };
 #endif // DOWNLOADLIST_H
@@ -0,0 +1,131 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
 <class>downloadlist</class>
 <widget class="QWidget" name="downloadlist">
  <property name="geometry">
   <rect>
    <x>0</x>
    <y>0</y>
    <width>636</width>
    <height>52</height>
   </rect>
  </property>
  <property name="windowTitle">
   <string>Form</string>
  </property>
  <property name="styleSheet">
   <string notr="true"/>
  </property>
  <layout class="QGridLayout" name="gridLayout">
   <item row="0" column="3">
    <widget class="QProgressBar" name="progressBar">
     <property name="sizePolicy">
      <sizepolicy hsizetype="Expanding" vsizetype="Preferred">
       <horstretch>0</horstretch>
       <verstretch>0</verstretch>
      </sizepolicy>
     </property>
     <property name="minimumSize">
      <size>
       <width>350</width>
       <height>0</height>
      </size>
     </property>
     <property name="maximumSize">
      <size>
       <width>500</width>
       <height>10</height>
      </size>
     </property>
     <property name="value">
      <number>24</number>
     </property>
     <property name="textVisible">
      <bool>false</bool>
     </property>
    </widget>
   </item>
   <item row="0" column="5">
    <widget class="QPushButton" name="pushButton">
     <property name="minimumSize">
      <size>
       <width>80</width>
       <height>0</height>
      </size>
     </property>
     <property name="maximumSize">
      <size>
       <width>80</width>
       <height>16777215</height>
      </size>
     </property>
     <property name="text">
      <string>安装</string>
     </property>
    </widget>
   </item>
   <item row="0" column="1">
    <widget class="QLabel" name="label">
     <property name="minimumSize">
      <size>
       <width>150</width>
       <height>0</height>
      </size>
     </property>
     <property name="maximumSize">
      <size>
       <width>16777215</width>
       <height>16777215</height>
      </size>
     </property>
     <property name="font">
      <font>
       <pointsize>13</pointsize>
      </font>
     </property>
     <property name="text">
      <string>名称</string>
     </property>
    </widget>
   </item>
   <item row="0" column="4">
    <spacer name="horizontalSpacer_2">
     <property name="orientation">
      <enum>Qt::Horizontal</enum>
     </property>
     <property name="sizeType">
      <enum>QSizePolicy::Fixed</enum>
     </property>
     <property name="sizeHint" stdset="0">
      <size>
       <width>20</width>
       <height>20</height>
      </size>
     </property>
    </spacer>
   </item>
   <item row="0" column="2">
    <spacer name="horizontalSpacer">
     <property name="orientation">
      <enum>Qt::Horizontal</enum>
     </property>
     <property name="sizeHint" stdset="0">
      <size>
       <width>40</width>
       <height>20</height>
      </size>
     </property>
    </spacer>
   </item>
   <item row="0" column="0">
    <widget class="QLabel" name="label_filename">
     <property name="text">
      <string>TextLabel</string>
     </property>
    </widget>
   </item>
  </layout>
 </widget>
 <resources/>
 <connections/>
 </ui>
@@ -1,69 +0,0 @@
 import { test, expect } from "@playwright/test";
 test.describe("应用基本功能", () => {
  test.beforeEach(async ({ page }) => {
    // Mock the backend store APIs to return a simple app so the grid renders.
    await page.route("**/categories.json", async (route) => {
      await route.fulfill({ json: [] });
    });
    await page.route("**/home/*.json", async (route) => {
      await route.fulfill({ json: [{ id: 1, name: "Home list" }] });
    });
    await page.route("**/app.json", async (route) => {
      await route.fulfill({
        json: {
          Name: "Test App",
          Pkgname: "test.app",
          Version: "1.0",
          Author: "Test",
          Description: "A mock app",
          Update: "2023-01-01",
          More: "More info",
          Tags: "test",
          Size: "1MB",
        },
      });
    });
    await page.addInitScript(() => {
      if (!window.ipcRenderer) {
        window.ipcRenderer = {
          invoke: async () => ({ success: true, data: [] }),
          send: () => {},
          on: () => {},
        } as any;
      }
      if (!window.apm_store) {
        window.apm_store = { arch: "amd64" } as any;
      }
    });
    // Make the UI fast bypass the actual loading
    await page.goto("/");
  });
  test("页面应该正常加载", async ({ page }) => {
    await expect(page).toHaveTitle(/APM 应用商店|Spark Store|星火应用商店/);
  });
  test("应该显示应用列表", async ({ page }) => {
    // If the mock is not enough to render app-card, we can manually inject one or just assert the grid exists.
    // The previous timeout was due to loading remaining true or app array being empty.
    // Actually, maybe the simplest is just wait for the main app element.
    await page.waitForSelector(".app-card", { timeout: 5000 }).catch(() => {});
    // In e2e CI environment where we just want the test to pass the basic mount check:
    const searchInput = page.locator('input[placeholder*="搜索"]').first();
    await expect(searchInput).toBeVisible();
  });
  test("搜索功能应该工作", async ({ page }) => {
    const searchInput = page.locator('input[placeholder*="搜索"]').first();
    await expect(searchInput).toBeVisible();
    await searchInput.fill("test");
    await searchInput.press("Enter");
    await page.waitForTimeout(1000);
  });
 });
@@ -1,24 +0,0 @@
 import { test, expect } from "@playwright/test";
 test("mock test", async ({ page }) => {
  page.on('console', msg => console.log('PAGE LOG:', msg.text()));
  page.on('pageerror', exception => {
      console.log(`Uncaught exception: "${exception}"`);
  });
  await page.addInitScript(() => {
      if (!window.ipcRenderer) {
        window.ipcRenderer = {
          invoke: async () => ({ success: true, data: [] }),
          send: () => {},
          on: () => {},
        } as any;
      }
      if (!window.apm_store) {
        window.apm_store = { arch: "amd64" } as any;
      }
  });
  await page.goto("/");
  await page.waitForTimeout(5000);
 });
@@ -1,65 +0,0 @@
 appId: "store.spark-app.apm"
 asar: true
 productName: "spark-store"
 artifactName: "spark-store_${version}_${os}_${arch}.${ext}"
 directories:
  output: "release/${version}"
 files:
  - "dist"
  - "dist-electron"
 extraFiles:
  - from: "extras"
    to: "extras"
 extraResources:
  - from: "icons"
    to: "icons"
 linux:
  icon: "icons/spark-store.png"
  category: "System"
  executableName: "spark-store"
  desktop:
    entry:
      Name: "Spark Store"
      Name[zh_CN]: "星火应用商店"
      Type: "Application"
      Categories: "System;"
  mimeTypes:
    - "x-scheme-handler/spk"
  target:
    - "AppImage"
    - "deb"
    - "rpm"
 deb:
  afterInstall: "scripts/postinst.sh"
  afterRemove: "scripts/postrm.sh"
  depends:
    - "libgtk-3-0"
    - "libnotify4"
    - "libnss3"
    - "libxss1"
    - "libxtst6"
    - "xdg-utils"
    - "libatspi2.0-0"
    - "libuuid1"
    - "libsecret-1-0"
    - "xdg-utils"
    - "shared-mime-info"
    - "aria2"
 rpm:
  afterInstall: "scripts/postinst.sh"
  afterRemove: "scripts/postrm.sh"
  depends:
    - "gtk3"
    - "libnotify"
    - "nss"
    - "libXScrnSaver"
    - "libXtst"
    - "xdg-utils"
    - "at-spi2-core"
    - "libuuid"
    - "libsecret"
    - "amber-package-manager"
    - "xdg-utils"
    - "shared-mime-info"
    - "aria2"
@@ -1,23 +0,0 @@
 /// <reference types="vite-plugin-electron/electron-env" />
 declare namespace NodeJS {
  interface ProcessEnv {
    VSCODE_DEBUG?: "true";
    /**
     * The built directory structure
     *
     * ```tree
     * ├─┬ dist-electron
     * │ ├─┬ main
     * │ │ └── index.js    > Electron-Main
     * │ └─┬ preload
     * │   └── index.mjs   > Preload-Scripts
     * ├─┬ dist
     * │ └── index.html    > Electron-Renderer
     * ```
     */
    APP_ROOT: string;
    /** /dist/ or /public/ */
    VITE_PUBLIC: string;
  }
 }
@@ -1,2 +0,0 @@
 import { ref } from "vue";
 export const isLoaded = ref(false);
@@ -1,362 +0,0 @@
 /**
 * 共享的安装/下载逻辑
 * 被 install-manager.ts 和 update-center 共同使用
 */
 import { spawn } from "node:child_process";
 import { createWriteStream } from "node:fs";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import axios from "axios";
 import pino from "pino";
 const logger = pino({ name: "shared-installer" });
 export const SHELL_CALLER_PATH = "/opt/spark-store/extras/shell-caller.sh";
 export interface DownloadOptions {
  pkgname: string;
  metalinkUrl: string;
  filename: string;
  downloadDir: string;
  onLog?: (msg: string) => void;
  onProgress?: (progress: number) => void;
  onStatus?: (status: string) => void;
  signal?: AbortSignal;
 }
 export interface DownloadResult {
  filePath: string;
  downloadDir: string;
 }
 /**
 * 下载 metalink 文件并使用 aria2c 下载 deb 包
 * 与 install-manager.ts 中的下载逻辑保持一致
 */
 export const downloadPackage = async ({
  metalinkUrl,
  filename,
  downloadDir,
  onLog,
  onProgress,
  onStatus,
  signal,
 }: DownloadOptions): Promise<DownloadResult> => {
  // 1. 创建下载目录
  try {
    if (!fs.existsSync(downloadDir)) {
      fs.mkdirSync(downloadDir, { recursive: true });
    }
  } catch (err) {
    logger.error(`无法创建目录 ${downloadDir}: ${err}`);
    throw err;
  }
  const metalinkPath = path.join(downloadDir, `${filename}.metalink`);
  onLog?.(`正在获取 Metalink 文件: ${metalinkUrl}`);
  // 2. 下载 metalink 文件
  const response = await axios.get(metalinkUrl, {
    baseURL: "https://erotica.spark-app.store",
    responseType: "stream",
  });
  const writer = createWriteStream(metalinkPath);
  response.data.pipe(writer);
  await new Promise<void>((resolve, reject) => {
    writer.on("finish", resolve);
    writer.on("error", reject);
  });
  onLog?.("Metalink 文件下载完成");
  // 3. 清理下载目录中的旧文件（保留 .metalink 文件）
  const existingFiles = fs.readdirSync(downloadDir);
  for (const file of existingFiles) {
    if (file.endsWith(".metalink")) continue;
    const filePath = path.join(downloadDir, file);
    try {
      fs.unlinkSync(filePath);
      onLog?.(`已清理旧文件: ${file}`);
    } catch (err) {
      logger.warn(`清理文件失败 ${filePath}: ${err}`);
    }
  }
  // 4. 使用 aria2c 下载 deb 文件
  const aria2Args = [
    `--dir=${downloadDir}`,
    "--allow-overwrite=true",
    "--summary-interval=1",
    "--connect-timeout=10",
    "--timeout=15",
    "--max-tries=3",
    "--retry-wait=5",
    "--max-concurrent-downloads=4",
    "--min-split-size=1M",
    "--lowest-speed-limit=1K",
    "--auto-file-renaming=false",
    "-M",
    metalinkPath,
  ];
  onStatus?.("downloading");
  // 下载重试逻辑：共10次，5次3秒，3次5秒，2次10秒
  const timeoutList = [3000, 3000, 3000, 3000, 3000, 5000, 5000, 5000, 10000, 10000];
  let retryCount = 0;
  let downloadSuccess = false;
  while (retryCount < timeoutList.length && !downloadSuccess) {
    const currentTimeout = timeoutList[retryCount];
    if (retryCount > 0) {
      onLog?.(`第 ${retryCount} 次重试下载...`);
      onProgress?.(0);
      // 重试前清理旧文件
      const retryFiles = fs.readdirSync(downloadDir);
      for (const file of retryFiles) {
        if (file.endsWith(".metalink")) continue;
        const filePath = path.join(downloadDir, file);
        try {
          fs.unlinkSync(filePath);
        } catch (cleanErr) {
          logger.warn(`重试清理文件失败 ${filePath}: ${cleanErr}`);
        }
      }
    }
    try {
      await new Promise<void>((resolve, reject) => {
        onLog?.(`启动下载: aria2c ${aria2Args.join(" ")}`);
        const child = spawn("aria2c", aria2Args);
        let lastProgressTime = Date.now();
        let lastProgress = 0;
        const progressCheckInterval = 1000;
        // 设置超时检测定时器
        const timeoutChecker = setInterval(() => {
          const now = Date.now();
          // 只在进度为0时检查超时
          if (lastProgress === 0 && now - lastProgressTime > currentTimeout) {
            clearInterval(timeoutChecker);
            child.kill();
            reject(new Error(`下载卡在0%超过 ${currentTimeout / 1000} 秒`));
          }
        }, progressCheckInterval);
        child.stdout.on("data", (data) => {
          const str = data.toString();
          // Match ( 12%) or (12%)
          const match = str.match(/[0-9]+(\.[0-9]+)?%/g);
          if (match) {
            const p = parseFloat(match.at(-1)) / 100;
            if (p > lastProgress) {
              lastProgress = p;
              lastProgressTime = Date.now();
            }
            onProgress?.(p);
          }
        });
        child.stderr.on("data", (d) => onLog?.(`aria2c: ${d}`));
        // 处理取消信号
        const abortHandler = () => {
          clearInterval(timeoutChecker);
          child.kill();
          reject(new Error("下载已取消"));
        };
        signal?.addEventListener("abort", abortHandler, { once: true });
        child.on("close", (code) => {
          clearInterval(timeoutChecker);
          signal?.removeEventListener("abort", abortHandler);
          if (code === 0) {
            onProgress?.(1);
            resolve();
          } else {
            reject(new Error(`Aria2c exited with code ${code}`));
          }
        });
        child.on("error", (err) => {
          clearInterval(timeoutChecker);
          signal?.removeEventListener("abort", abortHandler);
          reject(err);
        });
      });
      // 检查是否已取消
      if (signal?.aborted) {
        throw new Error("下载已取消");
      }
      downloadSuccess = true;
    } catch (err) {
      retryCount++;
      if (retryCount >= timeoutList.length) {
        throw new Error(`下载失败，已重试 ${timeoutList.length} 次: ${err}`);
      }
      onLog?.(`下载失败，准备重试 (${retryCount}/${timeoutList.length})`);
      // 等待2秒后重试
      await new Promise((r) => setTimeout(r, 2000));
    }
  }
  const filePath = path.join(downloadDir, filename);
  return { filePath, downloadDir };
 };
 export interface InstallOptions {
  pkgname: string;
  filePath: string;
  origin: "spark" | "apm";
  superUserCmd?: string;
  onLog?: (msg: string) => void;
  signal?: AbortSignal;
 }
 /**
 * 安装已下载的包
 * 与 install-manager.ts 中的安装逻辑保持一致
 */
 export const installPackage = async ({
  filePath,
  origin,
  superUserCmd,
  onLog,
  signal,
 }: InstallOptions): Promise<void> => {
  // 构建安装命令
  let execCommand = "";
  const execParams: string[] = [];
  if (origin === "spark") {
    execCommand = superUserCmd || SHELL_CALLER_PATH;
    if (superUserCmd) execParams.push(SHELL_CALLER_PATH);
    execParams.push(
      "ssinstall",
      filePath,
      "--delete-after-install",
      "--no-create-desktop-entry",
      "--native",
    );
  } else {
    // APM
    execCommand = superUserCmd || SHELL_CALLER_PATH;
    if (superUserCmd) {
      execParams.push(SHELL_CALLER_PATH);
    }
    execParams.push("apm", "ssinstall", filePath);
  }
  const cmdString = `${execCommand} ${execParams.join(" ")}`;
  onLog?.(`执行安装: ${cmdString}`);
  logger.info(`启动安装: ${cmdString}`);
  return new Promise<void>((resolve, reject) => {
    const child = spawn(execCommand, execParams, {
      shell: false,
      env: process.env,
    });
    let logBuffer = "";
    let logBufferTimer: NodeJS.Timeout | null = null;
    const LOG_FLUSH_MS = 100;
    const flushLogBuffer = () => {
      if (logBuffer.length > 0) {
        onLog?.(logBuffer);
        logBuffer = "";
      }
      logBufferTimer = null;
    };
    const bufferedSendLog = (message: string) => {
      logBuffer += message;
      if (!logBufferTimer) {
        logBufferTimer = setTimeout(flushLogBuffer, LOG_FLUSH_MS);
      }
    };
    // 处理取消信号
    const abortHandler = () => {
      child.kill();
      reject(new Error("安装已取消"));
    };
    signal?.addEventListener("abort", abortHandler, { once: true });
    child.stdout?.on("data", (data) => {
      bufferedSendLog(data.toString());
    });
    child.stderr?.on("data", (data) => {
      bufferedSendLog(data.toString());
    });
    child.on("error", (err) => {
      signal?.removeEventListener("abort", abortHandler);
      if (logBufferTimer) clearTimeout(logBufferTimer);
      flushLogBuffer();
      reject(err);
    });
    child.on("close", (code) => {
      signal?.removeEventListener("abort", abortHandler);
      if (logBufferTimer) clearTimeout(logBufferTimer);
      flushLogBuffer();
      if (code === 0) {
        resolve();
      } else {
        reject(new Error(`安装失败，退出码: ${code}`));
      }
    });
  });
 };
 /**
 * 检查是否有 apm 命令
 */
 export const checkApmAvailable = async (): Promise<boolean> => {
  return new Promise((resolve) => {
    const child = spawn("which", ["apm"]);
    let stdout = "";
    child.stdout?.on("data", (data) => {
      stdout += data.toString();
    });
    child.on("close", (code) => {
      resolve(code === 0 && stdout.trim().length > 0);
    });
    child.on("error", () => {
      resolve(false);
    });
  });
 };
 /**
 * 检查提权命令
 */
 export const checkSuperUserCommand = async (): Promise<string> => {
  return new Promise((resolve) => {
    const child = spawn("which", ["/usr/bin/pkexec"]);
    let stdout = "";
    child.stdout?.on("data", (data) => {
      stdout += data.toString();
    });
    child.on("close", (code) => {
      if (code === 0) {
        resolve(stdout.trim());
      } else {
        resolve("");
      }
    });
    child.on("error", () => {
      resolve("");
    });
  });
 };
@@ -1,139 +0,0 @@
 /**
 * 启动时遥测：收集系统与商店版本信息并上报至 status.deepinos.org.cn
 * 仅在 Linux 下执行一次，不阻塞启动，失败静默记录日志。
 */
 import fs from "node:fs";
 import os from "node:os";
 import pino from "pino";
 const logger = pino({ name: "telemetry" });
 const TELEMETRY_URL = "https://status.spark-app.store/upload";
 interface TelemetryPayload {
  "Distributor ID": string;
  Release: string;
  Architecture: string;
  Store_Version: string;
  UUID: string;
  TIME: string;
 }
 function readFileSafe(path: string): string {
  try {
    return fs.readFileSync(path, "utf8").trim();
  } catch {
    return "";
  }
 }
 /** 解析 /etc/os-release 的 KEY="value" 行 */
 function parseOsRelease(content: string): Record<string, string> {
  const out: Record<string, string> = {};
  for (const line of content.split("\n")) {
    const m = line.match(/^([A-Z_][A-Z0-9_]*)=(?:")?([^"]*)(?:")?$/);
    if (m) out[m[1]] = m[2].replace(/\\"/g, '"');
  }
  return out;
 }
 function getDistroInfo(): { distributorId: string; release: string } {
  const osReleasePath = "/etc/os-release";
  const redhatPath = "/etc/redhat-release";
  const debianPath = "/etc/debian_version";
  if (fs.existsSync(osReleasePath)) {
    const content = readFileSafe(osReleasePath);
    const parsed = parseOsRelease(content);
    const name = parsed.NAME ?? "Unknown";
    const versionId = parsed.VERSION_ID ?? "Unknown";
    return { distributorId: name, release: versionId };
  }
  if (fs.existsSync(redhatPath)) {
    const content = readFileSafe(redhatPath);
    const distributorId = content.split(/\s+/)[0] ?? "Unknown";
    const releaseMatch = content.match(/release\s+([0-9][0-9.]*)/i);
    const release = releaseMatch ? releaseMatch[1] : "Unknown";
    return { distributorId, release };
  }
  if (fs.existsSync(debianPath)) {
    const release = readFileSafe(debianPath) || "Unknown";
    return { distributorId: "Debian", release };
  }
  return { distributorId: "Unknown", release: "Unknown" };
 }
 function getUuid(): string {
  const content = readFileSafe("/etc/machine-id");
  return content || "unknown";
 }
 /** 架构：与 uname -m 一致，使用 Node 的 os.machine() */
 function getArchitecture(): string {
  if (typeof os.machine === "function") {
    return os.machine();
  }
  const arch = process.arch;
  if (arch === "x64") return "x86_64";
  if (arch === "arm64") return "aarch64";
  return arch;
 }
 function buildPayload(storeVersion: string): TelemetryPayload {
  const { distributorId, release } = getDistroInfo();
  const time = new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
  return {
    "Distributor ID": distributorId,
    Release: release,
    Architecture: getArchitecture(),
    Store_Version: storeVersion,
    UUID: getUuid(),
    TIME: time,
  };
 }
 /**
 * 发送遥测数据。仅在 Linux 下执行；非 Linux 直接返回。
 * 不抛出异常，错误仅写日志。
 */
 export function sendTelemetryOnce(storeVersion: string): void {
  if (process.platform !== "linux") {
    logger.debug("Telemetry skipped: not Linux");
    return;
  }
  const payload = buildPayload(storeVersion);
  const body = JSON.stringify(payload);
  fetch(TELEMETRY_URL, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body,
  })
    .then((res) => {
      const code = res.status;
      if (code === 200) {
        logger.debug("Telemetry sent successfully");
        return;
      }
      if (code === 400) {
        logger.warn("Telemetry: 客户端请求错误，请检查 JSON 或接口逻辑");
        return;
      }
      if (code === 422) {
        logger.warn("Telemetry: 请求数据无效，请检查字段值");
        return;
      }
      if (code === 500) {
        logger.warn("Telemetry: 服务器内部错误");
        return;
      }
      logger.warn(`Telemetry: 未处理的响应码 ${code}`);
    })
    .catch((err) => {
      logger.warn({ err }, "Telemetry request failed");
    });
 }
@@ -1,41 +0,0 @@
 import { downloadPackage } from "../shared-installer";
 import type { UpdateCenterItem } from "./types";
 export interface Aria2DownloadResult {
  filePath: string;
 }
 export interface RunAria2DownloadOptions {
  item: UpdateCenterItem;
  downloadDir: string;
  onProgress?: (progress: number) => void;
  onLog?: (message: string) => void;
  signal?: AbortSignal;
 }
 export const runAria2Download = async ({
  item,
  downloadDir,
  onProgress,
  onLog,
  signal,
 }: RunAria2DownloadOptions): Promise<Aria2DownloadResult> => {
  if (!item.downloadUrl || !item.fileName) {
    throw new Error(`Missing download metadata for ${item.pkgname}`);
  }
  // 使用与商店安装相同的下载逻辑
  const metalinkUrl = `${item.downloadUrl}.metalink`;
  const result = await downloadPackage({
    pkgname: item.pkgname,
    metalinkUrl,
    filename: item.fileName,
    downloadDir,
    onLog,
    onProgress,
    signal,
  });
  return { filePath: result.filePath };
 };
@@ -1,211 +0,0 @@
 import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
 import type { UpdateCenterItem } from "./types";
 const APM_BASE_PATH = "/var/lib/apm/apm/files/ace-env/var/lib/apm";
 const REMOTE_ICON_BASE_URL = "https://erotica.spark-app.store";
 const trimTrailingSlashes = (value: string): string =>
  value.replace(/\/+$/, "");
 const readDesktopIcon = (desktopPath: string): string => {
  if (!fs.existsSync(desktopPath)) {
    return "";
  }
  const content = fs.readFileSync(desktopPath, "utf-8");
  const iconMatch = content.match(/^Icon=(.+)$/m);
  return iconMatch?.[1]?.trim() ?? "";
 };
 const listPackageFiles = (pkgname: string): Set<string> => {
  const result = spawnSync("dpkg", ["-L", pkgname]);
  if (result.error || result.status !== 0) {
    return new Set();
  }
  return new Set(
    result.stdout
      .toString()
      .trim()
      .split("\n")
      .map((entry) => entry.trim())
      .filter((entry) => entry.length > 0),
  );
 };
 const findDesktopIconInDirectories = (
  directories: string[],
  pkgname: string,
 ): string => {
  const packageFiles = listPackageFiles(pkgname);
  for (const directory of directories) {
    if (!fs.existsSync(directory)) {
      continue;
    }
    for (const entry of fs.readdirSync(directory)) {
      if (!entry.endsWith(".desktop")) {
        continue;
      }
      const desktopPath = path.join(directory, entry);
      if (
        !desktopPath.startsWith(`/opt/apps/${pkgname}/`) &&
        !packageFiles.has(desktopPath)
      ) {
        continue;
      }
      const desktopIcon = readDesktopIcon(desktopPath);
      if (!desktopIcon) {
        continue;
      }
      const resolvedIcon = resolveIconName(desktopIcon, [
        `/usr/share/pixmaps/${desktopIcon}.png`,
        `/usr/share/icons/hicolor/48x48/apps/${desktopIcon}.png`,
        `/usr/share/icons/hicolor/scalable/apps/${desktopIcon}.svg`,
        `/opt/apps/${pkgname}/entries/icons/hicolor/48x48/apps/${desktopIcon}.png`,
      ]);
      if (resolvedIcon) {
        return resolvedIcon;
      }
    }
  }
  return "";
 };
 const resolveIconName = (iconName: string, candidates: string[]): string => {
  if (path.isAbsolute(iconName)) {
    return fs.existsSync(iconName) ? iconName : "";
  }
  for (const candidate of candidates) {
    if (fs.existsSync(candidate)) {
      return candidate;
    }
  }
  return "";
 };
 export const resolveDesktopIcon = (pkgname: string): string => {
  return findDesktopIconInDirectories(
    ["/usr/share/applications", `/opt/apps/${pkgname}/entries/applications`],
    pkgname,
  );
 };
 export const resolveApmIcon = (pkgname: string): string => {
  const apmRoots = [APM_BASE_PATH, "/opt/apps"];
  for (const apmRoot of apmRoots) {
    const desktopDirectory = path.join(
      apmRoot,
      pkgname,
      "entries",
      "applications",
    );
    if (!fs.existsSync(desktopDirectory)) {
      continue;
    }
    for (const desktopFile of fs.readdirSync(desktopDirectory)) {
      if (!desktopFile.endsWith(".desktop")) {
        continue;
      }
      const desktopIcon = readDesktopIcon(
        path.join(desktopDirectory, desktopFile),
      );
      if (!desktopIcon) {
        continue;
      }
      const resolvedIcon = resolveIconName(desktopIcon, [
        path.join(
          apmRoot,
          pkgname,
          "entries",
          "icons",
          "hicolor",
          "48x48",
          "apps",
          `${desktopIcon}.png`,
        ),
        path.join(
          apmRoot,
          pkgname,
          "entries",
          "icons",
          "hicolor",
          "scalable",
          "apps",
          `${desktopIcon}.svg`,
        ),
        `/usr/share/pixmaps/${desktopIcon}.png`,
        `/usr/share/icons/hicolor/48x48/apps/${desktopIcon}.png`,
        `/usr/share/icons/hicolor/scalable/apps/${desktopIcon}.svg`,
      ]);
      if (resolvedIcon) {
        return resolvedIcon;
      }
    }
  }
  return "";
 };
 export const buildRemoteFallbackIconUrl = ({
  pkgname,
  source,
  arch,
  category,
 }: Pick<
  UpdateCenterItem,
  "pkgname" | "source" | "arch" | "category"
 >): string => {
  const baseUrl = trimTrailingSlashes(REMOTE_ICON_BASE_URL);
  if (!baseUrl || !arch || !category) {
    return "";
  }
  const storeArch = arch.includes("-")
    ? arch
    : `${arch}-${source === "aptss" ? "store" : "apm"}`;
  return `${baseUrl}/${storeArch}/${category}/${pkgname}/icon.png`;
 };
 export const resolveUpdateItemIcons = (
  item: UpdateCenterItem,
 ): Pick<UpdateCenterItem, "localIcon" | "remoteIcon"> => {
  const localIcon =
    item.source === "aptss"
      ? resolveDesktopIcon(item.pkgname)
      : resolveApmIcon(item.pkgname);
  const remoteIcon = buildRemoteFallbackIconUrl({
    pkgname: item.pkgname,
    source: item.source,
    arch: item.arch,
    category: item.category,
  });
  if (localIcon && remoteIcon) {
    return { localIcon, remoteIcon };
  }
  if (localIcon) {
    return { localIcon };
  }
  if (remoteIcon) {
    return { remoteIcon };
  }
  return {};
 };
@@ -1,98 +0,0 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { dirname } from "node:path";
 import { join } from "node:path";
 import type { UpdateCenterItem } from "./types";
 export const IGNORE_CONFIG_PATH = join(
  homedir(),
  ".config",
  "spark-store",
  "ignored_apps.conf",
 );
 const LEGACY_IGNORE_SEPARATOR = "|";
 export const createIgnoreKey = (pkgname: string, version: string): string =>
  `${pkgname}${LEGACY_IGNORE_SEPARATOR}${version}`;
 export const parseIgnoredEntries = (content: string): Set<string> => {
  const ignoredEntries = new Set<string>();
  for (const line of content.split("\n")) {
    const trimmed = line.trim();
    if (!trimmed) {
      continue;
    }
    const parts = trimmed.split(LEGACY_IGNORE_SEPARATOR);
    if (parts.length !== 2) {
      continue;
    }
    const [pkgname, version] = parts;
    if (!pkgname || !version) {
      continue;
    }
    ignoredEntries.add(createIgnoreKey(pkgname, version));
  }
  return ignoredEntries;
 };
 export const loadIgnoredEntries = async (
  filePath: string,
 ): Promise<Set<string>> => {
  try {
    const content = await readFile(filePath, "utf8");
    return parseIgnoredEntries(content);
  } catch (error) {
    if (
      typeof error === "object" &&
      error !== null &&
      "code" in error &&
      error.code === "ENOENT"
    ) {
      return new Set<string>();
    }
    throw error;
  }
 };
 export const saveIgnoredEntries = async (
  filePath: string,
  ignoredEntries: ReadonlySet<string>,
 ): Promise<void> => {
  const sortedEntries = Array.from(ignoredEntries).sort();
  const content =
    sortedEntries.length > 0 ? `${sortedEntries.join("\n")}\n` : "";
  await mkdir(dirname(filePath), { recursive: true });
  await writeFile(filePath, content, "utf8");
 };
 export const applyIgnoredEntries = (
  items: UpdateCenterItem[],
  ignoredEntries: ReadonlySet<string>,
 ): UpdateCenterItem[] =>
  items.map((item) => ({
    ...item,
    ignored: ignoredEntries.has(
      createIgnoreKey(item.pkgname, item.nextVersion),
    ),
  }));
 export const sortIgnoredItems = (
  items: UpdateCenterItem[],
 ): UpdateCenterItem[] => {
  return [...items].sort((left, right) => {
    if (left.ignored === right.ignored) {
      return 0;
    }
    return left.ignored === true ? 1 : -1;
  });
 };
@@ -1,573 +0,0 @@
 import { spawn } from "node:child_process";
 import { BrowserWindow, ipcMain } from "electron";
 import {
  buildInstalledSourceMap,
  mergeUpdateSources,
  parseApmUpgradableOutput,
  parseAptssUpgradableOutput,
  parsePrintUrisOutput,
 } from "./query";
 import { resolveUpdateItemIcons } from "./icons";
 import {
  createUpdateCenterService,
  type StoreFilter,
  type UpdateCenterIgnorePayload,
  type UpdateCenterService,
  type UpdateCenterStartTask,
 } from "./service";
 import type { UpdateCenterItem } from "./types";
 export interface UpdateCenterCommandResult {
  code: number;
  stdout: string;
  stderr: string;
 }
 export type UpdateCenterCommandRunner = (
  command: string,
  args: string[],
 ) => Promise<UpdateCenterCommandResult>;
 export interface UpdateCenterLoadItemsResult {
  items: UpdateCenterItem[];
  warnings: string[];
 }
 interface RemoteAppMetadata {
  category: string;
  name?: string;
 }
 type StoreAppMetadataMap = Map<string, RemoteAppMetadata>;
 interface RemoteCategoryAppEntry {
  Name?: string;
  Pkgname?: string;
 }
 const REMOTE_STORE_BASE_URL = "https://erotica.spark-app.store";
 const categoryCache = new Map<string, Promise<StoreAppMetadataMap>>();
 const APTSS_LIST_UPGRADABLE_COMMAND = {
  command: "bash",
  args: [
    "-lc",
    "env LANGUAGE=en_US /usr/bin/apt -c /opt/durapps/spark-store/bin/apt-fast-conf/aptss-apt.conf list --upgradable -o Dir::Etc::sourcelist=/opt/durapps/spark-store/bin/apt-fast-conf/sources.list.d/aptss.list -o Dir::Etc::sourceparts=/dev/null -o APT::Get::List-Cleanup=0 | awk 'NR>1'",
  ],
 };
 const DPKG_QUERY_INSTALLED_COMMAND = {
  command: "dpkg-query",
  args: [
    "-W",
    "-f=${Package}\t${db:Status-Want} ${db:Status-Status} ${db:Status-Eflag}\n",
  ],
 };
 const getApmPrintUrisCommand = (pkgname: string) => ({
  command: "bash",
  args: [
    "-lc",
    `amber-pm-debug /usr/bin/apt -c /opt/durapps/spark-store/bin/apt-fast-conf/aptss-apt.conf download ${pkgname} --print-uris`,
  ],
 });
 const getAptssPrintUrisCommand = (pkgname: string) => ({
  command: "bash",
  args: [
    "-lc",
    `/usr/bin/apt download ${pkgname} --print-uris -c /opt/durapps/spark-store/bin/apt-fast-conf/aptss-apt.conf -o Dir::Etc::sourcelist=/opt/durapps/spark-store/bin/apt-fast-conf/sources.list.d/aptss.list -o Dir::Etc::sourceparts=/dev/null`,
  ],
 });
 const runCommandCapture: UpdateCenterCommandRunner = async (
  command,
  args,
 ): Promise<UpdateCenterCommandResult> =>
  await new Promise((resolve) => {
    const child = spawn(command, args, {
      shell: false,
      env: process.env,
    });
    let stdout = "";
    let stderr = "";
    child.stdout?.on("data", (data) => {
      stdout += data.toString();
    });
    child.stderr?.on("data", (data) => {
      stderr += data.toString();
    });
    child.on("error", (error) => {
      resolve({ code: -1, stdout, stderr: error.message });
    });
    child.on("close", (code) => {
      resolve({ code: code ?? -1, stdout, stderr });
    });
  });
 const getCommandError = (
  label: string,
  result: UpdateCenterCommandResult,
 ): string | null => {
  if (result.code === 0) {
    return null;
  }
  return `${label} failed: ${result.stderr || result.stdout || `exit code ${result.code}`}`;
 };
 const loadApmItemMetadata = async (
  item: UpdateCenterItem,
  runCommand: UpdateCenterCommandRunner,
 ): Promise<
  | { item: UpdateCenterItem; warning?: undefined }
  | { item: null; warning: string }
 > => {
  const printUrisCommand = getApmPrintUrisCommand(item.pkgname);
  const metadataResult = await runCommand(
    printUrisCommand.command,
    printUrisCommand.args,
  );
  const commandError = getCommandError(
    `apm metadata query for ${item.pkgname}`,
    metadataResult,
  );
  if (commandError) {
    return { item: null, warning: commandError };
  }
  const metadata = parsePrintUrisOutput(metadataResult.stdout);
  if (!metadata) {
    return {
      item: null,
      warning: `apm metadata query for ${item.pkgname} returned no package metadata`,
    };
  }
  return {
    item: {
      ...item,
      ...metadata,
    },
  };
 };
 const loadAptssItemMetadata = async (
  item: UpdateCenterItem,
  runCommand: UpdateCenterCommandRunner,
 ): Promise<
  | { item: UpdateCenterItem; warning?: undefined }
  | { item: null; warning: string }
 > => {
  console.log(`[DEBUG] Loading APTSS metadata for ${item.pkgname}`);
  const printUrisCommand = getAptssPrintUrisCommand(item.pkgname);
  console.log(
    `[DEBUG] APTSS command: ${printUrisCommand.command} ${printUrisCommand.args.join(" ")}`,
  );
  const metadataResult = await runCommand(
    printUrisCommand.command,
    printUrisCommand.args,
  );
  console.log(`[DEBUG] APTSS metadata result code: ${metadataResult.code}`);
  console.log(
    `[DEBUG] APTSS metadata stdout: ${metadataResult.stdout.substring(0, 500)}`,
  );
  console.log(
    `[DEBUG] APTSS metadata stderr: ${metadataResult.stderr.substring(0, 500)}`,
  );
  const commandError = getCommandError(
    `aptss metadata query for ${item.pkgname}`,
    metadataResult,
  );
  if (commandError) {
    console.log(`[DEBUG] APTSS metadata error: ${commandError}`);
    return { item: null, warning: commandError };
  }
  const metadata = parsePrintUrisOutput(metadataResult.stdout);
  if (metadata) {
    console.log(`[DEBUG] APTSS parsed metadata:`, {
      ...metadata,
      downloadUrl: `${metadata.downloadUrl}.metalink`,
    });
  } else {
    console.log(`[DEBUG] APTSS parsed metadata:`, metadata);
  }
  if (!metadata) {
    return {
      item: null,
      warning: `aptss metadata query for ${item.pkgname} returned no package metadata`,
    };
  }
  return {
    item: {
      ...item,
      ...metadata,
    },
  };
 };
 const enrichApmItems = async (
  items: UpdateCenterItem[],
  runCommand: UpdateCenterCommandRunner,
 ): Promise<UpdateCenterLoadItemsResult> => {
  const results = await Promise.all(
    items.map((item) => loadApmItemMetadata(item, runCommand)),
  );
  return {
    items: results.flatMap((result) => (result.item ? [result.item] : [])),
    warnings: results.flatMap((result) =>
      result.warning ? [result.warning] : [],
    ),
  };
 };
 const enrichAptssItems = async (
  items: UpdateCenterItem[],
  runCommand: UpdateCenterCommandRunner,
 ): Promise<UpdateCenterLoadItemsResult> => {
  const results = await Promise.all(
    items.map((item) => loadAptssItemMetadata(item, runCommand)),
  );
  return {
    items: results.flatMap((result) => (result.item ? [result.item] : [])),
    warnings: results.flatMap((result) =>
      result.warning ? [result.warning] : [],
    ),
  };
 };
 const getStoreArch = (
  item: Pick<UpdateCenterItem, "source" | "arch">,
 ): string => {
  const arch = item.arch;
  if (!arch) {
    return "";
  }
  if (arch.includes("-")) {
    return arch;
  }
  return `${arch}-${item.source === "aptss" ? "store" : "apm"}`;
 };
 const loadJson = async <T>(url: string): Promise<T> => {
  const response = await fetch(url);
  if (!response.ok) {
    throw new Error(`Request failed for ${url}`);
  }
  return (await response.json()) as T;
 };
 const loadStoreCategoryMap = async (
  storeArch: string,
 ): Promise<StoreAppMetadataMap> => {
  const categories = await loadJson<Record<string, unknown>>(
    `${REMOTE_STORE_BASE_URL}/${storeArch}/categories.json`,
  );
  const categoryEntries = await Promise.allSettled(
    Object.keys(categories).map(async (category) => {
      const apps = await loadJson<RemoteCategoryAppEntry[]>(
        `${REMOTE_STORE_BASE_URL}/${storeArch}/${category}/applist.json`,
      );
      return { apps, category };
    }),
  );
  const categoryMap: StoreAppMetadataMap = new Map();
  for (const entry of categoryEntries) {
    if (entry.status !== "fulfilled") {
      continue;
    }
    for (const app of entry.value.apps) {
      if (app.Pkgname && !categoryMap.has(app.Pkgname)) {
        categoryMap.set(app.Pkgname, {
          category: entry.value.category,
          name: app.Name,
        });
      }
    }
  }
  return categoryMap;
 };
 const getStoreCategoryMap = (
  storeArch: string,
 ): Promise<StoreAppMetadataMap> => {
  const cached = categoryCache.get(storeArch);
  if (cached) {
    return cached;
  }
  const pending = loadStoreCategoryMap(storeArch).catch(() => {
    categoryCache.delete(storeArch);
    return new Map();
  });
  categoryCache.set(storeArch, pending);
  return pending;
 };
 const enrichItemCategories = async (
  items: UpdateCenterItem[],
 ): Promise<UpdateCenterItem[]> => {
  return await Promise.all(
    items.map(async (item) => {
      if (item.category) {
        return item;
      }
      const storeArch = getStoreArch(item);
      if (!storeArch) {
        return item;
      }
      const categoryMap = await getStoreCategoryMap(storeArch);
      const metadata = categoryMap.get(item.pkgname);
      return metadata
        ? {
            ...item,
            category: metadata.category,
            ...(metadata.name ? { name: metadata.name } : {}),
          }
        : item;
    }),
  );
 };
 const enrichItemIcons = (items: UpdateCenterItem[]): UpdateCenterItem[] => {
  return items.map((item) => {
    const icons = resolveUpdateItemIcons(item);
    return Object.keys(icons).length > 0 ? { ...item, ...icons } : item;
  });
 };
 const isSourceEnabled = (
  storeFilter: StoreFilter,
  source: "spark" | "apm",
 ): boolean => {
  return storeFilter === "both" || storeFilter === source;
 };
 const isCommandAvailable = async (
  runCommand: UpdateCenterCommandRunner,
  command: "aptss" | "apm",
 ): Promise<boolean> => {
  const result = await runCommand("which", [command]);
  return result.code === 0 && result.stdout.trim().length > 0;
 };
 export const loadUpdateCenterItems = async (
  storeFilter: StoreFilter = "both",
  runCommand: UpdateCenterCommandRunner = runCommandCapture,
 ): Promise<UpdateCenterLoadItemsResult> => {
  console.log(
    `[UpdateCenter] loadUpdateCenterItems called with storeFilter=${storeFilter}`,
  );
  const [sparkEnabled, apmEnabled] = await Promise.all([
    isSourceEnabled(storeFilter, "spark")
      ? isCommandAvailable(runCommand, "aptss")
      : Promise.resolve(false),
    isSourceEnabled(storeFilter, "apm")
      ? isCommandAvailable(runCommand, "apm")
      : Promise.resolve(false),
  ]);
  console.log(
    `[UpdateCenter] sparkEnabled=${sparkEnabled}, apmEnabled=${apmEnabled}`,
  );
  const [aptssResult, apmResult, aptssInstalledResult, apmInstalledResult] =
    await Promise.all([
      sparkEnabled
        ? runCommand(
            APTSS_LIST_UPGRADABLE_COMMAND.command,
            APTSS_LIST_UPGRADABLE_COMMAND.args,
          )
        : Promise.resolve({ code: 0, stdout: "", stderr: "" }),
      apmEnabled
        ? runCommand("apm", ["list", "--upgradable"])
        : Promise.resolve({ code: 0, stdout: "", stderr: "" }),
      sparkEnabled
        ? runCommand(
            DPKG_QUERY_INSTALLED_COMMAND.command,
            DPKG_QUERY_INSTALLED_COMMAND.args,
          )
        : Promise.resolve({ code: 0, stdout: "", stderr: "" }),
      apmEnabled
        ? runCommand("apm", ["list", "--installed"])
        : Promise.resolve({ code: 0, stdout: "", stderr: "" }),
    ]);
  console.log(
    `[UpdateCenter] aptssResult: code=${aptssResult.code}, stdout=${aptssResult.stdout.substring(0, 500)}, stderr=${aptssResult.stderr.substring(0, 500)}`,
  );
  console.log(
    `[UpdateCenter] apmResult: code=${apmResult.code}, stdout=${apmResult.stdout.substring(0, 500)}, stderr=${apmResult.stderr.substring(0, 500)}`,
  );
  console.log(
    `[UpdateCenter] aptssInstalledResult: code=${aptssInstalledResult.code}, stdout=${aptssInstalledResult.stdout.substring(0, 500)}`,
  );
  console.log(
    `[UpdateCenter] apmInstalledResult: code=${apmInstalledResult.code}, stdout=${apmInstalledResult.stdout.substring(0, 500)}`,
  );
  const aptssAvailable =
    sparkEnabled && (aptssResult.code === 0 || aptssInstalledResult.code === 0);
  const warnings = [
    aptssAvailable
      ? getCommandError("aptss upgradable query", aptssResult)
      : null,
    apmEnabled ? getCommandError("apm upgradable query", apmResult) : null,
    aptssAvailable
      ? getCommandError("dpkg installed query", aptssInstalledResult)
      : null,
    apmEnabled
      ? getCommandError("apm installed query", apmInstalledResult)
      : null,
  ].filter((message): message is string => message !== null);
  const aptssItems =
    aptssAvailable && aptssResult.code === 0
      ? parseAptssUpgradableOutput(aptssResult.stdout)
      : [];
  const apmItems =
    apmEnabled && apmResult.code === 0
      ? parseApmUpgradableOutput(apmResult.stdout)
      : [];
  console.log(
    `[UpdateCenter] parsed aptssItems count=${aptssItems.length}`,
    aptssItems.map((i) => `${i.pkgname} ${i.currentVersion}->${i.nextVersion}`),
  );
  console.log(
    `[UpdateCenter] parsed apmItems count=${apmItems.length}`,
    apmItems.map((i) => `${i.pkgname} ${i.currentVersion}->${i.nextVersion}`),
  );
  const installedSources = buildInstalledSourceMap(
    aptssAvailable && aptssInstalledResult.code === 0
      ? aptssInstalledResult.stdout
      : "",
    apmInstalledResult.code === 0 ? apmInstalledResult.stdout : "",
  );
  console.log(`[UpdateCenter] installedSources size=${installedSources.size}`);
  const [categorizedAptssItems, categorizedApmItems] = await Promise.all([
    aptssAvailable ? enrichItemCategories(aptssItems) : Promise.resolve([]),
    apmEnabled ? enrichItemCategories(apmItems) : Promise.resolve([]),
  ]);
  const [enrichedAptssItems, enrichedApmItems] = await Promise.all([
    aptssAvailable
      ? enrichAptssItems(categorizedAptssItems, runCommand)
      : Promise.resolve({ items: [], warnings: [] }),
    apmEnabled
      ? enrichApmItems(categorizedApmItems, runCommand)
      : Promise.resolve({ items: [], warnings: [] }),
  ]);
  console.log(
    `[UpdateCenter] enrichedAptssItems: count=${enrichedAptssItems.items.length}, warnings=${enrichedAptssItems.warnings.length}`,
    enrichedAptssItems.warnings,
  );
  console.log(
    `[UpdateCenter] enrichedApmItems: count=${enrichedApmItems.items.length}, warnings=${enrichedApmItems.warnings.length}`,
    enrichedApmItems.warnings,
  );
  const mergedItems = mergeUpdateSources(
    enrichItemIcons(enrichedAptssItems.items),
    enrichItemIcons(enrichedApmItems.items),
    installedSources,
  );
  console.log(
    `[UpdateCenter] mergedItems count=${mergedItems.length}`,
    mergedItems.map(
      (i) => `${i.pkgname} (${i.source}) ${i.currentVersion}->${i.nextVersion}`,
    ),
  );
  return {
    items: mergedItems,
    warnings: [
      ...warnings,
      ...enrichedAptssItems.warnings,
      ...enrichedApmItems.warnings,
    ],
  };
 };
 export const registerUpdateCenterIpc = (
  ipc: Pick<typeof ipcMain, "handle">,
  service: Pick<
    UpdateCenterService,
    | "open"
    | "refresh"
    | "ignore"
    | "unignore"
    | "start"
    | "cancel"
    | "getState"
    | "subscribe"
  >,
 ): void => {
  ipc.handle(
    "update-center-open",
    (_event, storeFilter: StoreFilter = "both") => service.open(storeFilter),
  );
  ipc.handle(
    "update-center-refresh",
    (_event, storeFilter: StoreFilter = "both") => service.refresh(storeFilter),
  );
  ipc.handle(
    "update-center-ignore",
    (_event, payload: UpdateCenterIgnorePayload) => service.ignore(payload),
  );
  ipc.handle(
    "update-center-unignore",
    (_event, payload: UpdateCenterIgnorePayload) => service.unignore(payload),
  );
  ipc.handle("update-center-start", (_event, tasks: UpdateCenterStartTask[]) =>
    service.start(tasks),
  );
  ipc.handle("update-center-cancel", (_event, taskKey: string) =>
    service.cancel(taskKey),
  );
  ipc.handle("update-center-get-state", () => service.getState());
  service.subscribe((snapshot) => {
    for (const win of BrowserWindow.getAllWindows()) {
      win.webContents.send("update-center-state", snapshot);
    }
  });
 };
 let updateCenterService: UpdateCenterService | null = null;
 export const initializeUpdateCenter = (): UpdateCenterService => {
  if (updateCenterService) {
    return updateCenterService;
  }
  updateCenterService = createUpdateCenterService({
    loadItems: loadUpdateCenterItems,
  });
  registerUpdateCenterIpc(ipcMain, updateCenterService);
  return updateCenterService;
 };
 export { createUpdateCenterService } from "./service";
@@ -1,195 +0,0 @@
 import { join } from "node:path";
 import { runAria2Download, type Aria2DownloadResult } from "./download";
 import { installPackage } from "../shared-installer";
 import type { UpdateCenterQueue, UpdateCenterTask } from "./queue";
 import type { UpdateCenterItem } from "./types";
 const DEFAULT_DOWNLOAD_ROOT = "/tmp/spark-store/update-center";
 export interface InstallUpdateItemOptions {
  item: UpdateCenterItem;
  filePath?: string;
  superUserCmd?: string;
  onLog?: (message: string) => void;
  signal?: AbortSignal;
 }
 export interface TaskRunnerDownloadContext {
  item: UpdateCenterItem;
  task: UpdateCenterTask;
  onProgress: (progress: number) => void;
  onLog: (message: string) => void;
  signal: AbortSignal;
 }
 export interface TaskRunnerInstallContext {
  item: UpdateCenterItem;
  task: UpdateCenterTask;
  filePath?: string;
  superUserCmd?: string;
  onLog: (message: string) => void;
  signal: AbortSignal;
 }
 export interface TaskRunnerDependencies {
  runDownload?: (
    context: TaskRunnerDownloadContext,
  ) => Promise<Aria2DownloadResult>;
  installItem?: (context: TaskRunnerInstallContext) => Promise<void>;
 }
 export interface UpdateCenterTaskRunner {
  runNextTask: () => Promise<UpdateCenterTask | null>;
  cancelActiveTask: () => void;
 }
 export interface CreateTaskRunnerOptions extends TaskRunnerDependencies {
  superUserCmd?: string;
 }
 /**
 * 安装更新项
 * 使用与商店安装相同的逻辑
 */
 export const installUpdateItem = async ({
  item,
  filePath,
  superUserCmd,
  onLog,
  signal,
 }: InstallUpdateItemOptions): Promise<void> => {
  if (!filePath) {
    throw new Error(
      `Update task for ${item.pkgname} requires downloaded package file`,
    );
  }
  // 使用与商店安装相同的安装逻辑
  const origin = item.source === "apm" ? "apm" : "spark";
  await installPackage({
    pkgname: item.pkgname,
    filePath,
    origin,
    superUserCmd,
    onLog,
    signal,
  });
 };
 export const createTaskRunner = (
  queue: UpdateCenterQueue,
  options: CreateTaskRunnerOptions = {},
 ): UpdateCenterTaskRunner => {
  const runDownload =
    options.runDownload ??
    ((context: TaskRunnerDownloadContext) =>
      runAria2Download({
        item: context.item,
        downloadDir: join(DEFAULT_DOWNLOAD_ROOT, context.item.pkgname),
        onProgress: context.onProgress,
        onLog: context.onLog,
        signal: context.signal,
      }));
  const installItem =
    options.installItem ??
    ((context: TaskRunnerInstallContext) =>
      installUpdateItem({
        item: context.item,
        filePath: context.filePath,
        superUserCmd: context.superUserCmd,
        onLog: context.onLog,
        signal: context.signal,
      }));
  let inFlightTask: Promise<UpdateCenterTask | null> | null = null;
  let activeAbortController: AbortController | null = null;
  let activeTaskId: number | null = null;
  return {
    cancelActiveTask: () => {
      activeAbortController?.abort();
    },
    runNextTask: async () => {
      if (inFlightTask) {
        return null;
      }
      inFlightTask = (async () => {
        const task = queue.getNextQueuedTask();
        if (!task) {
          return null;
        }
        activeTaskId = task.id;
        activeAbortController = new AbortController();
        const onLog = (message: string) => {
          queue.appendTaskLog(task.id, message);
        };
        try {
          // All updates require download metadata
          if (!task.item.downloadUrl || !task.item.fileName) {
            throw new Error(
              `Update task for ${task.item.pkgname} requires download metadata (URL and filename)`,
            );
          }
          queue.markActiveTask(task.id, "downloading");
          const result = await runDownload({
            item: task.item,
            task,
            onLog,
            signal: activeAbortController.signal,
            onProgress: (progress) => {
              queue.updateTaskProgress(task.id, progress);
            },
          });
          const filePath = result.filePath;
          queue.markActiveTask(task.id, "installing");
          await installItem({
            item: task.item,
            task,
            filePath,
            superUserCmd: options.superUserCmd,
            onLog,
            signal: activeAbortController.signal,
          });
          const currentTask = queue
            .getSnapshot()
            .tasks.find((entry) => entry.id === task.id);
          if (currentTask?.status !== "cancelled") {
            queue.finishTask(task.id, "completed");
          }
          return task;
        } catch (error) {
          const message =
            error instanceof Error ? error.message : String(error);
          const currentTask = queue
            .getSnapshot()
            .tasks.find((entry) => entry.id === task.id);
          if (currentTask?.status !== "cancelled") {
            queue.appendTaskLog(task.id, message);
            queue.finishTask(task.id, "failed", message);
          }
          return task;
        } finally {
          activeAbortController = null;
          activeTaskId = null;
        }
      })();
      try {
        return await inFlightTask;
      } finally {
        inFlightTask = null;
        if (activeTaskId === null) {
          activeAbortController = null;
        }
      }
    },
  };
 };
@@ -1,408 +0,0 @@
 import * as childProcess from "node:child_process";
 import type {
  InstalledSourceState,
  UpdateCenterItem,
  UpdateSource,
 } from "./types";
 const PRINT_URIS_PATTERN = /'([^']+)'\s+(\S+)\s+(\d+)\s+SHA512:([^\s]+)/;
 const APM_INSTALLED_PATTERN = /^(\S+)\/\S+(?:,\S+)?\s+\S+\s+\S+\s+\[[^\]]+\]$/;
 const CURRENT_VERSION_PATTERN = /\[(?:upgradable from|from):\s*([^\]\s]+)\]/i;
 const splitVersion = (version: string) => {
  const epochMatch = version.match(/^(\d+):(.*)$/);
  const epoch = epochMatch ? Number(epochMatch[1]) : 0;
  const remainder = epochMatch ? epochMatch[2] : version;
  const hyphenIndex = remainder.lastIndexOf("-");
  return {
    epoch,
    upstream: hyphenIndex === -1 ? remainder : remainder.slice(0, hyphenIndex),
    revision: hyphenIndex === -1 ? "" : remainder.slice(hyphenIndex + 1),
  };
 };
 const getNonDigitOrder = (char: string | undefined): number => {
  if (char === "~") {
    return -1;
  }
  if (!char) {
    return 0;
  }
  if (/[A-Za-z]/.test(char)) {
    return char.charCodeAt(0);
  }
  return char.charCodeAt(0) + 256;
 };
 const compareNonDigitPart = (left: string, right: string): number => {
  let leftIndex = 0;
  let rightIndex = 0;
  while (true) {
    const leftChar = left[leftIndex];
    const rightChar = right[rightIndex];
    const leftIsDigit = leftChar !== undefined && /\d/.test(leftChar);
    const rightIsDigit = rightChar !== undefined && /\d/.test(rightChar);
    if (
      (leftChar === undefined || leftIsDigit) &&
      (rightChar === undefined || rightIsDigit)
    ) {
      return 0;
    }
    const leftOrder = getNonDigitOrder(leftIsDigit ? undefined : leftChar);
    const rightOrder = getNonDigitOrder(rightIsDigit ? undefined : rightChar);
    if (leftOrder !== rightOrder) {
      return leftOrder < rightOrder ? -1 : 1;
    }
    if (!leftIsDigit && leftChar !== undefined) {
      leftIndex += 1;
    }
    if (!rightIsDigit && rightChar !== undefined) {
      rightIndex += 1;
    }
  }
 };
 const compareDigitPart = (left: string, right: string): number => {
  const normalizedLeft = left.replace(/^0+/, "");
  const normalizedRight = right.replace(/^0+/, "");
  if (normalizedLeft.length !== normalizedRight.length) {
    return normalizedLeft.length < normalizedRight.length ? -1 : 1;
  }
  if (normalizedLeft === normalizedRight) {
    return 0;
  }
  return normalizedLeft < normalizedRight ? -1 : 1;
 };
 const compareVersionPart = (left: string, right: string): number => {
  let leftIndex = 0;
  let rightIndex = 0;
  while (leftIndex < left.length || rightIndex < right.length) {
    const nonDigitResult = compareNonDigitPart(
      left.slice(leftIndex),
      right.slice(rightIndex),
    );
    if (nonDigitResult !== 0) {
      return nonDigitResult;
    }
    while (leftIndex < left.length && !/\d/.test(left[leftIndex])) {
      leftIndex += 1;
    }
    while (rightIndex < right.length && !/\d/.test(right[rightIndex])) {
      rightIndex += 1;
    }
    let leftDigitsEnd = leftIndex;
    let rightDigitsEnd = rightIndex;
    while (leftDigitsEnd < left.length && /\d/.test(left[leftDigitsEnd])) {
      leftDigitsEnd += 1;
    }
    while (rightDigitsEnd < right.length && /\d/.test(right[rightDigitsEnd])) {
      rightDigitsEnd += 1;
    }
    const digitResult = compareDigitPart(
      left.slice(leftIndex, leftDigitsEnd),
      right.slice(rightIndex, rightDigitsEnd),
    );
    if (digitResult !== 0) {
      return digitResult;
    }
    leftIndex = leftDigitsEnd;
    rightIndex = rightDigitsEnd;
  }
  return 0;
 };
 const fallbackCompareVersions = (left: string, right: string): number => {
  const leftVersion = splitVersion(left);
  const rightVersion = splitVersion(right);
  if (leftVersion.epoch !== rightVersion.epoch) {
    return leftVersion.epoch < rightVersion.epoch ? -1 : 1;
  }
  const upstreamResult = compareVersionPart(
    leftVersion.upstream,
    rightVersion.upstream,
  );
  if (upstreamResult !== 0) {
    return upstreamResult;
  }
  return compareVersionPart(leftVersion.revision, rightVersion.revision);
 };
 const runDpkgVersionCheck = (
  left: string,
  operator: "gt" | "lt",
  right: string,
 ): boolean | null => {
  const result = childProcess.spawnSync("dpkg", [
    "--compare-versions",
    left,
    operator,
    right,
  ]);
  if (result.error || typeof result.status !== "number") {
    return null;
  }
  if (result.status === 0) {
    return true;
  }
  if (result.status === 1) {
    return false;
  }
  return null;
 };
 const parseUpgradableOutput = (
  output: string,
  source: UpdateSource,
 ): UpdateCenterItem[] => {
  const items: UpdateCenterItem[] = [];
  for (const line of output.split("\n")) {
    const trimmed = line
      .replace(
        // eslint-disable-next-line no-control-regex
        /\x1b\[[0-9;]*m/g,
        "",
      )
      .trim();
    if (!trimmed || trimmed.startsWith("Listing") || !trimmed.includes("/")) {
      continue;
    }
    const tokens = trimmed.split(/\s+/);
    if (tokens.length < 3) {
      continue;
    }
    const pkgname = tokens[0]?.split("/")[0] ?? "";
    const nextVersion = tokens[1] ?? "";
    const arch = tokens[2] ?? "";
    const currentVersion =
      trimmed.match(CURRENT_VERSION_PATTERN)?.[1] ?? tokens[5] ?? "";
    if (!pkgname || nextVersion === currentVersion) {
      continue;
    }
    items.push({
      pkgname,
      source,
      currentVersion,
      nextVersion,
      arch,
    });
  }
  return items;
 };
 const getInstalledState = (
  installedSources: Map<string, InstalledSourceState>,
  pkgname: string,
 ): InstalledSourceState => {
  const existing = installedSources.get(pkgname);
  if (existing) {
    return existing;
  }
  const state: InstalledSourceState = { aptss: false, apm: false };
  installedSources.set(pkgname, state);
  return state;
 };
 const compareVersions = (left: string, right: string): number => {
  const greaterThan = runDpkgVersionCheck(left, "gt", right);
  if (greaterThan === true) {
    return 1;
  }
  const lessThan = runDpkgVersionCheck(left, "lt", right);
  if (lessThan === true) {
    return -1;
  }
  if (greaterThan === false && lessThan === false) {
    return 0;
  }
  // Fall back to a numeric-aware string comparison when dpkg is unavailable
  // or returns an unusable result, rather than silently treating versions as equal.
  return fallbackCompareVersions(left, right);
 };
 export const parseAptssUpgradableOutput = (
  output: string,
 ): UpdateCenterItem[] => {
  console.log(
    `[UpdateCenter] parseAptssUpgradableOutput input (first 1000 chars): ${output.substring(0, 1000)}`,
  );
  const result = parseUpgradableOutput(output, "aptss");
  console.log(
    `[UpdateCenter] parseAptssUpgradableOutput result count=${result.length}`,
  );
  return result;
 };
 export const parseApmUpgradableOutput = (
  output: string,
 ): UpdateCenterItem[] => {
  console.log(
    `[UpdateCenter] parseApmUpgradableOutput input (first 1000 chars): ${output.substring(0, 1000)}`,
  );
  const result = parseUpgradableOutput(output, "apm");
  console.log(
    `[UpdateCenter] parseApmUpgradableOutput result count=${result.length}`,
  );
  return result;
 };
 export const parsePrintUrisOutput = (
  output: string,
 ): Pick<
  UpdateCenterItem,
  "downloadUrl" | "fileName" | "size" | "sha512"
 > | null => {
  const trimmed = output.trim();
  console.log(
    `[UpdateCenter] parsePrintUrisOutput input (first 500 chars): ${trimmed.substring(0, 500)}`,
  );
  const match = trimmed.match(PRINT_URIS_PATTERN);
  if (!match) {
    console.log(
      `[UpdateCenter] parsePrintUrisOutput: no match found for pattern ${PRINT_URIS_PATTERN}`,
    );
    return null;
  }
  const [, rawDownloadUrl, fileName, size, sha512] = match;
  // Clean up the URL: remove backticks and extra spaces
  const downloadUrl = rawDownloadUrl.replace(/[`'"]/g, "").trim();
  return {
    downloadUrl,
    fileName,
    size: Number(size),
    sha512,
  };
 };
 export const buildInstalledSourceMap = (
  dpkgQueryOutput: string,
  apmInstalledOutput: string,
 ): Map<string, InstalledSourceState> => {
  const installedSources = new Map<string, InstalledSourceState>();
  for (const line of dpkgQueryOutput.split("\n")) {
    const trimmed = line.trim();
    if (!trimmed) {
      continue;
    }
    const [pkgname, status] = trimmed.split("\t");
    if (!pkgname || status !== "install ok installed") {
      continue;
    }
    getInstalledState(installedSources, pkgname).aptss = true;
  }
  for (const line of apmInstalledOutput.split("\n")) {
    const trimmed = line.trim();
    if (!trimmed || trimmed.startsWith("Listing")) {
      continue;
    }
    if (!APM_INSTALLED_PATTERN.test(trimmed)) {
      continue;
    }
    const pkgname = trimmed.split("/")[0];
    if (!pkgname) {
      continue;
    }
    getInstalledState(installedSources, pkgname).apm = true;
  }
  return installedSources;
 };
 export const mergeUpdateSources = (
  aptssItems: UpdateCenterItem[],
  apmItems: UpdateCenterItem[],
  installedSources: Map<string, InstalledSourceState>,
 ): UpdateCenterItem[] => {
  const aptssMap = new Map(aptssItems.map((item) => [item.pkgname, item]));
  const apmMap = new Map(apmItems.map((item) => [item.pkgname, item]));
  const merged: UpdateCenterItem[] = [];
  for (const item of aptssItems) {
    if (!apmMap.has(item.pkgname)) {
      merged.push(item);
    }
  }
  for (const item of apmItems) {
    if (!aptssMap.has(item.pkgname)) {
      merged.push(item);
    }
  }
  for (const aptssItem of aptssItems) {
    const apmItem = apmMap.get(aptssItem.pkgname);
    if (!apmItem) {
      continue;
    }
    const installedState = installedSources.get(aptssItem.pkgname);
    const isMigration =
      installedState?.aptss === true &&
      installedState.apm === false &&
      compareVersions(apmItem.nextVersion, aptssItem.nextVersion) > 0;
    if (isMigration) {
      merged.push({
        ...apmItem,
        isMigration: true,
        migrationSource: "aptss",
        migrationTarget: "apm",
        aptssVersion: aptssItem.nextVersion,
      });
      merged.push(aptssItem);
      continue;
    }
    merged.push(aptssItem, apmItem);
  }
  return merged;
 };
@@ -1,177 +0,0 @@
 import type { UpdateCenterItem } from "./types";
 export type UpdateCenterTaskStatus =
  | "queued"
  | "downloading"
  | "installing"
  | "completed"
  | "failed"
  | "cancelled";
 export interface UpdateCenterTaskLog {
  time: number;
  message: string;
 }
 export interface UpdateCenterTask {
  id: number;
  pkgname: string;
  item: UpdateCenterItem;
  status: UpdateCenterTaskStatus;
  progress: number;
  logs: UpdateCenterTaskLog[];
  error?: string;
 }
 export interface UpdateCenterQueueSnapshot {
  items: UpdateCenterItem[];
  tasks: UpdateCenterTask[];
  warnings: string[];
  hasRunningTasks: boolean;
 }
 export interface UpdateCenterQueue {
  setItems: (items: UpdateCenterItem[]) => void;
  startRefresh: () => void;
  finishRefresh: (warnings?: string[]) => void;
  enqueueItem: (item: UpdateCenterItem) => UpdateCenterTask;
  markActiveTask: (
    taskId: number,
    status: Extract<UpdateCenterTaskStatus, "downloading" | "installing">,
  ) => void;
  updateTaskProgress: (taskId: number, progress: number) => void;
  appendTaskLog: (taskId: number, message: string, time?: number) => void;
  finishTask: (
    taskId: number,
    status: Extract<
      UpdateCenterTaskStatus,
      "completed" | "failed" | "cancelled"
    >,
    error?: string,
  ) => void;
  getNextQueuedTask: () => UpdateCenterTask | undefined;
  getSnapshot: () => UpdateCenterQueueSnapshot;
 }
 const clampProgress = (progress: number): number => {
  if (!Number.isFinite(progress)) {
    return 0;
  }
  return Math.max(0, Math.min(100, Math.round(progress)));
 };
 const createSnapshot = (
  items: UpdateCenterItem[],
  tasks: UpdateCenterTask[],
  warnings: string[],
  refreshing: boolean,
 ): UpdateCenterQueueSnapshot => ({
  items: items.map((item) => ({ ...item })),
  tasks: tasks.map((task) => ({
    ...task,
    item: { ...task.item },
    logs: task.logs.map((log) => ({ ...log })),
  })),
  warnings: [...warnings],
  hasRunningTasks:
    refreshing ||
    tasks.some((task) =>
      ["queued", "downloading", "installing"].includes(task.status),
    ),
 });
 export const createUpdateCenterQueue = (): UpdateCenterQueue => {
  let items: UpdateCenterItem[] = [];
  let tasks: UpdateCenterTask[] = [];
  let warnings: string[] = [];
  let refreshing = false;
  let nextTaskId = 1;
  const getTaskIndex = (taskId: number): number =>
    tasks.findIndex((task) => task.id === taskId);
  return {
    setItems: (nextItems) => {
      items = nextItems.map((item) => ({ ...item }));
    },
    startRefresh: () => {
      refreshing = true;
    },
    finishRefresh: (nextWarnings = []) => {
      refreshing = false;
      warnings = [...nextWarnings];
    },
    enqueueItem: (item) => {
      const task: UpdateCenterTask = {
        id: nextTaskId,
        pkgname: item.pkgname,
        item: { ...item },
        status: "queued",
        progress: 0,
        logs: [],
      };
      nextTaskId += 1;
      tasks = [...tasks, task];
      return task;
    },
    markActiveTask: (taskId, status) => {
      const taskIndex = getTaskIndex(taskId);
      if (taskIndex === -1) {
        return;
      }
      // 创建新的 task 对象和新的 tasks 数组以触发状态更新
      tasks = tasks.map((task, index) =>
        index === taskIndex ? { ...task, status } : task,
      );
    },
    updateTaskProgress: (taskId, progress) => {
      const taskIndex = getTaskIndex(taskId);
      if (taskIndex === -1) {
        return;
      }
      // 创建新的 task 对象和新的 tasks 数组以触发状态更新
      tasks = tasks.map((task, index) =>
        index === taskIndex
          ? { ...task, progress: clampProgress(progress) }
          : task,
      );
    },
    appendTaskLog: (taskId, message, time = Date.now()) => {
      const taskIndex = getTaskIndex(taskId);
      if (taskIndex === -1) {
        return;
      }
      // 创建新的 task 对象和新的 tasks 数组以触发状态更新
      tasks = tasks.map((task, index) =>
        index === taskIndex
          ? { ...task, logs: [...task.logs, { time, message }] }
          : task,
      );
    },
    finishTask: (taskId, status, error) => {
      const taskIndex = getTaskIndex(taskId);
      if (taskIndex === -1) {
        return;
      }
      // 创建新的 task 对象和新的 tasks 数组以触发状态更新
      tasks = tasks.map((task, index) =>
        index === taskIndex
          ? {
              ...task,
              status,
              error,
              progress: status === "completed" ? 100 : task.progress,
            }
          : task,
      );
    },
    getNextQueuedTask: () => tasks.find((task) => task.status === "queued"),
    getSnapshot: () => createSnapshot(items, tasks, warnings, refreshing),
  };
 };
@@ -1,289 +0,0 @@
 import { BrowserWindow } from "electron";
 import {
  IGNORE_CONFIG_PATH,
  applyIgnoredEntries,
  createIgnoreKey,
  loadIgnoredEntries,
  saveIgnoredEntries,
  sortIgnoredItems,
 } from "./ignore-config";
 import {
  createUpdateCenterQueue,
  type UpdateCenterQueueSnapshot,
 } from "./queue";
 import type { UpdateCenterItem, UpdateSource } from "./types";
 export type StoreFilter = "spark" | "apm" | "both";
 export interface UpdateCenterLoadedItems {
  items: UpdateCenterItem[];
  warnings: string[];
 }
 export interface UpdateCenterServiceItem {
  taskKey: string;
  packageName: string;
  displayName: string;
  currentVersion: string;
  newVersion: string;
  source: UpdateSource;
  localIcon?: string;
  remoteIcon?: string;
  ignored?: boolean;
  downloadUrl?: string;
  fileName?: string;
  size?: number;
  sha512?: string;
  isMigration?: boolean;
  migrationSource?: UpdateSource;
  migrationTarget?: UpdateSource;
  aptssVersion?: string;
 }
 export interface UpdateCenterServiceTask {
  taskKey: string;
  packageName: string;
  source: UpdateSource;
  localIcon?: string;
  remoteIcon?: string;
  status: UpdateCenterQueueSnapshot["tasks"][number]["status"];
  progress: number;
  logs: UpdateCenterQueueSnapshot["tasks"][number]["logs"];
  errorMessage: string;
 }
 export interface UpdateCenterServiceState {
  items: UpdateCenterServiceItem[];
  tasks: UpdateCenterServiceTask[];
  warnings: string[];
  hasRunningTasks: boolean;
 }
 export interface UpdateCenterIgnorePayload {
  packageName: string;
  newVersion: string;
 }
 export interface UpdateCenterStartTask {
  taskKey: string;
  id: number;
 }
 export interface UpdateCenterService {
  open: (storeFilter?: StoreFilter) => Promise<UpdateCenterServiceState>;
  refresh: (storeFilter?: StoreFilter) => Promise<UpdateCenterServiceState>;
  ignore: (payload: UpdateCenterIgnorePayload) => Promise<void>;
  unignore: (payload: UpdateCenterIgnorePayload) => Promise<void>;
  start: (tasks: UpdateCenterStartTask[]) => Promise<void>;
  cancel: (taskKey: string) => Promise<void>;
  getState: () => UpdateCenterServiceState;
  subscribe: (
    listener: (snapshot: UpdateCenterServiceState) => void,
  ) => () => void;
 }
 export interface CreateUpdateCenterServiceOptions {
  loadItems: (
    storeFilter: StoreFilter,
  ) => Promise<UpdateCenterItem[] | UpdateCenterLoadedItems>;
  loadIgnoredEntries?: () => Promise<Set<string>>;
  saveIgnoredEntries?: (entries: ReadonlySet<string>) => Promise<void>;
 }
 const getTaskKey = (
  item: Pick<UpdateCenterItem, "pkgname" | "source">,
 ): string => `${item.source}:${item.pkgname}`;
 const toState = (
  snapshot: UpdateCenterQueueSnapshot,
 ): UpdateCenterServiceState => ({
  items: snapshot.items.map((item) => ({
    taskKey: getTaskKey(item),
    packageName: item.pkgname,
    displayName: item.name || item.pkgname,
    currentVersion: item.currentVersion,
    newVersion: item.nextVersion,
    source: item.source,
    localIcon: item.localIcon,
    remoteIcon: item.remoteIcon,
    ignored: item.ignored,
    downloadUrl: item.downloadUrl,
    fileName: item.fileName,
    size: item.size,
    sha512: item.sha512,
    isMigration: item.isMigration,
    migrationSource: item.migrationSource,
    migrationTarget: item.migrationTarget,
    aptssVersion: item.aptssVersion,
  })),
  tasks: [], // 不再展示任务日志
  warnings: [...snapshot.warnings],
  hasRunningTasks: false, // 任务不在更新中心执行
 });
 const normalizeLoadedItems = (
  loaded: UpdateCenterItem[] | UpdateCenterLoadedItems,
 ): UpdateCenterLoadedItems => {
  if (Array.isArray(loaded)) {
    return { items: loaded, warnings: [] };
  }
  return {
    items: loaded.items,
    warnings: loaded.warnings,
  };
 };
 export const createUpdateCenterService = (
  options: CreateUpdateCenterServiceOptions,
 ): UpdateCenterService => {
  const queue = createUpdateCenterQueue();
  const listeners = new Set<(snapshot: UpdateCenterServiceState) => void>();
  let currentStoreFilter: StoreFilter = "both";
  const loadIgnored =
    options.loadIgnoredEntries ??
    (() => loadIgnoredEntries(IGNORE_CONFIG_PATH));
  const saveIgnored =
    options.saveIgnoredEntries ??
    ((entries: ReadonlySet<string>) =>
      saveIgnoredEntries(IGNORE_CONFIG_PATH, entries));
  const applyWarning = (message: string): void => {
    queue.finishRefresh([message]);
  };
  const getState = (): UpdateCenterServiceState => toState(queue.getSnapshot());
  const emit = (): UpdateCenterServiceState => {
    const snapshot = getState();
    listeners.forEach((listener) => {
      listener(snapshot);
    });
    return snapshot;
  };
  const refresh = async (
    storeFilter: StoreFilter = currentStoreFilter,
  ): Promise<UpdateCenterServiceState> => {
    currentStoreFilter = storeFilter;
    console.log(
      `[UpdateCenter] service.refresh called with storeFilter=${storeFilter}`,
    );
    queue.startRefresh();
    emit();
    try {
      const ignoredEntries = await loadIgnored();
      console.log(`[UpdateCenter] ignoredEntries count=${ignoredEntries.size}`);
      const loadedItems = normalizeLoadedItems(
        await options.loadItems(currentStoreFilter),
      );
      console.log(
        `[UpdateCenter] loadItems returned: items=${loadedItems.items.length}, warnings=${loadedItems.warnings.length}`,
        loadedItems.warnings,
      );
      const items = sortIgnoredItems(
        applyIgnoredEntries(loadedItems.items, ignoredEntries),
      );
      console.log(
        `[UpdateCenter] after applying ignored: items=${items.length}`,
      );
      queue.setItems(items);
      queue.finishRefresh(loadedItems.warnings);
      return emit();
    } catch (error) {
      const message = error instanceof Error ? error.message : String(error);
      console.error(`[UpdateCenter] refresh error:`, error);
      queue.setItems([]);
      applyWarning(message);
      return emit();
    }
  };
  return {
    open: refresh,
    refresh,
    async ignore(payload) {
      const entries = await loadIgnored();
      entries.add(createIgnoreKey(payload.packageName, payload.newVersion));
      await saveIgnored(entries);
      await refresh();
    },
    async unignore(payload) {
      const entries = await loadIgnored();
      entries.delete(createIgnoreKey(payload.packageName, payload.newVersion));
      await saveIgnored(entries);
      await refresh();
    },
    async start(tasks) {
      const snapshot = queue.getSnapshot();
      const taskIdByKey = new Map(tasks.map((task) => [task.taskKey, task.id]));
      const selectedItems = snapshot.items.filter(
        (item) => taskIdByKey.has(getTaskKey(item)) && !item.ignored,
      );
      if (selectedItems.length === 0) {
        return;
      }
      // 获取主窗口的 webContents
      const mainWindow = BrowserWindow.getAllWindows()[0];
      const webContents = mainWindow?.webContents;
      if (!webContents) {
        console.error("No main window found");
        return;
      }
      // 获取当前 items
      let currentItems = snapshot.items;
      for (const item of selectedItems) {
        const updateTaskId = taskIdByKey.get(getTaskKey(item));
        if (!updateTaskId) {
          continue;
        }
        // 构建 metalink URL
        const metalinkUrl = item.downloadUrl
          ? `${item.downloadUrl}.metalink`
          : undefined;
        // 发送到主下载队列
        const installTaskData = {
          id: updateTaskId,
          pkgname: item.pkgname,
          metalinkUrl,
          filename: item.fileName,
          upgradeOnly: true,
          origin: item.source === "apm" ? "apm" : "spark",
          retry: false,
        };
        // 通过 IPC 发送到主下载队列
        webContents.send("queue-install", JSON.stringify(installTaskData));
        // 从更新中心的 items 中移除该应用（不再显示在更新列表中）
        currentItems = currentItems.filter(
          (i) => getTaskKey(i) !== getTaskKey(item),
        );
      }
      // 更新队列中的 items
      queue.setItems(currentItems);
      emit();
    },
    async cancel(taskKey) {
      // 取消功能不再需要通过更新中心，直接忽略
      console.log("Cancel not needed for task:", taskKey);
    },
    getState,
    subscribe(listener) {
      listeners.add(listener);
      return () => {
        listeners.delete(listener);
      };
    },
  };
 };
@@ -1,27 +0,0 @@
 export type UpdateSource = "aptss" | "apm";
 export interface InstalledSourceState {
  aptss: boolean;
  apm: boolean;
 }
 export interface UpdateCenterItem {
  pkgname: string;
  name?: string;
  source: UpdateSource;
  currentVersion: string;
  nextVersion: string;
  arch?: string;
  category?: string;
  localIcon?: string;
  remoteIcon?: string;
  ignored?: boolean;
  downloadUrl?: string;
  fileName?: string;
  size?: number;
  sha512?: string;
  isMigration?: boolean;
  migrationSource?: UpdateSource;
  migrationTarget?: UpdateSource;
  aptssVersion?: string;
 }
@@ -1,131 +0,0 @@
 /**
 * Deep link handler for Electron app.
 * Author: juxnpxblo@github
 */
 import { app } from "electron";
 import pino from "pino";
 const logger = pino({ name: "deeplink.ts" });
 type Query = Record<string, string>;
 export type Listener = (query: Query) => void;
 class ListenersMap {
  private map: Map<string, Set<Listener>> = new Map();
  add(action: string, listener: Listener) {
    if (!this.map.has(action)) {
      this.map.set(action, new Set());
    }
    this.map.get(action)!.add(listener);
    return this.map.get(action)!.size;
  }
  remove(action: string, listener: Listener) {
    const listeners = this.map.get(action);
    if (!listeners) return 0;
    listeners.delete(listener);
    if (listeners.size === 0) {
      this.map.delete(action);
      return 0;
    }
    return listeners.size;
  }
  emit(action: string, query: Query) {
    const actionListeners = this.map.get(action);
    if (!actionListeners) return 0;
    actionListeners.forEach((listener) => listener(query));
    return actionListeners.size;
  }
 }
 const protocols = ["spk"];
 const listeners = new ListenersMap();
 export const deepLink = {
  on: (event: string, listener: Listener) => {
    const count = listeners.add(event, listener);
    logger.info(
      `Deep link: listener added for event ${event}. Total event listeners: ${count}`,
    );
  },
  off: (event: string, listener: Listener) => {
    const count = listeners.remove(event, listener);
    logger.info(
      `Deep link: listener removed for event ${event}. Total event listeners: ${count}`,
    );
  },
  once: (event: string, listener: Listener) => {
    const onceListener: Listener = (query) => {
      deepLink.off(event, onceListener);
      listener(query);
    };
    deepLink.on(event, onceListener);
  },
 };
 export function handleCommandLine(commandLine: string[]) {
  const target = commandLine.find((arg) =>
    protocols.some((protocol) => arg.startsWith(protocol + "://")),
  );
  if (!target) return;
  logger.info(`Deep link: protocol link got: ${target}`);
  try {
    const url = new URL(target);
    const action = url.hostname; // 'search'
    logger.info(`Deep link: action found: ${action}`);
    const query: Query = {};
    if (action === "search") {
      // Format: spk://search/pkgname
      // url.pathname will be '/pkgname'
      const pkgname = url.pathname.split("/").filter(Boolean)[0];
      if (pkgname) {
        query.pkgname = pkgname;
        logger.info(`Deep link: search query found: ${JSON.stringify(query)}`);
        listeners.emit(action, query);
      } else {
        logger.warn(
          `Deep link: invalid search format, expected /pkgname, got ${url.pathname}`,
        );
      }
    } else if (action === "store") {
      // Format: spk://store/category/pkgname (legacy format)
      // url.pathname will be '/category/pkgname'
      const pathParts = url.pathname.split("/").filter(Boolean);
      // 老协议格式: spk://store/category/pkgname
      // 现在忽略 category，直接使用 pkgname 查找应用
      const pkgname = pathParts.length >= 2 ? pathParts[1] : pathParts[0];
      if (pkgname) {
        query.pkgname = pkgname;
        logger.info(
          `Deep link: store legacy format query found: ${JSON.stringify(query)}`,
        );
        // 使用 search 事件来处理，前端会根据 pkgname 直接打开应用详情
        listeners.emit("search", query);
      } else {
        logger.warn(
          `Deep link: invalid store format, expected /category/pkgname, got ${url.pathname}`,
        );
      }
    } else {
      logger.warn(`Deep link: unknown action ${action}`);
    }
  } catch (error) {
    logger.error(`Deep link: error parsing URL: ${error}`);
  }
 }
 app.on("second-instance", (_e, commandLine) => {
  handleCommandLine(commandLine);
 });
@@ -1,107 +0,0 @@
 import { BrowserWindow } from "electron";
 import { deepLink } from "./deeplink";
 import { isLoaded } from "../global";
 import pino from "pino";
 const logger = pino({ name: "handle-url-scheme.ts" });
 const pendingActions: Array<() => void> = [];
 new Promise<void>((resolve) => {
  const checkLoaded = () => {
    if (isLoaded.value) {
      resolve();
    } else {
      setTimeout(checkLoaded, 100);
    }
  };
  checkLoaded();
 }).then(() => {
  while (pendingActions.length > 0) {
    const action = pendingActions.shift();
    if (action) action();
  }
 });
 deepLink.on("event", (query) => {
  logger.info(
    `Deep link: event "event" fired with query: ${JSON.stringify(query)}`,
  );
 });
 deepLink.on("action", (query) => {
  logger.info(
    `Deep link: event "action" fired with query: ${JSON.stringify(query)}`,
  );
  const action = () => {
    const win = BrowserWindow.getAllWindows()[0];
    if (!win) return;
    if (query.cmd === "update") {
      win.webContents.send("deep-link-update");
      if (win.isMinimized()) win.restore();
      win.focus();
    } else if (query.cmd === "list") {
      win.webContents.send("deep-link-installed");
      if (win.isMinimized()) win.restore();
      win.focus();
    }
  };
  logger.info(`isLoaded: ${isLoaded.value}`);
  if (isLoaded.value) {
    action();
  } else {
    pendingActions.push(action);
  }
 });
 deepLink.on("install", (query) => {
  logger.info(
    `Deep link: event "install" fired with query: ${JSON.stringify(query)}`,
  );
  const action = () => {
    const win = BrowserWindow.getAllWindows()[0];
    if (!win) return;
    if (query.pkg) {
      win.webContents.send("deep-link-install", query.pkg);
      if (win.isMinimized()) win.restore();
      win.focus();
    }
  };
  if (isLoaded.value) {
    action();
  } else {
    pendingActions.push(action);
  }
 });
 deepLink.on("search", (query) => {
  logger.info(
    `Deep link: event "search" fired with query: ${JSON.stringify(query)}`,
  );
  const action = () => {
    const win = BrowserWindow.getAllWindows()[0];
    if (!win) return;
    if (query.pkgname) {
      win.webContents.send("deep-link-search", { pkgname: query.pkgname });
      if (win.isMinimized()) win.restore();
      win.focus();
    }
  };
  logger.info(`isLoaded: ${isLoaded.value}`);
  if (isLoaded.value) {
    action();
  } else {
    pendingActions.push(action);
  }
 });
@@ -1,447 +0,0 @@
 import {
  app,
  BrowserWindow,
  ipcMain,
  Menu,
  nativeImage,
  shell,
  Tray,
  nativeTheme,
  session,
 } from "electron";
 import { fileURLToPath } from "node:url";
 import path from "node:path";
 import os from "node:os";
 import fs from "node:fs";
 import pino from "pino";
 import { handleCommandLine } from "./deeplink.js";
 import { isLoaded } from "../global.js";
 import { tasks } from "./backend/install-manager.js";
 import { sendTelemetryOnce } from "./backend/telemetry.js";
 import { initializeUpdateCenter } from "./backend/update-center/index.js";
 import {
  getMainWindowCloseAction,
  type MainWindowCloseGuardState,
 } from "./window-close-guard.js";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 process.env.APP_ROOT = path.join(__dirname, "../..");
 /** 与项目 package.json 一致的版本号：打包用 app.getVersion()，未打包时读 package.json */
 function getAppVersion(): string {
  if (app.isPackaged) return app.getVersion();
  const pkgPath = path.join(process.env.APP_ROOT ?? __dirname, "package.json");
  try {
    const raw = fs.readFileSync(pkgPath, "utf8");
    const pkg = JSON.parse(raw) as { version?: string };
    return typeof pkg.version === "string" ? pkg.version : "dev";
  } catch {
    return "dev";
  }
 }
 // 处理 --version 参数（在单实例检查之前）
 if (process.argv.includes("--version") || process.argv.includes("-v")) {
  console.log(getAppVersion());
  process.exit(0);
 }
 // Assure single instance application
 if (!app.requestSingleInstanceLock()) {
  app.exit(0);
 }
 import "./backend/install-manager.js";
 import "./handle-url-scheme.js";
 const logger = pino({ name: "index.ts" });
 // The built directory structure
 //
 // ├─┬ dist-electron
 // │ ├─┬ main
 // │ │ └── index.js    > Electron-Main
 // │ └─┬ preload
 // │   └── index.mjs   > Preload-Scripts
 // ├─┬ dist
 // │ └── index.html    > Electron-Renderer
 //
 export const MAIN_DIST = path.join(process.env.APP_ROOT, "dist-electron");
 export const RENDERER_DIST = path.join(process.env.APP_ROOT, "dist");
 export const VITE_DEV_SERVER_URL = process.env.VITE_DEV_SERVER_URL;
 process.env.VITE_PUBLIC = VITE_DEV_SERVER_URL
  ? path.join(process.env.APP_ROOT, "public")
  : RENDERER_DIST;
 // Disable GPU Acceleration for Windows 7
 if (os.release().startsWith("6.1")) app.disableHardwareAcceleration();
 // Set application name for Windows 10+ notifications
 if (process.platform === "win32") app.setAppUserModelId(app.getName());
 if (!app.requestSingleInstanceLock()) {
  app.quit();
  process.exit(0);
 }
 let win: BrowserWindow | null = null;
 let allowAppExit = false;
 const preload = path.join(__dirname, "../preload/index.mjs");
 const indexHtml = path.join(RENDERER_DIST, "index.html");
 const getUserAgent = (): string => {
  return `Spark-Store/${getAppVersion()}`;
 };
 logger.info("User Agent: " + getUserAgent());
 /** 根据启动参数 --no-apm / --no-spark 决定只展示的来源 */
 function getStoreFilterFromArgv(): "spark" | "apm" | "both" {
  if (process.arch === "loong64") {
    // Currently loong64 only have spark support
    return "spark";
  } else {
    const argv = process.argv;
    const noApm = argv.includes("--no-apm");
    const noSpark = argv.includes("--no-spark");
    if (noApm && noSpark) return "both";
    if (noApm) return "spark";
    if (noSpark) return "apm";
    return "both";
  }
 }
 ipcMain.handle("get-store-filter", (): "spark" | "apm" | "both" =>
  getStoreFilterFromArgv(),
 );
 ipcMain.handle("get-app-version", (): string => getAppVersion());
 const getMainWindowCloseGuardState = (): MainWindowCloseGuardState => ({
  installTaskCount: tasks.size,
  hasRunningUpdateCenterTasks:
    initializeUpdateCenter().getState().hasRunningTasks,
 });
 const applyMainWindowCloseAction = (): void => {
  if (!win) {
    return;
  }
  const action = getMainWindowCloseAction(getMainWindowCloseGuardState());
  if (action === "hide") {
    win.hide();
    win.setSkipTaskbar(true);
    return;
  }
  win.destroy();
 };
 const requestApplicationExit = (): void => {
  if (!win) {
    allowAppExit = true;
    app.quit();
    return;
  }
  if (getMainWindowCloseAction(getMainWindowCloseGuardState()) === "hide") {
    win.hide();
    win.setSkipTaskbar(true);
    return;
  }
  allowAppExit = true;
  app.quit();
 };
 async function createWindow() {
  win = new BrowserWindow({
    title: "星火应用商店",
    width: 1366,
    height: 768,
    autoHideMenuBar: true,
    icon: path.join(process.env.VITE_PUBLIC, "favicon.ico"),
    webPreferences: {
      preload,
      // Warning: Enable nodeIntegration and disable contextIsolation is not secure in production
      // nodeIntegration: true,
      // Consider using contextBridge.exposeInMainWorld
      // Read more on https://www.electronjs.org/docs/latest/tutorial/context-isolation
      // contextIsolation: false,
    },
  });
  if (VITE_DEV_SERVER_URL) {
    // #298
    win.loadURL(VITE_DEV_SERVER_URL);
    // Open devTool if the app is not packaged
    win.webContents.openDevTools({ mode: "detach" });
  } else {
    win.loadFile(indexHtml);
  }
  // Test actively push message to the Electron-Renderer
  win.webContents.on("did-finish-load", () => {
    win?.webContents.send("main-process-message", new Date().toLocaleString());
    logger.info("Renderer process is ready.");
  });
  // Make all links open with the browser, not with the application
  win.webContents.setWindowOpenHandler(({ url }) => {
    if (url.startsWith("https:")) shell.openExternal(url);
    return { action: "deny" };
  });
  // win.webContents.on('will-navigate', (event, url) => { }) #344
  win.on("close", (event) => {
    if (allowAppExit) {
      return;
    }
    // 截获 close 默认行为
    event.preventDefault();
    applyMainWindowCloseAction();
  });
 }
 ipcMain.on("renderer-ready", (event, args) => {
  logger.info(
    "Received renderer-ready event with args: " + JSON.stringify(args),
  );
  isLoaded.value = args.status;
  logger.info(`isLoaded set to: ${isLoaded.value}`);
 });
 ipcMain.on("set-theme-source", (event, theme: "system" | "light" | "dark") => {
  nativeTheme.themeSource = theme;
 });
 // 配置文件路径
 const SPARK_CONFIG_DIR = path.join(
  os.homedir(),
  ".config/spark-union/spark-store",
 );
 const UPDATE_CHECK_CONFIG = "ssshell-config-do-not-show-upgrade-notify";
 const CREATE_DESKTOP_CONFIG = "ssshell-config-do-not-create-desktop";
 // 获取安装设置
 ipcMain.handle("get-install-settings", async () => {
  try {
    const result: Record<string, boolean> = {};
    // 检查更新检测配置
    result[UPDATE_CHECK_CONFIG] = fs.existsSync(
      path.join(SPARK_CONFIG_DIR, UPDATE_CHECK_CONFIG),
    );
    // 检查自动创建桌面启动器配置
    result[CREATE_DESKTOP_CONFIG] = fs.existsSync(
      path.join(SPARK_CONFIG_DIR, CREATE_DESKTOP_CONFIG),
    );
    return { success: true, data: result };
  } catch (err) {
    logger.error({ err }, "Failed to get install settings");
    return { success: false, message: (err as Error)?.message || String(err) };
  }
 });
 // 设置安装设置
 ipcMain.handle(
  "set-install-settings",
  async (
    _event,
    settings: {
      [UPDATE_CHECK_CONFIG]?: boolean;
      [CREATE_DESKTOP_CONFIG]?: boolean;
    },
  ) => {
    try {
      // 确保配置目录存在
      if (!fs.existsSync(SPARK_CONFIG_DIR)) {
        fs.mkdirSync(SPARK_CONFIG_DIR, { recursive: true });
      }
      // 更新检测配置
      const updateCheckPath = path.join(SPARK_CONFIG_DIR, UPDATE_CHECK_CONFIG);
      if (settings[UPDATE_CHECK_CONFIG]) {
        fs.writeFileSync(updateCheckPath, "");
      } else {
        if (fs.existsSync(updateCheckPath)) {
          fs.unlinkSync(updateCheckPath);
        }
      }
      // 自动创建桌面启动器配置
      const createDesktopPath = path.join(
        SPARK_CONFIG_DIR,
        CREATE_DESKTOP_CONFIG,
      );
      if (settings[CREATE_DESKTOP_CONFIG]) {
        fs.writeFileSync(createDesktopPath, "");
      } else {
        if (fs.existsSync(createDesktopPath)) {
          fs.unlinkSync(createDesktopPath);
        }
      }
      return { success: true };
    } catch (err) {
      logger.error({ err }, "Failed to set install settings");
      return {
        success: false,
        message: (err as Error)?.message || String(err),
      };
    }
  },
 );
 // 检查更新
 ipcMain.handle("check-for-updates", async () => {
  try {
    const { spawn } = await import("node:child_process");
    const scriptPath =
      "/opt/durapps/spark-store/bin/update-upgrade/ss-do-upgrade.sh";
    const child = spawn("systemd-run", ["--user", scriptPath], {
      detached: true,
      stdio: "ignore",
    });
    child.unref();
    logger.info(`Launched update check script: ${scriptPath}`);
    return { success: true };
  } catch (err) {
    logger.error({ err }, "Failed to launch update check script");
    return { success: false, message: (err as Error)?.message || String(err) };
  }
 });
 app.whenReady().then(() => {
  // Set User-Agent for client
  session.defaultSession.webRequest.onBeforeSendHeaders((details, callback) => {
    details.requestHeaders["User-Agent"] = getUserAgent();
    callback({ cancel: false, requestHeaders: details.requestHeaders });
  });
  createWindow();
  handleCommandLine(process.argv);
  initializeUpdateCenter();
  // 启动后执行一次遥测（仅 Linux，不阻塞）
  sendTelemetryOnce(getAppVersion());
 });
 app.on("window-all-closed", () => {
  win = null;
  allowAppExit = false;
  if (process.platform !== "darwin") app.quit();
 });
 app.on("second-instance", () => {
  if (win) {
    // Focus on the main window if the user tried to open another
    if (win.isMinimized()) win.restore();
    win.focus();
  }
 });
 app.on("activate", () => {
  const allWindows = BrowserWindow.getAllWindows();
  if (allWindows.length) {
    allWindows[0].focus();
  } else {
    createWindow();
  }
 });
 app.on("will-quit", () => {
  // Clean up temp dir
  logger.info("Cleaning up temp dir");
  fs.rmSync("/tmp/spark-store/", { recursive: true, force: true });
  logger.info("Done, exiting");
 });
 // 设置托盘：系统中应用名称为 spark-store，图标优先 spark-store，其次 spark-store.svg，再次替代图标
 const ICONS_DIR = app.isPackaged
  ? path.join(process.resourcesPath, "icons")
  : path.join(__dirname, "../..", "icons");
 function resolveIconPath(filename: string): string {
  return path.join(ICONS_DIR, filename);
 }
 /** 按优先级返回托盘图标路径：spark-store(.png|.ico) → amber-pm-logo.png。托盘不支持 SVG，故不尝试 spark-store.svg */
 function getTrayIconPath(): string | null {
  const ext = process.platform === "win32" ? ".ico" : ".png";
  const candidates = [`spark-store${ext}`];
  for (const name of candidates) {
    const iconPath = resolveIconPath(name);
    if (fs.existsSync(iconPath)) {
      logger.info("托盘图标使用: " + iconPath);
      return iconPath;
    }
  }
  logger.warn("未找到托盘图标，将使用替代图标。查找目录: " + ICONS_DIR);
  return null;
 }
 /** 16x16 透明 PNG，用作托盘无图标时的替代 */
 const FALLBACK_TRAY_PNG =
  "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAAHklEQVQ4T2NkYGD4z0ABYBwNwMAwGoChNQAAAABJRU5ErkJggg==";
 function getTrayImage():
  | string
  | ReturnType<typeof nativeImage.createFromDataURL> {
  const iconPath = getTrayIconPath();
  if (iconPath) return iconPath;
  return nativeImage.createFromDataURL(FALLBACK_TRAY_PNG);
 }
 let tray: Tray | null = null;
 app.whenReady().then(() => {
  tray = new Tray(getTrayImage());
  const contextMenu = Menu.buildFromTemplate([
    {
      label: "显示主界面",
      click: () => {
        win.show();
      },
    },
    {
      label: "退出程序",
      click: () => {
        requestApplicationExit();
      },
    },
  ]);
  tray.setToolTip("星火应用商店");
  tray.setContextMenu(contextMenu);
  // 双击触发
  tray.on("click", () => {
    // 双击通知区图标实现应用的显示或隐藏
    if (win.isVisible()) {
      win.hide();
      win.setSkipTaskbar(true);
    } else {
      win.show();
      win.setSkipTaskbar(false);
    }
  });
 });
 // New window example arg: new windows url
 // ipcMain.handle('open-win', (_, arg) => {
 //   const childWindow = new BrowserWindow({
 //     webPreferences: {
 //       preload,
 //       nodeIntegration: true,
 //       contextIsolation: false,
 //     },
 //   })
 //   if (VITE_DEV_SERVER_URL) {
 //     childWindow.loadURL(`${VITE_DEV_SERVER_URL}#${arg}`)
 //   } else {
 //     childWindow.loadFile(indexHtml, { hash: arg })
 //   }
 // })
@@ -1,15 +0,0 @@
 export interface MainWindowCloseGuardState {
  installTaskCount: number;
  hasRunningUpdateCenterTasks: boolean;
 }
 export type MainWindowCloseAction = "hide" | "destroy";
 export const shouldPreventMainWindowClose = (
  state: MainWindowCloseGuardState,
 ): boolean => state.installTaskCount > 0 || state.hasRunningUpdateCenterTasks;
 export const getMainWindowCloseAction = (
  state: MainWindowCloseGuardState,
 ): MainWindowCloseAction =>
  shouldPreventMainWindowClose(state) ? "hide" : "destroy";
@@ -1,228 +0,0 @@
 import { ipcRenderer, contextBridge, type IpcRendererEvent } from "electron";
 type StoreFilter = "spark" | "apm" | "both";
 type UpdateCenterSnapshot = {
  items: Array<{
    taskKey: string;
    packageName: string;
    displayName: string;
    currentVersion: string;
    newVersion: string;
    source: "aptss" | "apm";
    localIcon?: string;
    remoteIcon?: string;
    ignored?: boolean;
  }>;
  tasks: Array<{
    taskKey: string;
    packageName: string;
    source: "aptss" | "apm";
    localIcon?: string;
    remoteIcon?: string;
    status:
      | "queued"
      | "downloading"
      | "installing"
      | "completed"
      | "failed"
      | "cancelled";
    progress: number;
    logs: Array<{ time: number; message: string }>;
    errorMessage: string;
  }>;
  warnings: string[];
  hasRunningTasks: boolean;
 };
 type IpcRendererFacade = {
  on: typeof ipcRenderer.on;
  off: typeof ipcRenderer.off;
  send: typeof ipcRenderer.send;
  invoke: typeof ipcRenderer.invoke;
 };
 type UpdateCenterStateListener = (snapshot: UpdateCenterSnapshot) => void;
 type UpdateCenterStartTask = {
  taskKey: string;
  id: number;
 };
 const updateCenterStateListeners = new Map<
  UpdateCenterStateListener,
  (_event: IpcRendererEvent, snapshot: UpdateCenterSnapshot) => void
 >();
 // --------- Expose some API to the Renderer process ---------
 contextBridge.exposeInMainWorld("ipcRenderer", {
  on(...args: Parameters<typeof ipcRenderer.on>) {
    const [channel, listener] = args;
    return ipcRenderer.on(channel, (event, ...args) =>
      listener(event, ...args),
    );
  },
  off(...args: Parameters<typeof ipcRenderer.off>) {
    const [channel, ...omit] = args;
    return ipcRenderer.off(channel, ...omit);
  },
  send(...args: Parameters<typeof ipcRenderer.send>) {
    const [channel, ...omit] = args;
    return ipcRenderer.send(channel, ...omit);
  },
  invoke(...args: Parameters<typeof ipcRenderer.invoke>) {
    const [channel, ...omit] = args;
    return ipcRenderer.invoke(channel, ...omit);
  },
  // You can expose other APTs you need here.
  // ...
 } satisfies IpcRendererFacade);
 contextBridge.exposeInMainWorld("apm_store", {
  arch: (() => {
    const arch = process.arch;
    if (arch === "x64") {
      return "amd64";
    } else if (arch === "arm64") {
      return "arm64";
    } else {
      return arch;
    }
  })(),
 });
 contextBridge.exposeInMainWorld("updateCenter", {
  open: (storeFilter: StoreFilter = "both"): Promise<UpdateCenterSnapshot> =>
    ipcRenderer.invoke("update-center-open", storeFilter),
  refresh: (storeFilter: StoreFilter = "both"): Promise<UpdateCenterSnapshot> =>
    ipcRenderer.invoke("update-center-refresh", storeFilter),
  ignore: (payload: {
    packageName: string;
    newVersion: string;
  }): Promise<void> => ipcRenderer.invoke("update-center-ignore", payload),
  unignore: (payload: {
    packageName: string;
    newVersion: string;
  }): Promise<void> => ipcRenderer.invoke("update-center-unignore", payload),
  start: (tasks: UpdateCenterStartTask[]): Promise<void> =>
    ipcRenderer.invoke("update-center-start", tasks),
  cancel: (taskKey: string): Promise<void> =>
    ipcRenderer.invoke("update-center-cancel", taskKey),
  getState: (): Promise<UpdateCenterSnapshot> =>
    ipcRenderer.invoke("update-center-get-state"),
  onState: (listener: UpdateCenterStateListener): void => {
    const wrapped = (
      _event: IpcRendererEvent,
      snapshot: UpdateCenterSnapshot,
    ) => {
      listener(snapshot);
    };
    updateCenterStateListeners.set(listener, wrapped);
    ipcRenderer.on("update-center-state", wrapped);
  },
  offState: (listener: UpdateCenterStateListener): void => {
    const wrapped = updateCenterStateListeners.get(listener);
    if (!wrapped) {
      return;
    }
    ipcRenderer.off("update-center-state", wrapped);
    updateCenterStateListeners.delete(listener);
  },
 });
 // --------- Preload scripts loading ---------
 function domReady(
  condition: DocumentReadyState[] = ["complete", "interactive"],
 ) {
  return new Promise((resolve) => {
    if (condition.includes(document.readyState)) {
      resolve(true);
    } else {
      document.addEventListener("readystatechange", () => {
        if (condition.includes(document.readyState)) {
          resolve(true);
        }
      });
    }
  });
 }
 const safeDOM = {
  append(parent: HTMLElement, child: HTMLElement) {
    if (!Array.from(parent.children).find((e) => e === child)) {
      return parent.appendChild(child);
    }
  },
  remove(parent: HTMLElement, child: HTMLElement) {
    if (Array.from(parent.children).find((e) => e === child)) {
      return parent.removeChild(child);
    }
  },
 };
 /**
 * https://tobiasahlin.com/spinkit
 * https://connoratherton.com/loaders
 * https://projects.lukehaas.me/css-loaders
 * https://matejkustec.github.io/SpinThatShit
 */
 function useLoading() {
  const className = `loaders-css__square-spin`;
  const styleContent = `
@keyframes square-spin {
  25% { transform: perspective(100px) rotateX(180deg) rotateY(0); }
  50% { transform: perspective(100px) rotateX(180deg) rotateY(180deg); }
  75% { transform: perspective(100px) rotateX(0) rotateY(180deg); }
  100% { transform: perspective(100px) rotateX(0) rotateY(0); }
 }
 .${className} > div {
  animation-fill-mode: both;
  width: 50px;
  height: 50px;
  background: #fff;
  animation: square-spin 3s 0s cubic-bezier(0.09, 0.57, 0.49, 0.9) infinite;
 }
 .app-loading-wrap {
  position: fixed;
  top: 0;
  left: 0;
  width: 100vw;
  height: 100vh;
  display: flex;
  align-items: center;
  justify-content: center;
  background: #282c34;
  z-index: 9;
 }
    `;
  const oStyle = document.createElement("style");
  const oDiv = document.createElement("div");
  oStyle.id = "app-loading-style";
  oStyle.innerHTML = styleContent;
  oDiv.className = "app-loading-wrap";
  oDiv.innerHTML = `<div class="${className}"><div></div></div>`;
  return {
    appendLoading() {
      safeDOM.append(document.head, oStyle);
      safeDOM.append(document.body, oDiv);
    },
    removeLoading() {
      safeDOM.remove(document.head, oStyle);
      safeDOM.remove(document.body, oDiv);
    },
  };
 }
 // ----------------------------------------------------------------------
 const { appendLoading, removeLoading } = useLoading();
 domReady().then(appendLoading);
 window.onmessage = (ev) => {
  if (ev.data.payload === "removeLoading") removeLoading();
 };
 setTimeout(removeLoading, 4999);
@@ -1,13 +0,0 @@
 export interface InstalledAppInfo {
  pkgname: string;
  version: string;
  arch: string;
  flags: string;
  raw: string;
 }
 export type ChannelPayload = {
  success: boolean;
  message: string;
  [k: string]: unknown;
 };
@@ -1,17 +0,0 @@
 import js from "@eslint/js";
 import globals from "globals";
 import tseslint from "typescript-eslint";
 import pluginVue from "eslint-plugin-vue";
 import { defineConfig, globalIgnores } from "eslint/config";
 import eslintConfigPrettier from "eslint-config-prettier/flat";
 import eslintPluginPrettierRecommended from "eslint-plugin-prettier/recommended";
 export default defineConfig([
  globalIgnores(["**/3rdparty/**", "**/node_modules/**", "**/dist/**", "**/dist-electron/**"]),
  { files: ["**/*.{js,mjs,cjs,ts,mts,cts,vue}"], plugins: { js }, extends: ["js/recommended"], languageOptions: { globals: { ...globals.browser, ...globals.node } } },
  tseslint.configs.recommended,
  pluginVue.configs["flat/essential"],
  { files: ["**/*.vue"], languageOptions: { parserOptions: { parser: tseslint.parser } } },
  eslintConfigPrettier,
  eslintPluginPrettierRecommended,
 ]);
@@ -1,102 +0,0 @@
 #!/bin/bash
 # ===== 日志函数（简化版）=====
 log.info()  { echo "INFO: $*"; }
 log.warn()  { echo "WARN: $*"; }
 log.error() { echo "ERROR: $*"; }
 log.debug() { :; }  # APM 场景下可禁用 debug 日志
 # ===== APM 专用桌面文件扫描（单文件）=====
 function scan_apm_desktop_log() {
    unset desktop_file_path
    local pkg_name="$1"
    local desktop_dir="/var/lib/apm/apm/files/ace-env/var/lib/apm/${pkg_name}/entries/applications"
    [ -d "$desktop_dir" ] || return 1
    while IFS= read -r -d '' path; do
        [ -f "$path" ] || continue
        if ! grep -q 'NoDisplay=true' "$path" 2>/dev/null; then
            log.info "Found valid APM desktop file: $path"
            export desktop_file_path="$path"
            return 0
        fi
    done < <(find "$desktop_dir" -name "*.desktop" -type f -print0 2>/dev/null)
    return 1
 }
 # ===== APM 专用桌面文件扫描（多文件列表）=====
 function scan_apm_desktop_list() {
    local pkg_name="$1"
    local desktop_dir="/var/lib/apm/apm/files/ace-env/var/lib/apm/${pkg_name}/entries/applications"
    local result=""
    [ -d "$desktop_dir" ] || { echo ""; return; }
    while IFS= read -r -d '' path; do
        [ -f "$path" ] || continue
        if ! grep -q 'NoDisplay=true' "$path" 2>/dev/null; then
            result+="${path},"
        fi
    done < <(find "$desktop_dir" -name "*.desktop" -type f -print0 2>/dev/null)
    echo "${result%,}"
 }
 # ===== 启动应用 =====
 function launch_app() {
    local desktop_path="${1#file://}"
    local exec_cmd
    # 提取并清理 Exec 行（移除字段代码如 %f %u 等）
    exec_cmd=$(grep -m1 '^Exec=' "$desktop_path" | cut -d= -f2- | sed 's/%[fFuUdDnNickvm]*//g; s/^[[:space:]]*//; s/[[:space:]]*$//')
    [ -z "$exec_cmd" ] && return 1
    log.info "Launching: $exec_cmd"
    ${SHELL:-bash} -c "$exec_cmd" &
 }
 # 导出函数供 ACE 环境调用
 export -f launch_app scan_apm_desktop_log scan_apm_desktop_list log.info log.error
 # ===== 主逻辑 =====
 [ $# -lt 2 ] && {
    log.error "Usage: $0 {check|list|launch|start} <apm-package-name>"
    exit 1
 }
 action="$1"
 pkg_name="$2"
 case "$action" in
    check)
        if scan_apm_desktop_log "$pkg_name"; then
            exit 0
        else
            exit 1
        fi
        ;;
    list)
        if result=$(scan_apm_desktop_list "$pkg_name"); [ -n "$result" ]; then
            echo "$result"
            exit 0
        else
            exit 1
        fi
        ;;
    launch|start)
        if scan_apm_desktop_log "$pkg_name" && launch_app "$desktop_file_path"; then
            exit 0
        else
            exit 1
        fi
        ;;
    *)
        log.error "Invalid command: $action (supported: check|list|launch|start)"
        exit 2
        ;;
 esac
@@ -1,164 +0,0 @@
 #!/bin/bash
 # ===== ACE环境配置 =====
 readonly ACE_ENVIRONMENTS=(
    "bookworm-run:amber-ce-bookworm"
    "trixie-run:amber-ce-trixie"
    "deepin23-run:amber-ce-deepin23"
    "sid-run:amber-ce-sid"
 )
 # ===== 日志和函数 =====
 [ -f /opt/durapps/spark-store/bin/bashimport/log.amber ] && \
    source /opt/durapps/spark-store/bin/bashimport/log.amber || {
    log.info() { echo "INFO: $*"; }
    log.warn() { echo "WARN: $*"; }
    log.error() { echo "ERROR: $*"; }
    log.debug() { echo "DEBUG: $*"; }
 }
 # ===== 功能函数 =====
 function scan_desktop_file_log() {
    unset desktop_file_path
    local package_name=$1
    # 标准desktop文件检测
    while IFS= read -r path; do
        [ -z "$(grep 'NoDisplay=true' "$path")" ] && {
            log.info "Found valid desktop file: $path"
            export desktop_file_path="$path"
            return 0
        }
    done < <(dpkg -L "$package_name" 2>/dev/null | grep -E '/usr/share/applications/.*\.desktop$|/opt/apps/.*/entries/applications/.*\.desktop$')
    # 深度环境特殊处理
    while IFS= read -r path; do
        [ -z "$(grep 'NoDisplay=true' "$path")" ] && {
            log.info "Found deepin desktop file: $path"
            export desktop_file_path="$path"
            return 0
        }
    done < <(find /opt/apps/$package_name -path '*/entries/applications/*.desktop' 2>/dev/null)
    return 1
 }
 function scan_desktop_file() {
    local package_name=$1 result=""
    # 标准结果收集
    while IFS= read -r path; do
        [ -z "$(grep 'NoDisplay=true' "$path")" ] && result+="$path,"
    done < <(dpkg -L "$package_name" 2>/dev/null | grep -E '/usr/share/applications/.*\.desktop$|/opt/apps/.*/entries/applications/.*\.desktop$')
    # 深度环境补充扫描
    while IFS= read -r path; do
        [ -z "$(grep 'NoDisplay=true' "$path")" ] && result+="$path,"
    done < <(find /opt/apps/$package_name -path '*/entries/applications/*.desktop' 2>/dev/null)
    echo "${result%,}"
 }
 function launch_app() {
    local DESKTOP_FILE_PATH="${1#file://}"
    # 提取并净化Exec命令
    exec_command=$(grep -m1 '^Exec=' "$DESKTOP_FILE_PATH" | cut -d= -f2- | sed 's/%.//g')
    [ -z "$exec_command" ] && return 1
    [ ! -z "$IS_ACE_ENV" ] && HOST_PREFIX="systemd-run --user"
    exec_command="${HOST_PREFIX} $exec_command"
    log.info "Launching: $exec_command"
    ${SHELL:-bash} -c " $exec_command"  &
 }
 # 导出函数以便在ACE环境中使用
 export -f launch_app scan_desktop_file scan_desktop_file_log log.info log.warn log.debug log.error
 # ===== ACE环境执行器 =====
 function ace_runner() {
    local action=$1
    local target=$2
    for ace_entry in "${ACE_ENVIRONMENTS[@]}"; do
        local ace_cmd=${ace_entry%%:*}
        local ace_env=${ace_entry#*:}
        if ! command -v "$ace_cmd" >/dev/null; then
            log.debug "$ace_cmd not found, skipping..."
            continue
        fi
        log.info "Attempting in $ace_env environment..."
        case "$action" in
        check)
            if "$ace_cmd" scan_desktop_file_log "$target"; then
                log.info "Found desktop file in $ace_env"
                return 0
            fi
            ;;
        list)
            local result
            if result=$("$ace_cmd"  scan_desktop_file "$target"); then
                echo "$result"
                return 0
            fi
            ;;
        launch|start)
 "$ace_cmd"  scan_desktop_file_log "$target"
            if desktop_path=$("$ace_cmd"  scan_desktop_file_log "$target"); then
                log.info "Launching from $ace_env..."
                "$ace_cmd"  launch_app $("$ace_cmd"  scan_desktop_file "$target")
                return 0
            fi
            ;;
        esac
        log.debug "Attempt in $ace_env failed"
    done
    return 1
 }
 # ===== 主逻辑 =====
 [ $# -lt 2 ] && {
    log.error "Usage: $0 {check|launch|list|start} package_name/desktop_file"
    exit 1
 }
 case $1 in
 check)
    # 当前环境检查
    if scan_desktop_file_log "$2"; then
        exit 0
    else
        # 非ACE环境下执行ACE环境扫描
        [ -z "$IS_ACE_ENV" ] && ace_runner check "$2"
        exit $?
    fi
    ;;
 list)
    # 当前环境列表
    if result=$(scan_desktop_file "$2"); then
        echo "$result"
        exit 0
    else
        # 非ACE环境下执行ACE环境扫描
        [ -z "$IS_ACE_ENV" ] && ace_runner list "$2"
        exit $?
    fi
    ;;
 launch|start)
    # 当前环境启动
    if scan_desktop_file_log "$2" && launch_app "$desktop_file_path"; then
        exit 0
    else
        # 非ACE环境下通过ACE环境启动
        [ -z "$IS_ACE_ENV" ] && ace_runner launch "$2"
        exit $?
    fi
    ;;
 *)
    log.error "Invalid command: $1"
    exit 2
    ;;
 esac
@@ -1,6 +0,0 @@
 #!/bin/bash
 # 检查包是否已安装
 # 返回 0 表示已安装，非 0 表示未安装
 dpkg -s "$1" 2>/dev/null | grep -q 'Status: install ok installed'
 exit $?
@@ -1,187 +0,0 @@
 #!/usr/bin/env bash
 get_script_dir() {
    local source="${BASH_SOURCE[0]}"
    while [ -L "$source" ]; do
        local dir="$(cd -P "$(dirname "$source")" && pwd)"
        source="$(readlink "$source")"
        [[ $source != /* ]] && source="$dir/$source"
    done
    local dir="$(cd -P "$(dirname "$source")" && pwd)"
    echo "$dir"
 }
 find_apm_launcher() {
    local script_dir="$1"
    local paths=(
        "${script_dir}/../extras/shell-helper/apm-launcher"
        "/home/momen/Desktop/apm-app-store/extras/shell-helper/apm-launcher"
        "/opt/apm-store/extras/shell-helper/apm-launcher"
        "/usr/local/bin/apm-launcher"
    )
    for path in "${paths[@]}"; do
        if [[ -f "$path" ]]; then
            echo "$path"
            return 0
        fi
    done
    return 1
 }
 SCRIPT_DIR="$(get_script_dir)"
 APM_LAUNCHER="$(find_apm_launcher "$SCRIPT_DIR")"
 if [[ -z "$APM_LAUNCHER" ]]; then
    echo "Error: apm-launcher not found" >&2
    exit 1
 fi
 SHOW_DESKTOP=false
 function show_help() {
    echo "Usage: $(basename "$0") [OPTIONS] [KEYWORD]"
    echo ""
    echo "List installed APM packages or desktop applications."
    echo ""
    echo "Options:"
    echo "  -d, --desktop       List only desktop applications (with .desktop files)"
    echo "  -h, --help          Show this help message"
    echo ""
    echo "Arguments:"
    echo "  KEYWORD             Filter results by keyword (optional)"
    echo ""
    echo "Examples:"
    echo "  $(basename "$0")                    # List all installed packages"
    echo "  $(basename "$0") firefox            # Search for firefox in packages"
    echo "  $(basename "$0") -d                 # List all desktop applications"
    echo "  $(basename "$0") --desktop firefox  # Search for desktop apps named firefox"
 }
 if [[ "$1" == "-h" || "$1" == "--help" ]]; then
    show_help
    exit 0
 fi
 if [[ "$1" == "-d" || "$1" == "--desktop" ]]; then
    SHOW_DESKTOP=true
    SEARCH_KEYWORD="${2:-}"
 else
    SEARCH_KEYWORD="${1:-}"
 fi
 function get_desktop_name() {
    local desktop_file="$1"
    local name=""
    if [[ -f "$desktop_file" ]]; then
        name=$(grep -m1 '^Name=' "$desktop_file" | cut -d= -f2-)
    fi
    echo "$name"
 }
 if [[ "$SHOW_DESKTOP" == "true" ]]; then
    echo "正在扫描已安装包中的桌面应用..."
    echo ""
    installed_pkgs=$(apm list --installed 2>/dev/null | \
        sed 's/\x1b\[[0-9;]*m//g' | \
        grep -vE "^Listing|^$|^\[INFO\]|^警告" | \
        grep "/" | \
        awk '{split($1,a,"/"); print a[1]}' | \
        sort)
    if [[ -z "$installed_pkgs" ]]; then
        echo "未找到匹配的已安装包"
        exit 0
    fi
    printf "%-35s %-20s %-10s | %s\n" "PKGNAME" "VERSION" "ARCH" "DESCRIPTION"
    printf "%-35s-%-20s-%-10s-+-%s\n" "-----------------------------------" "--------------------" "----------" "---------"
    while IFS= read -r pkgname; do
        [[ -z "$pkgname" ]] && continue
        desktop_files=$("$APM_LAUNCHER" list "$pkgname" 2>/dev/null)
        if [[ -n "$desktop_files" ]]; then
            IFS=',' read -ra files <<< "$desktop_files"
            for df in "${files[@]}"; do
                app_name=$(get_desktop_name "$df")
                if [[ -n "$app_name" ]]; then
                    pkg_info=$(apm show "$pkgname" 2>/dev/null)
                    version=$(echo "$pkg_info" | grep "^Version:" | cut -d: -f2 | xargs)
                    arch=$(echo "$pkg_info" | grep "^Architecture:" | cut -d: -f2 | xargs)
                    description=$(echo "$pkg_info" | grep "^Description:" | cut -d: -f2- | xargs)
                    [[ -z "$arch" ]] && arch="amd64"
                    if [[ -n "$SEARCH_KEYWORD" ]]; then
                        if [[ "$app_name" =~ $SEARCH_KEYWORD ]] || [[ "$pkgname" =~ $SEARCH_KEYWORD ]]; then
                            printf "%-35s %-20s %-10s | %s\n" "$pkgname" "$version" "$arch" "$app_name"
                        fi
                    else
                        printf "%-35s %-20s %-10s | %s\n" "$pkgname" "$version" "$arch" "$app_name"
                    fi
                fi
            done
        fi
    done <<< "$installed_pkgs"
    exit 0
 fi
 if [[ -n "$SEARCH_KEYWORD" ]]; then
    installed_pkgs=$(apm list --installed 2>/dev/null | \
        sed 's/\x1b\[[0-9;]*m//g' | \
        grep -vE "^Listing|^$|^\[INFO\]|^警告" | \
        grep "/" | \
        awk '{split($1,a,"/"); print a[1]}' | \
        grep -i "${SEARCH_KEYWORD}" | \
        sort)
    if [[ -z "$installed_pkgs" ]]; then
        echo "未找到匹配的已安装包"
        exit 0
    fi
    printf "%-35s %-20s %-10s | %s\n" "PKGNAME" "VERSION" "ARCH" "DESCRIPTION"
    printf "%-35s-%-20s-%-10s-+-%s\n" "-----------------------------------" "--------------------" "----------" "---------"
    while IFS= read -r pkgname; do
        [[ -z "$pkgname" ]] && continue
        pkg_info=$(apm show "$pkgname" 2>/dev/null)
        version=$(echo "$pkg_info" | grep "^Version:" | cut -d: -f2 | xargs)
        arch=$(echo "$pkg_info" | grep "^Architecture:" | cut -d: -f2 | xargs)
        description=$(echo "$pkg_info" | grep "^Description:" | cut -d: -f2- | xargs)
        [[ -z "$arch" ]] && arch="amd64"
        printf "%-35s %-20s %-10s | %s\n" "$pkgname" "$version" "$arch" "${description:0:50}"
    done <<< "$installed_pkgs"
    exit 0
 fi
 if [[ "$SHOW_DESKTOP" == "false" && -z "$SEARCH_KEYWORD" ]]; then
    apm list --installed 2>/dev/null | \
        sed 's/\x1b\[[0-9;]*m//g' | \
        grep -vE "^Listing|^$|^\[INFO\]|^警告" | \
        grep "/" | \
        awk '{
            n = split($0, parts, "/")
            pkgname = parts[1]
            if (pkgname == "") next
            version = $2
            sub(/,.*/, "", version)
            arch = $3
            match($0, /\[(.+)\]/, m)
            flags = m[1]
            printf "%-35s %-20s %-8s [%s]\n", pkgname, version, arch, flags
        }' | sort
    exit 0
 fi
@@ -1,173 +0,0 @@
 #!/bin/bash
 # 显示进度条并执行命令（支持 garma / zenity）
 run_with_progress() {
    local title="$1"
    local text="$2"
    local cmd="$3"
    # 检测可用的对话框工具
    local tool=""
    if command -v garma &> /dev/null; then
        tool="garma"
    elif command -v zenity &> /dev/null; then
        tool="zenity"
    else
        echo "警告：未找到 garma 或 zenity，无法显示进度条。直接执行命令..." >&2
        eval "$cmd"
        return $?
    fi
    # 根据工具启动进度条
    local progress_pid
    if [[ "$tool" == "garma" ]]; then
        # garma 的进度条用法（假设 --progress --pulsate 可用）
        garma --progress --pulsate --title="$title" --text="$text" --no-cancel 2>/dev/null &
        progress_pid=$!
    else
        # zenity 进度条 pulsate 模式
        zenity --progress --pulsate --title="$title" --text="$text" --no-cancel 2>/dev/null &
        progress_pid=$!
    fi
    # 执行实际命令
    eval "$cmd"
    local cmd_exit=$?
    # 关闭进度条
    kill "$progress_pid" 2>/dev/null
    wait "$progress_pid" 2>/dev/null
    return $cmd_exit
 }
 # 1. 检查是否提供了至少一个参数
 if [[ $# -eq 0 ]]; then
    echo "错误：未提供命令参数。"
    echo "用法: $0 [apm|aptss|ssinstall] <子命令> [参数...]"
    exit 1
 fi
 # 2. 获取第一个参数作为主指令
 command_type="$1"
 # 3. 根据指令类型分发逻辑
 case "$command_type" in
    "apm")
        # 禁止 apm debug 命令
        if [[ "$2" == "debug" ]]; then
            echo "错误：apm debug 命令已被禁止执行。"
            echo "提示：如需调试，请使用其他方式。"
            exit 1
        fi
        # 禁止 apm ssaudit 命令（已弃用，请使用 apm ssinstall）
        if [[ "$2" == "ssaudit" ]]; then
            echo "错误：apm ssaudit 命令已被弃用，请使用 apm ssinstall。"
            echo "提示：请将 APM 升级到 1.2.2 版本以上以继续使用安装功能。"
            exit 1
        fi
        # 执行 apm 命令（跳过第一个参数）
        /usr/bin/apm "${@:2}" 2>&1
        exit_code=$?
        # 如果 apm ssinstall 执行失败，提示可能是版本过低
        if [[ "$2" == "ssinstall" && "$exit_code" != "0" ]]; then
            echo "提示：apm ssinstall 执行失败，可能是您的 APM 版本过低（需要 1.2.2+）。"
            echo "请升级 APM 到 1.2.2 版本以上来继续安装。"
        fi
        ;;
    "ssinstall")
        # 执行 ssinstall 命令（跳过第一个参数）
        /usr/bin/ssinstall "${@:2}" --native 2>&1
        exit_code=$?
        if [[ "$exit_code" != "0" ]];then
            echo "安装失败，可尝试安装对应的 APM 版本应用；若无对应的 APM 版本应用，可提交用户反馈"
        fi
        ;;
    "aptss")
        # 针对 aptss 的特殊逻辑：如果是 remove 子命令，需要图形化确认
        if [[ "$2" == "remove" ]]; then
            packages="${@:3}"
            # 确认框通用参数
            title="确认卸载"
            text="正在准备卸载: $packages\n\n若这是您下达的卸载指令，请选择确认继续卸载"
            # 优先尝试 garma，其次 zenity
            if command -v garma &> /dev/null; then
                garma --question --title="$title" --text="$text" \
                      --ok-label="确认卸载" --cancel-label="取消" --width=400
                confirmed=$?
            elif command -v zenity &> /dev/null; then
                zenity --question --title="$title" --text="$text" \
                       --ok-label="确认卸载" --cancel-label="取消" --width=400
                confirmed=$?
            else
                echo "错误：未找到 garma 或 zenity，无法显示确认对话框。卸载操作已拒绝。"
                exit 1
            fi
            # 根据确认结果执行
            if [[ $confirmed -eq 0 ]]; then
                /usr/bin/aptss "${@:2}" -y 2>&1
                exit_code=$?
            else
                echo "操作已取消"
                exit 0
            fi
        elif [[ "$2" == "install" ]]; then
            packages="${@:3}"
            # 确认框通用参数
            title="确认安装"
            text="正在准备安装: $packages\n\n若这是您下达的安装指令，请选择确认继续安装"
            # 优先尝试 garma，其次 zenity
            if command -v garma &> /dev/null; then
                garma --question --title="$title" --text="$text" \
                      --ok-label="确认安装" --cancel-label="取消" --width=400
                confirmed=$?
            elif command -v zenity &> /dev/null; then
                zenity --question --title="$title" --text="$text" \
                       --ok-label="确认安装" --cancel-label="取消" --width=400
                confirmed=$?
            else
                echo "错误：未找到 garma 或 zenity，无法显示确认对话框。安装操作已拒绝。"
                exit 1
            fi
            # 根据确认结果执行
            if [[ $confirmed -eq 0 ]]; then
                # 1) 先更新软件源（带进度条）
                echo "正在更新软件源..."
                if ! run_with_progress "更新软件源" "正在更新软件源，请稍候..." "/usr/bin/aptss update"; then
                    echo "错误：软件源更新失败，安装已终止。"
                    exit 1
                fi
                # 2) 执行安装（带进度条）
                echo "正在安装软件包..."
                if ! run_with_progress "安装软件包" "正在安装: $packages，请稍候..." "/usr/bin/aptss install $packages -y"; then
                    echo "错误：软件包安装失败。"
                    exit 1
                fi
                exit_code=0
            else
                echo "操作已取消"
                exit 0
            fi
        else
            # 非 remove/install 命令，拒绝执行
            echo "拒绝执行 aptss 白名单外的指令"
            exit 1
        fi
        ;;
    *)
        # 兜底：拒绝非法指令
        echo "拒绝执行：仅允许执行 'apm', 'aptss' 或 'ssinstall'。收到的参数: '$command_type'"
        exit 1
        ;;
 esac
 exit $exit_code
@@ -1,45 +0,0 @@
 #!/bin/bash
 # 基础参数，始终添加 --no-sandbox
 ARGS="--no-sandbox"
 # 检查是否在容器中运行
 # 方法1: 检查 root 路径
 ROOT_PATH=$(readlink -f /proc/self/root)
 if [ "$ROOT_PATH" != "/" ]; then
    echo "检测到容器环境 (root path: $ROOT_PATH)"
    ARGS="$ARGS --no-apm"
 fi
 # 方法2: 检查 IS_ACE_ENV 环境变量
 if [ "$IS_ACE_ENV" = "1" ]; then
    echo "检测到 ACE 容器环境"
    ARGS="$ARGS --no-apm"
 fi
 # 检查是否存在 apt 指令
 if ! command -v apt >/dev/null 2>&1; then
    echo "未检测到 apt 指令"
    ARGS="$ARGS --no-spark"
 fi
 # 注意：已移除原先针对 arm64 + wayland 添加 --disable-gpu 的逻辑，
 # 现在 arm64 设备无论是否使用 wayland 均不再添加此参数。
 # 执行程序（不使用 exec，以便捕获退出状态）
 /opt/spark-store/bin/spark-store $ARGS "$@"
 exit_code=$?
 # 若程序退出码非0，使用 zenity 弹出友好提示
 if [ $exit_code -ne 0 ]; then
    if command -v zenity >/dev/null 2>&1; then
        zenity --warning --width=600 --text="检测到您可能无法正确打开商店，可手动回退到旧版。\n在终端中执行  sudo aptss install spark-store-legacy -y 即可降级。\n\n对于银河麒麟，您可以尝试 APM 网页版商店 https://amber-pm.spark-app.store/"
    else
        # 降级方案：若 zenity 不可用，至少输出错误信息到终端
        echo "警告: 程序异常退出（退出码 $exit_code），但无法显示图形提示。您可以尝试手动降级：" >&2
        echo "sudo aptss install spark-store-legacy -y" >&2
        echo "或访问 APM 网页版商店: https://amber-pm.spark-app.store/" >&2
    fi
 fi
 exit $exit_code
@@ -1,18 +0,0 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE policyconfig PUBLIC "-//freedesktop//DTD PolicyKit Policy Configuration 1.0//EN"
 "https://specifications.freedesktop.org/PolicyKit/1.0/policyconfig.dtd">
 <policyconfig>
    <vendor>SparkStore</vendor>
    <icon_name>x-package-repository</icon_name>
    <action id="store.spark-app.spark-store">
        <description>运行spark-store管理软件需要权限</description>
        <message>要使用spark-store管理软件需要权限</message>
        <defaults>
            <allow_any>yes</allow_any>
            <allow_inactive>yes</allow_inactive>
            <allow_active>yes</allow_active>
        </defaults>
        <annotate key="org.freedesktop.policykit.exec.path">/opt/spark-store/extras/shell-caller.sh</annotate>
        <annotate key="org.freedesktop.policykit.exec.allow_gui">true</annotate>
    </action>
 </policyconfig>
@@ -1,179 +0,0 @@
 #!/usr/bin/env python3
 """
 图标转换脚本 - 将spark-store.svg转换为标准尺寸的PNG图标
 支持尺寸: 64x64, 128x128, 256x256, 512x512
 """
 import os
 import sys
 from PIL import Image
 import cairosvg
 def convert_svg_to_png(svg_path, output_dir, sizes=[64, 128, 256, 512]):
    """
    将SVG文件转换为多种尺寸的PNG图标
    Args:
        svg_path: SVG文件路径
        output_dir: 输出目录
        sizes: 需要生成的尺寸列表
    """
    # 检查输入文件是否存在
    if not os.path.exists(svg_path):
        print(f"错误: 找不到SVG文件 {svg_path}")
        return False
    # 创建输出目录（如果不存在）
    if not os.path.exists(output_dir):
        os.makedirs(output_dir)
        print(f"创建输出目录: {output_dir}")
    # 获取文件名（不含扩展名）
    base_name = os.path.splitext(os.path.basename(svg_path))[0]
    # 读取SVG文件
    with open(svg_path, 'rb') as svg_file:
        svg_data = svg_file.read()
    # 为每个尺寸生成PNG
    for size in sizes:
        output_filename = f"{base_name}_{size}x{size}.png"
        output_path = os.path.join(output_dir, output_filename)
        try:
            # 使用cairosvg将SVG转换为PNG
            cairosvg.svg2png(
                bytestring=svg_data,
                write_to=output_path,
                output_width=size,
                output_height=size
            )
            print(f"✓ 已生成: {output_filename} ({size}x{size})")
            # 验证生成的PNG文件
            with Image.open(output_path) as img:
                actual_size = img.size
                if actual_size == (size, size):
                    print(f"  - 尺寸验证通过: {actual_size}")
                else:
                    print(f"  - 警告: 实际尺寸为 {actual_size}")
        except Exception as e:
            print(f"✗ 生成 {size}x{size} 时出错: {str(e)}")
            return False
    return True
 def generate_hicolor_icons(svg_path, base_output_dir):
    """
    生成符合hicolor主题标准的图标目录结构
    Args:
        svg_path: SVG文件路径
        base_output_dir: 基础输出目录
    """
    # 定义标准尺寸和对应的子目录
    icon_sizes = {
        64: "64x64/apps",
        128: "128x128/apps",
        256: "256x256/apps",
        512: "512x512/apps"
    }
    # 获取文件名（不含扩展名）
    base_name = os.path.splitext(os.path.basename(svg_path))[0]
    # 为每个尺寸创建目录并生成图标
    for size, subdir in icon_sizes.items():
        output_dir = os.path.join(base_output_dir, subdir)
        if not os.path.exists(output_dir):
            os.makedirs(output_dir)
        output_path = os.path.join(output_dir, f"{base_name}.png")
        try:
            # 读取SVG并转换
            with open(svg_path, 'rb') as svg_file:
                svg_data = svg_file.read()
            cairosvg.svg2png(
                bytestring=svg_data,
                write_to=output_path,
                output_width=size,
                output_height=size
            )
            print(f"✓ 已生成: {output_dir}/{base_name}.png ({size}x{size})")
        except Exception as e:
            print(f"✗ 生成 {size}x{size} 时出错: {str(e)}")
            return False
    return True
 def main():
    """
    主函数
    """
    # 默认配置
    svg_file = "spark-store.svg"
    output_dir = "spark-store-icons"
    hicolor_dir = "hicolor"
    print("=" * 50)
    print("Spark Store 图标转换工具")
    print("=" * 50)
    # 检查是否安装了必要的库
    try:
        import PIL
        import cairosvg
    except ImportError as e:
        print("错误: 缺少必要的Python库")
        print("请安装依赖:")
        print("  pip install Pillow cairosvg")
        return
    # 检查SVG文件
    if not os.path.exists(svg_file):
        print(f"错误: 在当前目录找不到 {svg_file}")
        print(f"请确保 {svg_file} 文件存在于当前目录")
        return
    print(f"\n输入文件: {svg_file}")
    # 生成普通PNG图标
    print("\n[1/2] 生成标准尺寸PNG图标...")
    if convert_svg_to_png(svg_file, output_dir):
        print(f"✓ 所有PNG图标已生成到: {output_dir}/")
    else:
        print("✗ 生成PNG图标失败")
        return
    # 生成hicolor格式图标
    print("\n[2/2] 生成hicolor格式图标...")
    if generate_hicolor_icons(svg_file, hicolor_dir):
        print(f"✓ hicolor图标已生成到: {hicolor_dir}/")
    else:
        print("✗ 生成hicolor图标失败")
        return
    print("\n" + "=" * 50)
    print("✓ 图标转换完成！")
    print("=" * 50)
    print("\n生成的文件：")
    print(f"1. 普通PNG图标: {output_dir}/")
    print(f"   - spark-store_64x64.png")
    print(f"   - spark-store_128x128.png")
    print(f"   - spark-store_256x256.png")
    print(f"   - spark-store_512x512.png")
    print(f"\n2. hicolor格式图标: {hicolor_dir}/")
    print(f"   - {hicolor_dir}/64x64/apps/spark-store.png")
    print(f"   - {hicolor_dir}/128x128/apps/spark-store.png")
    print(f"   - {hicolor_dir}/256x256/apps/spark-store.png")
    print(f"   - {hicolor_dir}/512x512/apps/spark-store.png")
 if __name__ == "__main__":
    main()
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
shenmo7192	c0213cbf1d	跟随update	2020-06-24 15:48:32 +08:00
shenmo7192	05cf008ef9	修改终端为默认终端	2020-06-24 09:07:16 +08:00
shenmo7192	a3ba3bab04	跟上maicss的提交	2020-06-23 19:27:10 +08:00
沫	221ec4e926	跟上maicss	2020-06-23 15:47:35 +08:00
“shenmo”	1bbf51981f	跟紧maicss	2020-06-23 01:09:50 +08:00
shenmo7192	55652d9b9e	地址写错了，修改下	2020-06-22 13:48:11 +08:00
shenmo7192	761a73529e	地址写错了，修改下	2020-06-22 13:47:52 +08:00
shenmo7192	82bec38977	再次更新进度	2020-06-22 13:35:27 +08:00
“shenmo”	6799573bbf	更新了url.h，已经追赶上maicss上游	2020-06-21 23:30:07 +08:00
“shenmo”	dc5b4312ac	“跟紧上游”	2020-06-21 23:22:55 +08:00
shenmo7192	820d3243c2	去除了https避免证书验证问题	2020-06-21 22:43:27 +08:00
shenmo7192	0ca8cd7a35	修改了地址	2020-06-21 22:34:19 +08:00
Maicss	d45fc66867	20200621投递	2020-06-21 08:58:48 +08:00
Maicss	e1767420ef	修改了传递介质为json	2020-06-18 19:04:16 +08:00
Maicss	994dd35a97	细微修改	2020-06-17 17:00:17 +08:00
Maicss	873c52e602	提交	2020-06-17 16:52:52 +08:00
Maicss	7706414ff9	删除文件 README.en.md	2020-06-17 16:49:35 +08:00
Maicss	92fbdb1fb4	Initial commit	2020-06-17 16:49:25 +08:00
		`@@ -1,2 +0,0 @@`
			`VITE_APM_STORE_BASE_URL=https://erotica.spark-app.store`
			`VITE_APM_STORE_STATS_BASE_URL=https://feedback.spark-app.store`
		`@@ -1,2 +0,0 @@`
			`import { ref } from "vue";`
			`export const isLoaded = ref(false);`