chore(deps): bump koffi from 2.15.2 to 2.15.4

Bumps [koffi](https://github.com/Koromix/koffi) from 2.15.2 to 2.15.4.
- [Commits](https://github.com/Koromix/koffi/commits)

---
updated-dependencies:
- dependency-name: koffi
  dependency-version: 2.15.4
  dependency-type: direct:production
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>

.github/ISSUE_TEMPLATE/bug.yml

@@ -0,0 +1,114 @@
+name: "报告 Bug"
+description: "代码出现了非预期的问题、崩溃或报错"
+title: "[Bug]: "
+labels: ["type: bug", "status: needs info"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        请提供尽可能详细的信息，帮助我们快速定位和修复问题。
+  - type: checkboxes
+    id: pre-check
+    attributes:
+      label: 提交前确认
+      description: 请务必确认以下事项
+      options:
+        - label: 我已搜索过现有的 Issues，确认这不是重复问题
+          required: true
+        - label: 我使用的是最新版本
+          required: true
+        - label: 我已阅读过相关文档
+          required: true
+  - type: dropdown
+    id: platform
+    attributes:
+      label: 使用平台
+      description: 选择出现问题的平台
+      options:
+        - Windows
+        - macOS
+        - Linux
+    validations:
+      required: true
+  - type: dropdown
+    id: severity
+    attributes:
+      label: 问题严重程度
+      description: 这个问题对你的使用造成了多大影响？
+      options:
+        - 严重崩溃或数据丢失（无法使用）
+        - 核心功能受影响（在下一个常规发布中必须修复）
+        - 边缘场景或轻微问题（等待空闲时修复）
+    validations:
+      required: true
+  - type: textarea
+    id: description
+    attributes:
+      label: 问题描述
+      description: 清晰描述你遇到的问题，包括实际发生了什么
+      placeholder: 例如：当我点击发送按钮时，应用程序崩溃并显示白屏
+    validations:
+      required: true
+  - type: textarea
+    id: reproduction
+    attributes:
+      label: 复现步骤
+      description: 提供详细的操作步骤，让我们能够重现这个问题
+      placeholder: |
+        1. 打开应用并登录账号
+        2. 进入聊天页面
+        3. 点击发送按钮
+        4. 观察到应用崩溃
+    validations:
+      required: true
+  - type: textarea
+    id: expected-behavior
+    attributes:
+      label: 预期行为
+      description: 描述你期望的正确行为应该是什么样的
+      placeholder: 例如：点击发送按钮后，消息应该正常发送并显示在聊天窗口中
+    validations:
+      required: true
+  - type: textarea
+    id: actual-behavior
+    attributes:
+      label: 实际行为
+      description: 描述实际发生的错误行为
+      placeholder: 例如：点击后应用直接崩溃，显示白屏
+    validations:
+      required: true
+  - type: textarea
+    id: logs
+    attributes:
+      label: 错误日志或截图
+      description: 粘贴控制台错误信息、崩溃日志，或拖入截图
+      placeholder: 请粘贴完整的错误堆栈信息
+      render: shell
+  - type: input
+    id: os
+    attributes:
+      label: 操作系统版本
+      description: 例如：Windows 11 24H2、macOS 15.0、Ubuntu 24.04
+      placeholder: Windows 11 24H2
+    validations:
+      required: true
+  - type: input
+    id: app-version
+    attributes:
+      label: 应用版本
+      description: 在关于页面或设置中查看版本号
+      placeholder: v1.2.3
+    validations:
+      required: true
+  - type: input
+    id: architecture
+    attributes:
+      label: 系统架构
+      description: 例如：x64、arm64
+      placeholder: x64
+  - type: textarea
+    id: additional-context
+    attributes:
+      label: 补充信息
+      description: 其他可能有助于定位问题的信息
+      placeholder: 例如：这个问题是在某次更新后开始出现的，或者只在特定网络环境下出现

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name:🤔 找不到合适的模板？
+    url: https://t.me/weflow_cc
+    about: 如果你的问题不属于上述任何分类，请前往我们的 Telegram 频道与我们交流。

.github/ISSUE_TEMPLATE/docs.yml

@@ -0,0 +1,67 @@
+name: "文档反馈"
+description: "文档存在错别字、描述不清晰或缺少必要的示例"
+title: "[Docs]: "
+labels: ["type: docs"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        优秀的文档和代码一样重要。感谢你帮助我们完善文档！
+  - type: dropdown
+    id: doc-type
+    attributes:
+      label: 文档类型
+      description: 问题出现在哪类文档中？
+      options:
+        - README 或项目说明
+        - 安装部署文档
+        - 使用教程
+        - API 文档
+        - 开发者文档
+        - 其他
+    validations:
+      required: true
+  - type: input
+    id: doc-link
+    attributes:
+      label: 文档位置
+      description: 提供文档的 URL 或文件路径
+      placeholder: 例如：docs/installation.md 或 https://github.com/xxx/xxx/wiki/xxx
+    validations:
+      required: true
+  - type: dropdown
+    id: issue-type
+    attributes:
+      label: 问题类型
+      description: 文档存在什么问题？
+      options:
+        - 错别字或语法错误
+        - 内容过时或不准确
+        - 描述不清晰或有歧义
+        - 缺少必要的示例代码
+        - 缺少重要的说明或警告
+        - 链接失效或错误
+        - 其他
+    validations:
+      required: true
+  - type: textarea
+    id: issue-desc
+    attributes:
+      label: 问题描述
+      description: 详细说明文档中存在的问题
+      placeholder: 例如：第 3 步中的命令拼写错误，应该是 "npm install" 而不是 "npm instal"
+    validations:
+      required: true
+  - type: textarea
+    id: suggestion
+    attributes:
+      label: 修改建议
+      description: 你认为应该如何修改？
+      placeholder: 例如：建议将"安装依赖"部分补充完整的命令示例，并说明不同操作系统的差异
+    validations:
+      required: true
+  - type: textarea
+    id: additional
+    attributes:
+      label: 补充说明
+      description: 其他需要补充的信息

.github/ISSUE_TEMPLATE/enhancement.yml

@@ -0,0 +1,78 @@
+name: "功能与体验优化"
+description: "对现有的功能逻辑进行优化，或改进用户体验"
+title: "[Enhancement]: "
+labels: ["type: enhancement"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        持续优化是项目进步的动力！请告诉我们哪个现有功能可以做得更好。
+  - type: checkboxes
+    id: pre-check
+    attributes:
+      label: 提交前确认
+      options:
+        - label: 我已搜索过现有的 Issues，确认这个优化建议尚未被提出
+          required: true
+        - label: 这是对现有功能的改进，而不是全新功能
+          required: true
+  - type: dropdown
+    id: category
+    attributes:
+      label: 优化类别
+      description: 这个优化主要属于哪个方面？
+      options:
+        - 性能优化（速度、内存、资源占用）
+        - 交互体验（操作流程、界面布局）
+        - 视觉设计（样式、动画、美观度）
+        - 易用性（降低使用门槛、减少操作步骤）
+        - 稳定性（减少崩溃、提高可靠性）
+        - 其他
+    validations:
+      required: true
+  - type: textarea
+    id: target
+    attributes:
+      label: 目标功能或模块
+      description: 你希望优化的具体功能或页面是哪个？
+      placeholder: 例如：聊天页面的消息加载、设置页面的布局、文件上传功能
+    validations:
+      required: true
+  - type: textarea
+    id: current-behavior
+    attributes:
+      label: 当前表现
+      description: 描述当前功能的不足之处或存在的问题
+      placeholder: 例如：消息列表滚动时会出现明显卡顿，加载 100 条消息需要 3 秒
+    validations:
+      required: true
+  - type: textarea
+    id: improvement
+    attributes:
+      label: 优化建议
+      description: 详细说明你的优化方案和预期效果
+      placeholder: 例如：建议使用虚拟滚动技术，只渲染可见区域的消息，预计可将加载时间缩短到 0.5 秒以内
+    validations:
+      required: true
+  - type: textarea
+    id: benefits
+    attributes:
+      label: 优化收益
+      description: 这个优化会带来什么具体好处？
+      placeholder: 例如：提升 80% 的加载速度、减少 50% 的内存占用、降低用户操作步骤从 5 步到 2 步
+    validations:
+      required: true
+  - type: textarea
+    id: impact
+    attributes:
+      label: 影响范围
+      description: 这个优化会影响哪些用户或场景？
+      placeholder: 例如：所有用户在查看历史消息时都会受益，尤其是群聊消息较多的场景
+  - type: checkboxes
+    id: contribution
+    attributes:
+      label: 参与贡献
+      options:
+        - label: 我愿意提交 Pull Request 来实现这个优化
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/feature.yml

@@ -0,0 +1,71 @@
+name: "全新功能请求"
+description: "提议一个目前项目中完全没有的新特性"
+title: "[Feature]: "
+labels: ["type: feature"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        感谢你为项目提供新想法！详细的需求描述能极大提高该功能被采纳的几率。
+  - type: checkboxes
+    id: pre-check
+    attributes:
+      label: 提交前确认
+      options:
+        - label: 我已搜索过现有的 Issues 和 Pull Requests，确认这个功能尚未被提出或实现
+          required: true
+        - label: 这是一个全新的功能，而不是对现有功能的改进
+          required: true
+  - type: dropdown
+    id: priority
+    attributes:
+      label: 功能优先级
+      description: 你认为这个功能有多重要？
+      options:
+        - 高优先级（核心功能缺失，严重影响使用体验）
+        - 中优先级（有助于提升使用体验）
+        - 低优先级（锦上添花的功能）
+    validations:
+      required: true
+  - type: textarea
+    id: problem
+    attributes:
+      label: 问题或痛点
+      description: 【为什么需要】你现在做某件事遇到了什么困难？缺少什么能力？
+      placeholder: 例如：目前无法批量导出聊天记录，每次只能手动复制单条消息，处理 100 条消息需要半小时
+    validations:
+      required: true
+  - type: textarea
+    id: solution
+    attributes:
+      label: 期望的解决方案
+      description: 【怎么实现】详细描述功能的操作流程、界面位置、可选参数等
+      placeholder: 例如：在聊天窗口右键菜单添加"导出记录"，点击后弹窗可选时间范围、导出格式（TXT/JSON）、筛选用户，最后保存到本地
+    validations:
+      required: true
+  - type: textarea
+    id: use-case
+    attributes:
+      label: 使用场景
+      description: 【什么时候用】你会在哪些具体情况下使用这个功能？
+      placeholder: 例如：每周五整理工作讨论记录；保存客户沟通记录作为合同依据；备份重要群聊内容
+    validations:
+      required: true
+  - type: textarea
+    id: alternatives
+    attributes:
+      label: 替代方案
+      description: 你目前使用什么临时方案？或者有没有考虑过其他实现方式？
+      placeholder: 例如：目前只能手动截图或逐条复制粘贴
+  - type: textarea
+    id: reference
+    attributes:
+      label: 参考示例
+      description: 其他应用中是否有类似功能可以参考？
+      placeholder: 例如：微信的聊天记录导出功能、Telegram 的导出数据功能
+  - type: checkboxes
+    id: contribution
+    attributes:
+      label: 参与贡献
+      options:
+        - label: 我愿意提交 Pull Request 来实现这个功能

.github/ISSUE_TEMPLATE/question.yml

@@ -0,0 +1,71 @@
+name: "使用答疑"
+description: "关于如何配置、如何使用项目的求助"
+title: "[Question]: "
+labels: ["type: question"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        在提问之前，请确保你已经仔细阅读过我们的官方文档。
+  - type: checkboxes
+    id: pre-check
+    attributes:
+      label: 提交前确认
+      options:
+        - label: 我已阅读过相关文档
+          required: true
+        - label: 我已搜索过现有的 Issues，没有找到类似问题
+          required: true
+  - type: dropdown
+    id: question-type
+    attributes:
+      label: 问题类型
+      description: 你的问题属于哪个方面？
+      options:
+        - 安装部署问题
+        - 配置相关问题
+        - 功能使用问题
+        - API 调用问题
+        - 错误排查问题
+        - 其他
+    validations:
+      required: true
+  - type: textarea
+    id: question
+    attributes:
+      label: 问题描述
+      description: 清晰描述你遇到的问题或疑问
+      placeholder: 例如：我在 Windows 系统上安装后无法启动应用，双击图标没有任何反应
+    validations:
+      required: true
+  - type: textarea
+    id: attempts
+    attributes:
+      label: 已尝试的方法
+      description: 你已经尝试过哪些解决方法？
+      placeholder: 例如：我尝试过重新安装、以管理员身份运行、关闭防火墙，但问题依然存在
+    validations:
+      required: true
+  - type: textarea
+    id: environment
+    attributes:
+      label: 运行环境
+      description: 提供你的系统环境信息
+      placeholder: |
+        操作系统：Windows 11
+        应用版本：v1.2.3
+        系统架构：x64
+    validations:
+      required: true
+  - type: textarea
+    id: code-snippet
+    attributes:
+      label: 相关配置或代码
+      description: 如果涉及配置或代码问题，请粘贴相关内容
+      placeholder: 粘贴你的配置文件或代码片段
+      render: javascript
+  - type: textarea
+    id: screenshots
+    attributes:
+      label: 截图或日志
+      description: 如有必要，请提供截图或错误日志

.github/dependabot.yml

@@ -0,0 +1,7 @@
+version: 2
+updates:
+  - package-ecosystem: "npm"
+    directory: "/"                
+    schedule:
+      interval: "daily"           
+    target-branch: "dev"          

.github/workflows/anti-spam.yml

@@ -0,0 +1,134 @@
+name: Anti-Spam
+
+on:
+  issues:
+    types: [opened, edited]
+
+permissions:
+  issues: write
+
+jobs:
+  check-spam:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check for spam
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const issue = context.payload.issue;
+            const title = (issue.title || '').toLowerCase();
+            const body = (issue.body || '').toLowerCase();
+            const text = title + ' ' + body;
+
+            // 博彩/赌球类
+            const gamblingPatterns = [
+              /世界杯.*买球/, /买球.*世界杯/,
+              /世界杯.*下注/, /世界杯.*竞猜/,
+              /世界杯.*投注/, /世界杯.*押注/,
+              /世界杯.*彩票/, /世界杯.*平台/,
+              /世界杯.*app/, /世界杯.*软件/,
+              /世界杯.*网站/, /世界杯.*网址/,
+              /足球.*买球/, /买球.*足球/,
+              /足球.*投注/, /足球.*押注/,
+              /足球.*竞猜/, /足球.*平台/,
+              /篮球.*买球/, /篮球.*投注/,
+              /体育.*投注/, /体育.*竞猜/,
+              /体育.*买球/, /体育.*押注/,
+              /赌球/, /赌博.*网站/, /赌博.*平台/,
+              /博彩/, /博彩.*网站/, /博彩.*平台/,
+              /正规.*买球/, /官方.*买球/,
+              /买球.*网站/, /买球.*app/,
+              /买球.*软件/, /买球.*网址/,
+              /买球.*平台/, /买球.*技巧/,
+              /投注.*网站/, /投注.*平台/,
+              /押注.*网站/, /押注.*平台/,
+              /竞猜.*网站/, /竞猜.*平台/,
+              /彩票.*网站/, /彩票.*平台/,
+              /欧洲杯.*买球/, /欧冠.*买球/,
+              /nba.*买球/, /nba.*投注/,
+            ];
+
+            // 色情/交友类
+            const adultPatterns = [
+              /约炮/, /一夜情/, /外围/,
+              /包养/, /援交/, /陪聊/,
+              /成人.*网站/, /成人.*视频/,
+              /av.*网站/, /黄色.*网站/,
+            ];
+
+            // 贷款/金融诈骗类
+            const financePatterns = [
+              /秒到账.*贷款/, /无抵押.*贷款/,
+              /征信.*贷款/, /黑户.*贷款/,
+              /快速.*放款/, /私人.*放贷/,
+              /刷单/, /兼职.*日入/, /兼职.*月入/,
+              /网赚/, /躺赚/, /被动收入.*平台/,
+              /虚拟货币.*投资/, /usdt.*投资/,
+              /炒币.*平台/, /数字货币.*平台/,
+            ];
+
+            // 垃圾推广类
+            const spamPromoPatterns = [
+              /代刷/, /粉丝.*购买/, /涨粉/,
+              /seo.*优化/, /快速排名/,
+              /微商/, /代理.*招募/,
+            ];
+
+            // 账号特征检测（新账号 + 无 contribution）
+            const allPatterns = [
+              ...gamblingPatterns,
+              ...adultPatterns,
+              ...financePatterns,
+              ...spamPromoPatterns,
+            ];
+
+            const isSpam = allPatterns.some(pattern => pattern.test(text));
+
+            // 额外检测：标题超短且含可疑关键词（常见于批量刷单）
+            const suspiciousShort = title.length < 10 && /(买球|投注|博彩|赌博|下注|押注)/.test(title);
+
+            if (isSpam || suspiciousShort) {
+              // 确保 spam label 存在
+              try {
+                await github.rest.issues.createLabel({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  name: 'spam',
+                  color: 'e4e669',
+                  description: 'Spam issue'
+                });
+              } catch (e) {
+                // label 已存在，忽略
+              }
+
+              await github.rest.issues.createComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: issue.number,
+                body: '此 issue 已被自动识别为垃圾内容并关闭。\n\nThis issue has been automatically identified as spam and closed.'
+              });
+
+              await github.rest.issues.addLabels({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: issue.number,
+                labels: ['spam']
+              });
+
+              await github.rest.issues.update({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: issue.number,
+                state: 'closed',
+                state_reason: 'not_planned'
+              });
+
+              await github.rest.issues.lock({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: issue.number,
+                lock_reason: 'spam'
+              });
+
+              console.log(`Closed spam issue #${issue.number}: ${issue.title}`);
+            }

.github/workflows/dev-daily-fixed.yml

@@ -0,0 +1,327 @@
+name: Dev Daily
+
+on:
+  schedule:
+    # GitHub Actions schedule uses UTC. 16:00 UTC = 北京时间次日 00:00
+    - cron: "0 16 * * *"
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+env:
+  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
+  FIXED_DEV_TAG: nightly-dev
+  TARGET_BRANCH: dev
+  ELECTRON_BUILDER_BINARIES_MIRROR: https://github.com/electron-userland/electron-builder-binaries/releases/download/
+
+jobs:
+  prepare:
+    runs-on: ubuntu-latest
+    outputs:
+      dev_version: ${{ steps.meta.outputs.dev_version }}
+    steps:
+      - name: Check out git repository
+        uses: actions/checkout@v5
+        with:
+          ref: ${{ env.TARGET_BRANCH }}
+          fetch-depth: 0
+
+      - name: Install Node.js
+        uses: actions/setup-node@v5
+        with:
+          node-version: 24
+          cache: "npm"
+
+      - name: Generate daily dev version
+        id: meta
+        shell: bash
+        run: |
+          set -euo pipefail
+          YEAR_2="$(TZ=Asia/Shanghai date +%y)"
+          MONTH="$(TZ=Asia/Shanghai date +%-m)"
+          DAY="$(TZ=Asia/Shanghai date +%-d)"
+          DEV_VERSION="${YEAR_2}.${MONTH}.${DAY}"
+          echo "dev_version=$DEV_VERSION" >> "$GITHUB_OUTPUT"
+          echo "Dev version: $DEV_VERSION"
+
+      - name: Ensure fixed prerelease exists
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: bash
+        run: |
+          set -euo pipefail
+          if gh release view "$FIXED_DEV_TAG" --repo "$GITHUB_REPOSITORY" >/dev/null 2>&1; then
+            gh release edit "$FIXED_DEV_TAG" --repo "$GITHUB_REPOSITORY" --title "Daily Dev Build" --prerelease
+          else
+            gh release create "$FIXED_DEV_TAG" --repo "$GITHUB_REPOSITORY" --title "Daily Dev Build" --notes "开发版发布页" --prerelease
+          fi
+
+  dev-mac-arm64:
+    needs: prepare
+    runs-on: macos-14
+    steps:
+      - name: Check out git repository
+        uses: actions/checkout@v5
+        with:
+          ref: ${{ env.TARGET_BRANCH }}
+          fetch-depth: 0
+
+      - name: Install Node.js
+        uses: actions/setup-node@v5
+        with:
+          node-version: 24
+          cache: "npm"
+
+      - name: Install Dependencies
+        run: npm install
+
+      - name: Set dev version
+        shell: bash
+        run: npm version "${{ needs.prepare.outputs.dev_version }}" --no-git-tag-version --allow-same-version
+
+      - name: Build Frontend & Type Check
+        run: |
+          npx tsc
+          npx vite build
+
+      - name: Package macOS arm64 dev artifacts
+        shell: bash
+        run: |
+          export ELECTRON_BUILDER_BINARIES_MIRROR="https://github.com/electron-userland/electron-builder-binaries/releases/download/"
+          echo "Using ELECTRON_BUILDER_BINARIES_MIRROR=$ELECTRON_BUILDER_BINARIES_MIRROR"
+          npx electron-builder --mac dmg --arm64 --publish never '--config.publish.channel=dev' '--config.artifactName=${productName}-dev-arm64.${ext}'
+
+      - name: Upload macOS arm64 assets to fixed release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: bash
+        run: |
+          assets=()
+          while IFS= read -r file; do
+            assets+=("$file")
+          done < <(find release -maxdepth 1 -type f | sort)
+          if [ "${#assets[@]}" -eq 0 ]; then
+            echo "No release files found in ./release"
+            exit 1
+          fi
+          gh release upload "$FIXED_DEV_TAG" "${assets[@]}" --repo "$GITHUB_REPOSITORY" --clobber
+
+  dev-linux:
+    needs: prepare
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out git repository
+        uses: actions/checkout@v5
+        with:
+          ref: ${{ env.TARGET_BRANCH }}
+          fetch-depth: 0
+
+      - name: Install Node.js
+        uses: actions/setup-node@v5
+        with:
+          node-version: 24
+          cache: "npm"
+
+      - name: Install Dependencies
+        run: npm install
+
+      - name: Set dev version
+        shell: bash
+        run: npm version "${{ needs.prepare.outputs.dev_version }}" --no-git-tag-version --allow-same-version
+
+      - name: Build Frontend & Type Check
+        run: |
+          npx tsc
+          npx vite build
+
+      - name: Package Linux dev artifacts
+        run: |
+          npx electron-builder --linux --publish never '--config.publish.channel=dev' '--config.artifactName=${productName}-dev-linux.${ext}'
+
+      - name: Upload Linux assets to fixed release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: bash
+        run: |
+          assets=()
+          while IFS= read -r file; do
+            assets+=("$file")
+          done < <(find release -maxdepth 1 -type f | sort)
+          if [ "${#assets[@]}" -eq 0 ]; then
+            echo "No release files found in ./release"
+            exit 1
+          fi
+          gh release upload "$FIXED_DEV_TAG" "${assets[@]}" --repo "$GITHUB_REPOSITORY" --clobber
+
+  dev-win-x64:
+    needs: prepare
+    runs-on: windows-latest
+    steps:
+      - name: Check out git repository
+        uses: actions/checkout@v5
+        with:
+          ref: ${{ env.TARGET_BRANCH }}
+          fetch-depth: 0
+
+      - name: Install Node.js
+        uses: actions/setup-node@v5
+        with:
+          node-version: 24
+          cache: "npm"
+
+      - name: Install Dependencies
+        run: npm install
+
+      - name: Set dev version
+        shell: bash
+        run: npm version "${{ needs.prepare.outputs.dev_version }}" --no-git-tag-version --allow-same-version
+
+      - name: Build Frontend & Type Check
+        run: |
+          npx tsc
+          npx vite build
+
+      - name: Package Windows x64 dev artifacts
+        run: |
+          npx electron-builder --win nsis --x64 --publish never '--config.publish.channel=dev' '--config.artifactName=${productName}-dev-x64-Setup.${ext}'
+
+      - name: Upload Windows x64 assets to fixed release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: bash
+        run: |
+          assets=()
+          while IFS= read -r file; do
+            assets+=("$file")
+          done < <(find release -maxdepth 1 -type f | sort)
+          if [ "${#assets[@]}" -eq 0 ]; then
+            echo "No release files found in ./release"
+            exit 1
+          fi
+          gh release upload "$FIXED_DEV_TAG" "${assets[@]}" --repo "$GITHUB_REPOSITORY" --clobber
+
+  dev-win-arm64:
+    needs: prepare
+    runs-on: windows-latest
+    steps:
+      - name: Check out git repository
+        uses: actions/checkout@v5
+        with:
+          ref: ${{ env.TARGET_BRANCH }}
+          fetch-depth: 0
+
+      - name: Install Node.js
+        uses: actions/setup-node@v5
+        with:
+          node-version: 24
+          cache: "npm"
+
+      - name: Install Dependencies
+        run: npm install
+
+      - name: Set dev version
+        shell: bash
+        run: npm version "${{ needs.prepare.outputs.dev_version }}" --no-git-tag-version --allow-same-version
+
+      - name: Build Frontend & Type Check
+        run: |
+          npx tsc
+          npx vite build
+
+      - name: Package Windows arm64 dev artifacts
+        run: |
+          npx electron-builder --win nsis --arm64 --publish never '--config.publish.channel=dev-arm64' '--config.artifactName=${productName}-dev-arm64-Setup.${ext}'
+
+      - name: Upload Windows arm64 assets to fixed release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: bash
+        run: |
+          assets=()
+          while IFS= read -r file; do
+            assets+=("$file")
+          done < <(find release -maxdepth 1 -type f | sort)
+          if [ "${#assets[@]}" -eq 0 ]; then
+            echo "No release files found in ./release"
+            exit 1
+          fi
+          gh release upload "$FIXED_DEV_TAG" "${assets[@]}" --repo "$GITHUB_REPOSITORY" --clobber
+
+  update-dev-release-notes:
+    needs:
+      - prepare
+      - dev-mac-arm64
+      - dev-linux
+      - dev-win-x64
+      - dev-win-arm64
+    if: always() && needs.prepare.result == 'success'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Update fixed dev release notes
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          FIXED_DEV_TAG: ${{ env.FIXED_DEV_TAG }}
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          TAG="$FIXED_DEV_TAG"
+          REPO="$GITHUB_REPOSITORY"
+          RELEASE_PAGE="https://github.com/$REPO/releases/tag/$TAG"
+
+          if ! gh release view "$TAG" --repo "$REPO" >/dev/null 2>&1; then
+            echo "Release $TAG not found, skip notes update."
+            exit 0
+          fi
+
+          ASSETS_JSON="$(gh release view "$TAG" --repo "$REPO" --json assets)"
+
+          pick_asset() {
+            local pattern="$1"
+            echo "$ASSETS_JSON" | jq -r --arg p "$pattern" '[.assets[].name | select(test($p))][0] // ""'
+          }
+
+          WINDOWS_ASSET="$(pick_asset "dev-x64-Setup[.]exe$")"
+          WINDOWS_ARM64_ASSET="$(pick_asset "dev-arm64-Setup[.]exe$")"
+          MAC_ASSET="$(pick_asset "dev-arm64[.]dmg$")"
+          LINUX_TAR_ASSET="$(pick_asset "dev-linux[.]tar[.]gz$")"
+          LINUX_APPIMAGE_ASSET="$(pick_asset "dev-linux[.]AppImage$")"
+
+          build_link() {
+            local name="$1"
+            if [ -n "$name" ]; then
+              echo "https://github.com/$REPO/releases/download/$TAG/$name"
+            fi
+          }
+
+          WINDOWS_URL="$(build_link "$WINDOWS_ASSET")"
+          WINDOWS_ARM64_URL="$(build_link "$WINDOWS_ARM64_ASSET")"
+          MAC_URL="$(build_link "$MAC_ASSET")"
+          LINUX_TAR_URL="$(build_link "$LINUX_TAR_ASSET")"
+          LINUX_APPIMAGE_URL="$(build_link "$LINUX_APPIMAGE_ASSET")"
+
+          cat > dev_release_notes.md <<EOF
+          ## Daily Dev Build
+          - 该发布页为 **开发版**。
+          - 当前构建版本：\`${{ needs.prepare.outputs.dev_version }}\`
+          - 此版本为每日构建的开发版，包含最新的功能和修复，但可能不够稳定，仅推荐用于测试和验证。
+
+          ## 下载
+          - Windows x64: [点击下载](${WINDOWS_URL:-$RELEASE_PAGE})
+          - Windows arm64: [点击下载](${WINDOWS_ARM64_URL:-$RELEASE_PAGE})
+          - macOS（Apple Silicon）: [点击下载](${MAC_URL:-$RELEASE_PAGE})
+          - Linux (.tar.gz): [点击下载](${LINUX_TAR_URL:-$RELEASE_PAGE})
+          - Linux (.AppImage): [点击下载](${LINUX_APPIMAGE_URL:-$RELEASE_PAGE})
+
+          ## macOS 安装提示
+          - 如果被系统提示已损坏，你需要在终端执行以下命令去除隔离标记：
+          - \`xattr -dr com.apple.quarantine "/Applications/WeFlow.app"\`
+          - 执行后重新打开 WeFlow。
+
+          ## 说明
+          - 该发布页的同名资源会被后续构建覆盖，请勿将其视作长期归档版本。
+          - 如某个平台资源暂未生成，请进入[发布页]($RELEASE_PAGE)查看最新状态
+          EOF
+
+          gh release edit "$TAG" --repo "$REPO" --title "Daily Dev Build" --notes-file dev_release_notes.md

.github/workflows/issue-auto-assign.yml

@@ -0,0 +1,84 @@
+name: Issue Auto Assign
+
+on:
+  issues:
+    types: [opened, edited, reopened]
+
+permissions:
+  issues: write
+
+jobs:
+  assign-by-platform:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Assign issue by selected platform
+        uses: actions/github-script@v7
+        env:
+          ASSIGNEE_WINDOWS: ${{ vars.ISSUE_ASSIGNEE_WINDOWS }}
+          ASSIGNEE_MACOS: ${{ vars.ISSUE_ASSIGNEE_MACOS }}
+          ASSIGNEE_LINUX: ${{ vars.ISSUE_ASSIGNEE_LINUX || 'H3CoF6' }}
+        with:
+          script: |
+            const issue = context.payload.issue;
+            if (!issue) {
+              core.info("No issue payload.");
+              return;
+            }
+
+            const labels = (issue.labels || []).map((l) => l.name);
+            if (!labels.includes("type: bug")) {
+              core.info("Skip non-bug issue.");
+              return;
+            }
+
+            const body = issue.body || "";
+            const match = body.match(/###\s*(?:使用平台|平台|Platform)\s*\r?\n+([^\r\n]+)/i);
+            if (!match) {
+              core.info("No platform field found in issue body.");
+              return;
+            }
+
+            const rawPlatform = match[1].trim().toLowerCase();
+            let platformKey = null;
+            if (rawPlatform.includes("windows")) platformKey = "windows";
+            if (rawPlatform.includes("macos")) platformKey = "macos";
+            if (rawPlatform.includes("linux")) platformKey = "linux";
+
+            if (!platformKey) {
+              core.info(`Unrecognized platform value: ${rawPlatform}`);
+              return;
+            }
+
+            const parseAssignees = (value) =>
+              (value || "")
+                .split(",")
+                .map((v) => v.trim())
+                .filter(Boolean);
+
+            const assigneeMap = {
+              windows: parseAssignees(process.env.ASSIGNEE_WINDOWS),
+              macos: parseAssignees(process.env.ASSIGNEE_MACOS),
+              linux: parseAssignees(process.env.ASSIGNEE_LINUX),
+            };
+
+            const candidates = assigneeMap[platformKey] || [];
+            if (candidates.length === 0) {
+              core.info(`No assignee configured for platform: ${platformKey}`);
+              return;
+            }
+
+            const existing = new Set((issue.assignees || []).map((a) => a.login));
+            const toAdd = candidates.filter((u) => !existing.has(u));
+            if (toAdd.length === 0) {
+              core.info("All configured assignees already assigned.");
+              return;
+            }
+
+            await github.rest.issues.addAssignees({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: issue.number,
+              assignees: toAdd,
+            });
+
+            core.info(`Assigned issue #${issue.number} to: ${toAdd.join(", ")}`);

.github/workflows/preview-nightly-main.yml

@@ -0,0 +1,368 @@
+name: Preview Nightly
+
+on:
+  schedule:
+    # GitHub Actions schedule uses UTC. 16:00 UTC = 北京时间次日 00:00
+    - cron: "0 16 * * *"
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+env:
+  FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
+  FIXED_PREVIEW_TAG: nightly-preview
+  TARGET_BRANCH: main
+  ELECTRON_BUILDER_BINARIES_MIRROR: https://github.com/electron-userland/electron-builder-binaries/releases/download/
+
+jobs:
+  prepare:
+    runs-on: ubuntu-latest
+    outputs:
+      should_build: ${{ steps.meta.outputs.should_build }}
+      preview_version: ${{ steps.meta.outputs.preview_version }}
+    steps:
+      - name: Check out git repository
+        uses: actions/checkout@v5
+        with:
+          ref: ${{ env.TARGET_BRANCH }}
+          fetch-depth: 0
+
+      - name: Install Node.js
+        uses: actions/setup-node@v5
+        with:
+          node-version: 24
+          cache: "npm"
+
+      - name: Decide whether to build and generate preview version
+        id: meta
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          git fetch origin main --depth=1
+          COMMITS_24H="$(git rev-list --count --since='24 hours ago' origin/main)"
+
+          if [ "${{ github.event_name }}" = "workflow_dispatch" ]; then
+            SHOULD_BUILD=true
+          elif [ "$COMMITS_24H" -gt 0 ]; then
+            SHOULD_BUILD=true
+          else
+            SHOULD_BUILD=false
+          fi
+
+          YEAR_2="$(TZ=Asia/Shanghai date +%y)"
+          YEARLY_RUN_COUNT=1
+          LAST_VERSION="$(gh release view "$FIXED_PREVIEW_TAG" --repo "$GITHUB_REPOSITORY" --json body --jq '.body' 2>/dev/null | grep -Eo '0\.[0-9]{2}\.[0-9]+' | head -n 1 || true)"
+          if [[ "$LAST_VERSION" =~ ^0\.([0-9]{2})\.([0-9]+)$ ]]; then
+            LAST_YEAR="${BASH_REMATCH[1]}"
+            LAST_COUNT="${BASH_REMATCH[2]}"
+            if [ "$LAST_YEAR" = "$YEAR_2" ]; then
+              YEARLY_RUN_COUNT=$((LAST_COUNT + 1))
+            fi
+          fi
+
+          PREVIEW_VERSION="0.${YEAR_2}.${YEARLY_RUN_COUNT}"
+
+          echo "should_build=$SHOULD_BUILD" >> "$GITHUB_OUTPUT"
+          echo "preview_version=$PREVIEW_VERSION" >> "$GITHUB_OUTPUT"
+          echo "Preview version: $PREVIEW_VERSION (commits in last 24h on main: $COMMITS_24H, yearly count: $YEARLY_RUN_COUNT)"
+
+      - name: Ensure fixed preview prerelease exists
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: bash
+        run: |
+          set -euo pipefail
+          if gh release view "$FIXED_PREVIEW_TAG" --repo "$GITHUB_REPOSITORY" >/dev/null 2>&1; then
+            gh release edit "$FIXED_PREVIEW_TAG" --repo "$GITHUB_REPOSITORY" --title "Preview Nightly Build" --prerelease
+          else
+            gh release create "$FIXED_PREVIEW_TAG" --repo "$GITHUB_REPOSITORY" --title "Preview Nightly Build" --notes "预览版发布页" --prerelease
+          fi
+
+  preview-mac-arm64:
+    needs: prepare
+    if: needs.prepare.outputs.should_build == 'true'
+    runs-on: macos-14
+    steps:
+      - name: Check out git repository
+        uses: actions/checkout@v5
+        with:
+          ref: ${{ env.TARGET_BRANCH }}
+          fetch-depth: 0
+
+      - name: Install Node.js
+        uses: actions/setup-node@v5
+        with:
+          node-version: 24
+          cache: "npm"
+
+      - name: Install Dependencies
+        run: npm install
+
+      - name: Set preview version
+        shell: bash
+        run: npm version "${{ needs.prepare.outputs.preview_version }}" --no-git-tag-version --allow-same-version
+
+      - name: Build Frontend & Type Check
+        run: |
+          npx tsc
+          npx vite build
+
+      - name: Package macOS arm64 preview artifacts
+        env:
+          CSC_IDENTITY_AUTO_DISCOVERY: "false"
+        shell: bash
+        run: |
+          export ELECTRON_BUILDER_BINARIES_MIRROR="https://github.com/electron-userland/electron-builder-binaries/releases/download/"
+          echo "Using ELECTRON_BUILDER_BINARIES_MIRROR=$ELECTRON_BUILDER_BINARIES_MIRROR"
+          npx electron-builder --mac dmg --arm64 --publish never '--config.publish.channel=preview' '--config.artifactName=${productName}-preview-arm64.${ext}'
+
+      - name: Upload macOS arm64 assets to fixed preview release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: bash
+        run: |
+          assets=()
+          while IFS= read -r file; do
+            assets+=("$file")
+          done < <(find release -maxdepth 1 -type f | sort)
+          if [ "${#assets[@]}" -eq 0 ]; then
+            echo "No release files found in ./release"
+            exit 1
+          fi
+          gh release upload "$FIXED_PREVIEW_TAG" "${assets[@]}" --repo "$GITHUB_REPOSITORY" --clobber
+
+  preview-linux:
+    needs: prepare
+    if: needs.prepare.outputs.should_build == 'true'
+    runs-on: ubuntu-latest
+    steps:
+      - name: Check out git repository
+        uses: actions/checkout@v5
+        with:
+          ref: ${{ env.TARGET_BRANCH }}
+          fetch-depth: 0
+
+      - name: Install Node.js
+        uses: actions/setup-node@v5
+        with:
+          node-version: 24
+          cache: "npm"
+
+      - name: Install Dependencies
+        run: npm install
+
+      - name: Set preview version
+        shell: bash
+        run: npm version "${{ needs.prepare.outputs.preview_version }}" --no-git-tag-version --allow-same-version
+
+      - name: Build Frontend & Type Check
+        run: |
+          npx tsc
+          npx vite build
+
+      - name: Package Linux preview artifacts
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: bash
+        run: |
+          npx electron-builder --linux --publish never '--config.publish.channel=preview' '--config.artifactName=${productName}-preview-linux.${ext}'
+
+      - name: Upload Linux assets to fixed preview release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: bash
+        run: |
+          assets=()
+          while IFS= read -r file; do
+            assets+=("$file")
+          done < <(find release -maxdepth 1 -type f | sort)
+          if [ "${#assets[@]}" -eq 0 ]; then
+            echo "No release files found in ./release"
+            exit 1
+          fi
+          gh release upload "$FIXED_PREVIEW_TAG" "${assets[@]}" --repo "$GITHUB_REPOSITORY" --clobber
+
+  preview-win-x64:
+    needs: prepare
+    if: needs.prepare.outputs.should_build == 'true'
+    runs-on: windows-latest
+    steps:
+      - name: Check out git repository
+        uses: actions/checkout@v5
+        with:
+          ref: ${{ env.TARGET_BRANCH }}
+          fetch-depth: 0
+
+      - name: Install Node.js
+        uses: actions/setup-node@v5
+        with:
+          node-version: 24
+          cache: "npm"
+
+      - name: Install Dependencies
+        run: npm install
+
+      - name: Set preview version
+        shell: bash
+        run: npm version "${{ needs.prepare.outputs.preview_version }}" --no-git-tag-version --allow-same-version
+
+      - name: Build Frontend & Type Check
+        run: |
+          npx tsc
+          npx vite build
+
+      - name: Package Windows x64 preview artifacts
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: bash
+        run: |
+          npx electron-builder --win nsis --x64 --publish never '--config.publish.channel=preview' '--config.artifactName=${productName}-preview-x64-Setup.${ext}'
+
+      - name: Upload Windows x64 assets to fixed preview release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: bash
+        run: |
+          assets=()
+          while IFS= read -r file; do
+            assets+=("$file")
+          done < <(find release -maxdepth 1 -type f | sort)
+          if [ "${#assets[@]}" -eq 0 ]; then
+            echo "No release files found in ./release"
+            exit 1
+          fi
+          gh release upload "$FIXED_PREVIEW_TAG" "${assets[@]}" --repo "$GITHUB_REPOSITORY" --clobber
+
+  preview-win-arm64:
+    needs: prepare
+    if: needs.prepare.outputs.should_build == 'true'
+    runs-on: windows-latest
+    steps:
+      - name: Check out git repository
+        uses: actions/checkout@v5
+        with:
+          ref: ${{ env.TARGET_BRANCH }}
+          fetch-depth: 0
+
+      - name: Install Node.js
+        uses: actions/setup-node@v5
+        with:
+          node-version: 24
+          cache: "npm"
+
+      - name: Install Dependencies
+        run: npm install
+
+      - name: Set preview version
+        shell: bash
+        run: npm version "${{ needs.prepare.outputs.preview_version }}" --no-git-tag-version --allow-same-version
+
+      - name: Build Frontend & Type Check
+        run: |
+          npx tsc
+          npx vite build
+
+      - name: Package Windows arm64 preview artifacts
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: bash
+        run: |
+          npx electron-builder --win nsis --arm64 --publish never '--config.publish.channel=preview-arm64' '--config.artifactName=${productName}-preview-arm64-Setup.${ext}'
+
+      - name: Upload Windows arm64 assets to fixed preview release
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: bash
+        run: |
+          assets=()
+          while IFS= read -r file; do
+            assets+=("$file")
+          done < <(find release -maxdepth 1 -type f | sort)
+          if [ "${#assets[@]}" -eq 0 ]; then
+            echo "No release files found in ./release"
+            exit 1
+          fi
+          gh release upload "$FIXED_PREVIEW_TAG" "${assets[@]}" --repo "$GITHUB_REPOSITORY" --clobber
+
+  update-preview-release-notes:
+    needs:
+      - prepare
+      - preview-mac-arm64
+      - preview-linux
+      - preview-win-x64
+      - preview-win-arm64
+    if: needs.prepare.outputs.should_build == 'true' && always()
+    runs-on: ubuntu-latest
+    steps:
+      - name: Update preview release notes
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          TAG="$FIXED_PREVIEW_TAG"
+          CURRENT_PREVIEW_VERSION="${{ needs.prepare.outputs.preview_version }}"
+          REPO="$GITHUB_REPOSITORY"
+          RELEASE_PAGE="https://github.com/$REPO/releases/tag/$TAG"
+
+          if ! gh release view "$TAG" --repo "$REPO" >/dev/null 2>&1; then
+            echo "Release $TAG not found (possibly all publish jobs failed), skip notes update."
+            exit 0
+          fi
+
+          ASSETS_JSON="$(gh release view "$TAG" --repo "$REPO" --json assets)"
+
+          pick_asset() {
+            local pattern="$1"
+            echo "$ASSETS_JSON" | jq -r --arg p "$pattern" '[.assets[].name | select(test($p))][0] // ""'
+          }
+
+          WINDOWS_ASSET="$(pick_asset "x64.*[.]exe$")"
+          if [ -z "$WINDOWS_ASSET" ]; then
+            WINDOWS_ASSET="$(echo "$ASSETS_JSON" | jq -r '[.assets[].name | select(test("[.]exe$")) | select(test("arm64") | not)][0] // ""')"
+          fi
+          WINDOWS_ARM64_ASSET="$(pick_asset "arm64.*[.]exe$")"
+          MAC_ASSET="$(pick_asset "[.]dmg$")"
+          LINUX_TAR_ASSET="$(pick_asset "[.]tar[.]gz$")"
+          LINUX_APPIMAGE_ASSET="$(pick_asset "[.]AppImage$")"
+
+          build_link() {
+            local name="$1"
+            if [ -n "$name" ]; then
+              echo "https://github.com/$REPO/releases/download/$TAG/$name"
+            fi
+          }
+
+          WINDOWS_URL="$(build_link "$WINDOWS_ASSET")"
+          WINDOWS_ARM64_URL="$(build_link "$WINDOWS_ARM64_ASSET")"
+          MAC_URL="$(build_link "$MAC_ASSET")"
+          LINUX_TAR_URL="$(build_link "$LINUX_TAR_ASSET")"
+          LINUX_APPIMAGE_URL="$(build_link "$LINUX_APPIMAGE_ASSET")"
+
+          cat > preview_release_notes.md <<EOF
+          ## Preview Nightly 说明
+          - 该版本为 **预览版**，用于提前体验即将发布的功能与修复。
+          - 可能包含尚未完全稳定的改动，不建议长期使用
+          - 当前版本号：\`$CURRENT_PREVIEW_VERSION\`
+
+          ## 下载
+          - Windows x64: [点击下载](${WINDOWS_URL:-$RELEASE_PAGE})
+          - Windows arm64: [点击下载](${WINDOWS_ARM64_URL:-$RELEASE_PAGE})
+          - macOS（Apple Silicon）: [点击下载](${MAC_URL:-$RELEASE_PAGE})
+          - Linux (.tar.gz): [点击下载](${LINUX_TAR_URL:-$RELEASE_PAGE})
+          - Linux (.AppImage): [点击下载](${LINUX_APPIMAGE_URL:-$RELEASE_PAGE})
+
+          ## macOS 安装提示
+          - 如果被系统提示已损坏，你需要在终端执行以下命令去除隔离标记：
+          - \`xattr -dr com.apple.quarantine "/Applications/WeFlow.app"\`
+          - 执行后重新打开 WeFlow。
+
+          > 如某个平台链接暂未生成，请前往[发布页]($RELEASE_PAGE)查看最新资源
+          EOF
+
+          gh release edit "$TAG" --repo "$REPO" --notes-file preview_release_notes.md

.github/workflows/release.yml

@@ -10,6 +10,7 @@ permissions:
 
 env:
   FORCE_JAVASCRIPT_ACTIONS_TO_NODE24: "true"
+  ELECTRON_BUILDER_BINARIES_MIRROR: https://github.com/electron-userland/electron-builder-binaries/releases/download/
 
 jobs:
   release-mac-arm64:
@@ -28,7 +29,7 @@ jobs:
           cache: "npm"
 
       - name: Install Dependencies
-        run: npm ci
+        run: npm install
 
       - name: Sync version with tag
         shell: bash
@@ -46,23 +47,77 @@ jobs:
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           CSC_IDENTITY_AUTO_DISCOVERY: "false"
+        shell: bash
         run: |
+          export ELECTRON_BUILDER_BINARIES_MIRROR="https://github.com/electron-userland/electron-builder-binaries/releases/download/"
+          echo "Using ELECTRON_BUILDER_BINARIES_MIRROR=$ELECTRON_BUILDER_BINARIES_MIRROR"
           npx electron-builder --mac dmg --arm64 --publish always
 
-      - name: Update Release Notes
+      - name: Inject minimumVersion into latest yml
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         shell: bash
         run: |
-          cat <<EOF > release_notes.md
-          ## 更新日志
-          修复了一些已知问题
+          TAG=${GITHUB_REF_NAME}
+          REPO=${{ github.repository }}
+          MINIMUM_VERSION="4.1.7"
+          for YML_FILE in latest-mac.yml latest-arm64-mac.yml; do
+            gh release download "$TAG" --repo "$REPO" --pattern "$YML_FILE" --output "/tmp/$YML_FILE" 2>/dev/null || continue
+            if ! grep -q 'minimumVersion' "/tmp/$YML_FILE"; then
+              echo "minimumVersion: $MINIMUM_VERSION" >> "/tmp/$YML_FILE"
+            fi
+            gh release upload "$TAG" --repo "$REPO" "/tmp/$YML_FILE" --clobber
+          done
 
-          ## 查看更多日志/获取最新动态
-          [点击加入 Telegram 频道](https://t.me/weflow_cc)
-          EOF
+  release-linux:
+    runs-on: ubuntu-latest
 
-          gh release edit "$GITHUB_REF_NAME" --notes-file release_notes.md
+    steps:
+      - name: Check out git repository
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      - name: Install Node.js
+        uses: actions/setup-node@v5
+        with:
+          node-version: 24
+          cache: "npm"
+
+      - name: Install Dependencies
+        run: npm install
+
+      - name: Sync version with tag
+        shell: bash
+        run: |
+          VERSION=${GITHUB_REF_NAME#v}
+          echo "Syncing package.json version to $VERSION"
+          npm version $VERSION --no-git-tag-version --allow-same-version
+
+      - name: Build Frontend & Type Check
+        run: |
+          npx tsc
+          npx vite build
+
+      - name: Package and Publish Linux
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          npx electron-builder --linux --publish always
+
+      - name: Inject minimumVersion into latest yml
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: bash
+        run: |
+          TAG=${GITHUB_REF_NAME}
+          REPO=${{ github.repository }}
+          MINIMUM_VERSION="4.1.7"
+          gh release download "$TAG" --repo "$REPO" --pattern "latest-linux.yml" --output "/tmp/latest-linux.yml" 2>/dev/null
+          if [ -f /tmp/latest-linux.yml ] && ! grep -q 'minimumVersion' /tmp/latest-linux.yml; then
+            echo "minimumVersion: $MINIMUM_VERSION" >> /tmp/latest-linux.yml
+            gh release upload "$TAG" --repo "$REPO" /tmp/latest-linux.yml --clobber
+          fi
 
   release:
     runs-on: windows-latest
@@ -80,7 +135,7 @@ jobs:
           cache: 'npm'
 
       - name: Install Dependencies
-        run: npm ci
+        run: npm install
 
       - name: Sync version with tag
         shell: bash
@@ -98,19 +153,141 @@ jobs:
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |
-          npx electron-builder --publish always
+          npx electron-builder --win nsis --x64 --publish always '--config.artifactName=${productName}-${version}-x64-Setup.${ext}'
 
-      - name: Update Release Notes
+      - name: Inject minimumVersion into latest yml
         env:
           GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         shell: bash
         run: |
-          cat <<EOF > release_notes.md
+          TAG=${GITHUB_REF_NAME}
+          REPO=${{ github.repository }}
+          MINIMUM_VERSION="4.1.7"
+          gh release download "$TAG" --repo "$REPO" --pattern "latest.yml" --output "/tmp/latest.yml" 2>/dev/null
+          if [ -f /tmp/latest.yml ] && ! grep -q 'minimumVersion' /tmp/latest.yml; then
+            echo "minimumVersion: $MINIMUM_VERSION" >> /tmp/latest.yml
+            gh release upload "$TAG" --repo "$REPO" /tmp/latest.yml --clobber
+          fi
+
+  release-windows-arm64:
+    runs-on: windows-latest
+
+    steps:
+      - name: Check out git repository
+        uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      - name: Install Node.js
+        uses: actions/setup-node@v5
+        with:
+          node-version: 24
+          cache: 'npm'
+
+      - name: Install Dependencies
+        run: npm install
+
+      - name: Sync version with tag
+        shell: bash
+        run: |
+          VERSION=${GITHUB_REF_NAME#v}
+          echo "Syncing package.json version to $VERSION"
+          npm version $VERSION --no-git-tag-version --allow-same-version
+
+      - name: Build Frontend & Type Check
+        run: |
+          npx tsc
+          npx vite build
+
+      - name: Package and Publish Windows arm64
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          npx electron-builder --win nsis --arm64 --publish always '--config.publish.channel=latest-arm64' '--config.artifactName=${productName}-${version}-arm64-Setup.${ext}'
+
+      - name: Inject minimumVersion into latest yml
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: bash
+        run: |
+          TAG=${GITHUB_REF_NAME}
+          REPO=${{ github.repository }}
+          MINIMUM_VERSION="4.1.7"
+          gh release download "$TAG" --repo "$REPO" --pattern "latest-arm64.yml" --output "/tmp/latest-arm64.yml" 2>/dev/null
+          if [ -f /tmp/latest-arm64.yml ] && ! grep -q 'minimumVersion' /tmp/latest-arm64.yml; then
+            echo "minimumVersion: $MINIMUM_VERSION" >> /tmp/latest-arm64.yml
+            gh release upload "$TAG" --repo "$REPO" /tmp/latest-arm64.yml --clobber
+          fi
+
+  update-release-notes:
+    runs-on: ubuntu-latest
+    needs:
+      - release-mac-arm64
+      - release-linux
+      - release
+      - release-windows-arm64
+
+    steps:
+      - name: Generate release notes with platform download links
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        shell: bash
+        run: |
+          set -euo pipefail
+
+          TAG="$GITHUB_REF_NAME"
+          REPO="$GITHUB_REPOSITORY"
+          RELEASE_PAGE="https://github.com/$REPO/releases/tag/$TAG"
+
+          ASSETS_JSON="$(gh release view "$TAG" --repo "$REPO" --json assets)"
+
+          pick_asset() {
+            local pattern="$1"
+            echo "$ASSETS_JSON" | jq -r --arg p "$pattern" '[.assets[].name | select(test($p))][0] // ""'
+          }
+
+          WINDOWS_ASSET="$(echo "$ASSETS_JSON" | jq -r '[.assets[].name | select(test("x64.*\\.exe$"))][0] // ""')"
+          if [ -z "$WINDOWS_ASSET" ]; then
+            WINDOWS_ASSET="$(echo "$ASSETS_JSON" | jq -r '[.assets[].name | select(test("\\.exe$")) | select(test("arm64") | not)][0] // ""')"
+          fi
+          WINDOWS_ARM64_ASSET="$(echo "$ASSETS_JSON" | jq -r '[.assets[].name | select(test("arm64.*\\.exe$"))][0] // ""')"
+          MAC_ASSET="$(pick_asset "\\.dmg$")"
+          LINUX_TAR_ASSET="$(pick_asset "\\.tar\\.gz$")"
+          LINUX_APPIMAGE_ASSET="$(pick_asset "\\.AppImage$")"
+
+          build_link() {
+            local name="$1"
+            if [ -n "$name" ]; then
+              echo "https://github.com/$REPO/releases/download/$TAG/$name"
+            fi
+          }
+
+          WINDOWS_URL="$(build_link "$WINDOWS_ASSET")"
+          WINDOWS_ARM64_URL="$(build_link "$WINDOWS_ARM64_ASSET")"
+          MAC_URL="$(build_link "$MAC_ASSET")"
+          LINUX_TAR_URL="$(build_link "$LINUX_TAR_ASSET")"
+          LINUX_APPIMAGE_URL="$(build_link "$LINUX_APPIMAGE_ASSET")"
+
+          cat > release_notes.md <<EOF
           ## 更新日志
           修复了一些已知问题
 
           ## 查看更多日志/获取最新动态
           [点击加入 Telegram 频道](https://t.me/weflow_cc)
+
+          ## 下载
+          - Windows x64（Win10+）: [点击下载](${WINDOWS_URL:-$RELEASE_PAGE})
+          - Windows arm64: [点击下载](${WINDOWS_ARM64_URL:-$RELEASE_PAGE})
+          - macOS（M系列芯片）: [点击下载](${MAC_URL:-$RELEASE_PAGE})
+          - Linux (.tar.gz): [点击下载](${LINUX_TAR_URL:-$RELEASE_PAGE})
+          - Linux (.AppImage): [点击下载](${LINUX_APPIMAGE_URL:-$RELEASE_PAGE})
+
+          ## macOS 安装提示
+          - 如果被系统提示已损坏，你需要在终端执行以下命令去除隔离标记：
+          - \`xattr -dr com.apple.quarantine "/Applications/WeFlow.app"\`
+          - 执行后重新打开 WeFlow。
+
+          > 如果某个平台链接暂时未生成，可进入[完整发布页]($RELEASE_PAGE)查看全部资源
           EOF
-          
-          gh release edit "$GITHUB_REF_NAME" --notes-file release_notes.md
+
+          gh release edit "$TAG" --repo "$REPO" --notes-file release_notes.md

.github/workflows/security-scan.yml

@@ -0,0 +1,87 @@
+name: Security Scan
+
+on:
+  schedule:
+    - cron: '0 2 * * *'  # 每天 UTC 02:00
+  workflow_dispatch:     # 手动触发
+  pull_request:          # PR 时触发
+    branches: [ main, dev ]
+
+permissions:
+  contents: read
+  security-events: write
+  actions: read
+
+jobs:
+  security-scan:
+    name: Security Scan (${{ matrix.branch }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        branch:
+          - main
+
+    steps:
+      - name: Checkout ${{ matrix.branch }}
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ matrix.branch }}
+          fetch-depth: 0
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm' # 使用 npm 缓存加速
+
+      - name: Install dependencies
+        run: npm ci --ignore-scripts
+
+      # 1. npm audit - 检查依赖漏洞
+      - name: Dependency vulnerability audit
+        run: npm audit --audit-level=moderate
+        continue-on-error: true
+
+      # 2. CodeQL 静态分析
+      - name: Initialize CodeQL
+        uses: github/codeql-action/init@v3
+        with:
+          languages: javascript, typescript
+          queries: security-and-quality
+
+      - name: Autobuild
+        uses: github/codeql-action/autobuild@v3
+
+      - name: Perform CodeQL Analysis
+        uses: github/codeql-action/analyze@v3
+        with:
+          category: '/language:javascript-typescript/branch:${{ matrix.branch }}'
+
+      # 3. 密钥/敏感信息扫描
+      - name: Secret scanning with Gitleaks
+        uses: gitleaks/gitleaks-action@v2
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        continue-on-error: true
+
+  # 动态获取所有分支并扫描
+  scan-all-branches:
+    name: Scan additional branches
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Run npm audit on all branches
+        run: |
+          git branch -r | grep -v HEAD | sed 's|origin/||' | tr -d ' ' | while read branch; do
+            echo "===== Auditing branch: $branch ====="
+            git checkout "$branch" 2>/dev/null || continue
+            # 尝试安装并审计
+            npm ci --ignore-scripts --silent 2>/dev/null || npm install --ignore-scripts --silent 2>/dev/null || true
+            npm audit --audit-level=moderate 2>/dev/null || true
+          done
+        continue-on-error: true

.gitignore

@@ -62,9 +62,13 @@ server/
 chatlab-format.md
 *.bak
 AGENTS.md
+AGENT.md
 .claude/
 CLAUDE.md
 .agents/
 resources/wx_send
 概述.md
 pnpm-lock.yaml
+/pnpm-workspace.yaml
+wechat-research-site
+.codex

.gitleaks.toml

@@ -0,0 +1,23 @@
+title = "Gitleaks Config"
+
+[extend]
+# 继承默认规则
+useDefault = true
+
+# 排除误报路径
+[[rules]]
+id = "curl-auth-header"
+[rules.allowlist]
+paths = [
+  '''docs/HTTP-API\.md'''
+]
+regexes = [
+  '''YOUR_TOKEN'''
+]
+
+[[rules]]
+id = "generic-api-key"
+[rules.allowlist]
+paths = [
+  '''src/pages/ChatPage\.tsx'''
+]

.npmrc

@@ -1,3 +1 @@
-registry=https://registry.npmmirror.com
-electron_mirror=https://npmmirror.com/mirrors/electron/
-electron_builder_binaries_mirror=https://npmmirror.com/mirrors/electron-builder-binaries/
+registry=https://registry.npmjs.org

README.md

@@ -19,7 +19,9 @@ WeFlow 是一个**完全本地**的微信**实时**聊天记录查看、分析
 </a>
 <a href="https://github.com/hicccc77/WeFlow/issues">
 <img src="https://img.shields.io/github/issues/hicccc77/WeFlow?style=flat-square" alt="Issues">
-<img src="https://gh-down-badges.linkof.link/hicccc77/WeFlow/" alt="Downloads" />
+</a>
+<a href="https://github.com/hicccc77/WeFlow/releases">
+<img src="https://img.shields.io/github/downloads/hicccc77/WeFlow/total?style=flat-square" alt="Downloads" />
 </a>
 <a href="https://t.me/weflow_cc">
 <img src="https://img.shields.io/badge/Telegram%20频道-0088cc?style=flat-square&logo=telegram&logoColor=0088cc&labelColor=white" alt="Telegram">
@@ -43,9 +45,21 @@ WeFlow 是一个**完全本地**的微信**实时**聊天记录查看、分析
 - HTTP API 接口（供开发者集成）
 - 查看完整能力清单：[详细功能](#详细功能清单)
 
+## 支持平台与设备
+
+
+| 平台 | 设备/架构 | 安装包 |
+|------|----------|--------|
+| Windows | Windows10+、x64（amd64） | `.exe` |
+| macOS | Apple Silicon（M 系列，arm64） | `.dmg` |
+| Linux | x64 设备（amd64） | `.AppImage`、`.tar.gz` |
+
+
 ## 快速开始
 
-若你只想使用成品版本，可前往 Release 下载并安装。
+若你只想使用成品版本，可前往 [Releases](https://github.com/hicccc77/WeFlow/releases) 下载并安装。
+
+> ArchLinux 用户可以选择 `yay -S weflow` 快速安装
 
 ## 详细功能清单
 
@@ -94,14 +108,8 @@ npm install
 # 3. 运行应用（开发模式）
 npm run dev
 
-# 4. 打包可执行文件
-npm run build
 ```
 
-打包产物在 `release` 目录下。
-
-
-
 ## 致谢
 
 - [密语 CipherTalk](https://github.com/ILoveBingLu/miyu) 为本项目提供了基础框架

docs/HTTP-API.md

@@ -1,33 +1,56 @@
-# WeFlow HTTP API 接口文档
+# WeFlow HTTP API / Push 文档
 
-WeFlow 提供 HTTP API 服务，支持通过 HTTP 接口查询消息数据，支持 [ChatLab](https://github.com/nichuanfang/chatlab-format) 标准化格式输出。
+WeFlow 提供本地 HTTP API（已支持GET 和 POST请求），便于外部脚本或工具读取聊天记录、会话、联系人、群成员和导出的媒体文件；也支持在检测到新消息后通过固定 SSE 地址主动推送消息事件。
 
-## 启用 API 服务
+## 启用方式
 
-在设置页面 → API 服务 → 点击「启动服务」按钮。
+在应用设置页启用 `API 服务`。
 
-默认端口：`5031`
+- 默认监听地址：`127.0.0.1`
+- 默认端口：`5031`
+- 基础地址：`http://127.0.0.1:5031`
+- 可选开启 `主动推送`，检测到新收到的消息后会通过 `GET /api/v1/push/messages` 推送给 SSE 订阅端
 
-## 基础地址
+**状态记忆**：API 服务和主动推送的状态及端口会自动保存，重启 WeFlow 后会自动恢复运行。
 
-```
-http://127.0.0.1:5031
-```
+## 鉴权规范
 
----
+**鉴权规范 (Access Token)** 除健康检查接口外，所有 `/api/v1/*` 接口均受 Token 保护。支持三种传参方式（任选其一）：
+
+1. **HTTP Header (推荐)**: `Authorization: Bearer <您的Token>`
+2. **Query 参数**: `?access_token=<您的Token>`（SSE 长连接推荐此方式）
+3. **JSON Body**: `{"access_token": "<您的Token>"}`（仅限 POST 请求）
 
 ## 接口列表
 
-### 1. 健康检查
+- `GET|POST /health`
+- `GET|POST /api/v1/health`
+- `GET|POST /api/v1/push/messages`
+- `GET|POST /api/v1/messages`
+- `GET|POST /api/v1/messages/new`
+- `GET|POST /api/v1/sessions`
+- `GET|POST /api/v1/contacts`
+- `GET|POST /api/v1/group-members`
+- `GET|POST /api/v1/media/*`
 
-检查 API 服务是否正常运行。
+---
+
+## 1. 健康检查
 
 **请求**
-```
+
+```http
 GET /health
 ```
 
+或
+
+```http
+GET /api/v1/health
+```
+
 **响应**
+
 ```json
 {
   "status": "ok"
@@ -36,211 +59,227 @@ GET /health
 
 ---
 
-### 2. 获取消息列表
+## 2. 主动推送
 
-获取指定会话的消息，支持 ChatLab 格式输出。
+通过 SSE 长连接接收新消息事件，端口与 HTTP API 共用。
 
 **请求**
+
+```http
+GET /api/v1/push/messages
 ```
+
+### 说明
+
+- 需要先在设置页开启 `HTTP API 服务`
+- 同时需要开启 `主动推送`
+- 响应类型为 `text/event-stream`
+- 新消息事件名固定为 `message.new`
+- 建议接收端按 `messageKey` 去重
+
+### 事件字段
+
+- `event`
+- `sessionId`
+- `messageKey`
+- `avatarUrl`
+- `sourceName`
+- `groupName`（仅群聊）
+- `content`
+
+### 示例
+
+```bash
+curl -N "http://127.0.0.1:5031/api/v1/push/messages?access_token=YOUR_TOKEN
+```
+
+示例事件：
+
+```text
+event: message.new
+data: {"event":"message.new","sessionId":"xxx@chatroom","messageKey":"server:123456:1760000123:1760000123000:321:wxid_member:1","avatarUrl":"https://example.com/group.jpg","sourceName":"李四","groupName":"项目群","content":"[图片]"}
+```
+
+---
+
+## 3. 获取消息
+
+> 当使用 POST 时，请将参数放在 JSON Body 中（Content-Type: application/json）
+
+读取指定会话的消息，支持原始 JSON 和 ChatLab 格式。
+
+**请求**
+
+```http
 GET /api/v1/messages
 ```
 
-**参数**
+### 参数
 
-| 参数名 | 类型 | 必填 | 说明 |
-|--------|------|------|------|
-| `talker` | string | ✅ | 会话 ID（wxid 或群 ID） |
-| `limit` | number | ❌ | 返回数量限制，默认 100，范围 `1~10000` |
-| `offset` | number | ❌ | 偏移量，用于分页，默认 0 |
-| `start` | string | ❌ | 开始时间，格式 YYYYMMDD |
-| `end` | string | ❌ | 结束时间，格式 YYYYMMDD |
-| `keyword` | string | ❌ | 关键词过滤（基于消息显示文本） |
-| `chatlab` | string | ❌ | 设为 `1` 则输出 ChatLab 格式 |
-| `format` | string | ❌ | 输出格式：`json`（默认）或 `chatlab` |
-| `media` | string | ❌ | 设为 `1` 时导出媒体并返回媒体路径（兼容别名 `meiti`）；`0` 时媒体返回占位符 |
-| `image` | string | ❌ | 在 `media=1` 时控制图片导出，`1/0`（兼容别名 `tupian`） |
-| `voice` | string | ❌ | 在 `media=1` 时控制语音导出，`1/0`（兼容别名 `vioce`） |
-| `video` | string | ❌ | 在 `media=1` 时控制视频导出，`1/0` |
-| `emoji` | string | ❌ | 在 `media=1` 时控制表情导出，`1/0` |
+| 参数 | 类型 | 必填 | 说明 |
+| --- | --- | --- | --- |
+| `talker` | string | 是 | 会话 ID。私聊通常是对方 `wxid`，群聊是 `xxx@chatroom` |
+| `limit` | number | 否 | 返回条数，默认 `100`，范围 `1~10000` |
+| `offset` | number | 否 | 分页偏移，默认 `0` |
+| `start` | string | 否 | 开始时间，支持 `YYYYMMDD` 或时间戳 |
+| `end` | string | 否 | 结束时间，支持 `YYYYMMDD` 或时间戳 |
+| `keyword` | string | 否 | 基于消息显示文本过滤 |
+| `chatlab` | string | 否 | `1/true` 时输出 ChatLab 格式 |
+| `format` | string | 否 | `json` 或 `chatlab` |
+| `media` | string | 否 | `1/true` 时导出媒体并返回媒体地址，兼容别名 `meiti` |
+| `image` | string | 否 | 在 `media=1` 时控制图片导出，兼容别名 `tupian` |
+| `voice` | string | 否 | 在 `media=1` 时控制语音导出，兼容别名 `vioce` |
+| `video` | string | 否 | 在 `media=1` 时控制视频导出 |
+| `emoji` | string | 否 | 在 `media=1` 时控制表情导出 |
 
-默认媒体导出目录：`%USERPROFILE%\\Documents\\WeFlow\\api-media`
-
-**示例请求**
+### 示例
 
 ```bash
-# 获取消息（原始格式）
-GET http://127.0.0.1:5031/api/v1/messages?talker=wxid_xxx&limit=50
-
-# 获取消息（ChatLab 格式）
-GET http://127.0.0.1:5031/api/v1/messages?talker=wxid_xxx&chatlab=1
-
-# 带时间范围查询
-GET http://127.0.0.1:5031/api/v1/messages?talker=wxid_xxx&start=20260101&end=20260205&limit=100
-
-# 开启媒体导出（只导出图片和语音）
-GET http://127.0.0.1:5031/api/v1/messages?talker=wxid_xxx&media=1&image=1&voice=1&video=0&emoji=0
-
-# 关键词过滤
-GET http://127.0.0.1:5031/api/v1/messages?talker=wxid_xxx&keyword=项目进度&limit=50
+curl "http://127.0.0.1:5031/api/v1/messages?talker=wxid_xxx&limit=20"
+curl "http://127.0.0.1:5031/api/v1/messages?talker=xxx@chatroom&chatlab=1"
+curl "http://127.0.0.1:5031/api/v1/messages?talker=wxid_xxx&start=20260101&end=20260131"
+curl "http://127.0.0.1:5031/api/v1/messages?talker=xxx@chatroom&media=1&image=1&voice=0&video=0&emoji=0"
 ```
 
-**响应（原始格式）**
+### JSON 响应字段
+
+顶层字段：
+
+- `success`
+- `talker`
+- `count`
+- `hasMore`
+- `media.enabled`
+- `media.exportPath`
+- `media.count`
+- `messages`
+
+单条消息字段：
+
+- `localId`
+- `serverId`
+- `localType`
+- `createTime`
+- `isSend`
+- `senderUsername`
+- `content`
+- `rawContent`
+- `parsedContent`
+- `mediaType`
+- `mediaFileName`
+- `mediaUrl`
+- `mediaLocalPath`
+
+**示例响应**
+
 ```json
 {
   "success": true,
-  "talker": "wxid_xxx",
-  "count": 50,
+  "talker": "xxx@chatroom",
+  "count": 2,
   "hasMore": true,
   "media": {
     "enabled": true,
     "exportPath": "C:\\Users\\Alice\\Documents\\WeFlow\\api-media",
-    "count": 12
+    "count": 1
   },
   "messages": [
     {
       "localId": 123,
+      "serverId": "456",
+      "localType": 1,
+      "createTime": 1738713600,
+      "isSend": 0,
+      "senderUsername": "wxid_member",
+      "content": "你好",
+      "rawContent": "你好",
+      "parsedContent": "你好"
+    },
+    {
+      "localId": 124,
       "localType": 3,
+      "createTime": 1738713660,
+      "isSend": 0,
+      "senderUsername": "wxid_member",
       "content": "[图片]",
-      "createTime": 1738713600000,
-      "senderUsername": "wxid_sender",
       "mediaType": "image",
-      "mediaFileName": "image_123.jpg",
-      "mediaUrl": "http://127.0.0.1:5031/api/v1/media/wxid_xxx/images/image_123.jpg",
-      "mediaLocalPath": "C:\\Users\\Alice\\Documents\\WeFlow\\api-media\\wxid_xxx\\images\\image_123.jpg"
+      "mediaFileName": "abc123.jpg",
+      "mediaUrl": "http://127.0.0.1:5031/api/v1/media/xxx@chatroom/images/abc123.jpg",
+      "mediaLocalPath": "C:\\Users\\Alice\\Documents\\WeFlow\\api-media\\xxx@chatroom\\images\\abc123.jpg"
     }
   ]
 }
 ```
 
-**响应（ChatLab 格式）**
-```json
-{
-  "chatlab": {
-    "version": "0.0.2",
-    "exportedAt": 1738713600000,
-    "generator": "WeFlow",
-    "description": "Exported from WeFlow"
-  },
-  "meta": {
-    "name": "会话名称",
-    "platform": "wechat",
-    "type": "private",
-    "ownerId": "wxid_me"
-  },
-  "members": [
-    {
-      "platformId": "wxid_xxx",
-      "accountName": "用户名",
-      "groupNickname": "群昵称"
-    }
-  ],
-  "messages": [
-    {
-      "sender": "wxid_xxx",
-      "accountName": "用户名",
-      "timestamp": 1738713600000,
-      "type": 0,
-      "content": "消息内容",
-      "mediaPath": "http://127.0.0.1:5031/api/v1/media/wxid_xxx/images/image_123.jpg"
-    }
-  ],
-  "media": {
-    "enabled": true,
-    "exportPath": "C:\\Users\\Alice\\Documents\\WeFlow\\api-media",
-    "count": 12
-  }
-}
-```
+### ChatLab 响应
+
+当 `chatlab=1` 或 `format=chatlab` 时，返回 ChatLab 结构：
+
+- `chatlab.version`
+- `chatlab.exportedAt`
+- `chatlab.generator`
+- `meta.name`
+- `meta.platform`
+- `meta.type`
+- `meta.groupId`
+- `meta.groupAvatar`
+- `meta.ownerId`
+- `members[].platformId`
+- `members[].accountName`
+- `members[].groupNickname`
+- `members[].avatar`
+- `messages[].sender`
+- `messages[].accountName`
+- `messages[].groupNickname`
+- `messages[].timestamp`
+- `messages[].type`
+- `messages[].content`
+- `messages[].platformMessageId`
+- `messages[].mediaPath`
+
+群聊里 `groupNickname` 会优先来自群成员群昵称；若源数据缺失，则回退为空或展示名。
 
 ---
 
-### 3. 访问导出媒体文件
+## 4. 获取会话列表
 
-通过 HTTP 直接访问已导出的媒体文件（图片、语音、视频、表情）。
+> 当使用 POST 时，请将参数放在 JSON Body 中（Content-Type: application/json）
 
 **请求**
-```
-GET /api/v1/media/{relativePath}
-```
 
-**路径参数**
-
-| 参数名 | 类型 | 必填 | 说明 |
-|--------|------|------|------|
-| `relativePath` | string | ✅ | 媒体文件的相对路径，如 `wxid_xxx/images/image_123.jpg` |
-
-**支持的媒体类型**
-
-| 扩展名 | Content-Type |
-|--------|-------------|
-| `.png` | image/png |
-| `.jpg` / `.jpeg` | image/jpeg |
-| `.gif` | image/gif |
-| `.webp` | image/webp |
-| `.wav` | audio/wav |
-| `.mp3` | audio/mpeg |
-| `.mp4` | video/mp4 |
-
-**示例请求**
-```bash
-# 访问导出的图片
-GET http://127.0.0.1:5031/api/v1/media/wxid_xxx/images/image_123.jpg
-
-# 访问导出的语音
-GET http://127.0.0.1:5031/api/v1/media/wxid_xxx/voices/voice_456.wav
-
-# 访问导出的视频
-GET http://127.0.0.1:5031/api/v1/media/wxid_xxx/videos/video_789.mp4
-```
-
-**响应**
-
-成功时直接返回文件内容，`Content-Type` 根据文件扩展名自动设置。
-
-失败时返回：
-```json
-{ "error": "Media not found" }
-```
-
-> 注意：媒体文件需要先通过消息接口的 `media=1` 参数导出后才能访问。
-
----
-
-### 4. 获取会话列表
-
-获取所有会话列表。
-
-**请求**
-```
+```http
 GET /api/v1/sessions
 ```
 
-**参数**
+### 参数
 
-| 参数名 | 类型 | 必填 | 说明 |
-|--------|------|------|------|
-| `keyword` | string | ❌ | 搜索关键词，匹配会话名或 ID |
-| `limit` | number | ❌ | 返回数量限制，默认 100 |
+| 参数 | 类型 | 必填 | 说明 |
+| --- | --- | --- | --- |
+| `keyword` | string | 否 | 匹配 `username` 或 `displayName` |
+| `limit` | number | 否 | 默认 `100` |
 
-**示例请求**
-```bash
-GET http://127.0.0.1:5031/api/v1/sessions
+### 响应字段
 
-GET http://127.0.0.1:5031/api/v1/sessions?keyword=工作群&limit=20
-```
+- `success`
+- `count`
+- `sessions[].username`
+- `sessions[].displayName`
+- `sessions[].type`
+- `sessions[].lastTimestamp`
+- `sessions[].unreadCount`
+
+**示例响应**
 
-**响应**
 ```json
 {
   "success": true,
-  "count": 50,
-  "total": 100,
+  "count": 1,
   "sessions": [
     {
-      "username": "wxid_xxx",
-      "displayName": "用户名",
-      "lastMessage": "最后一条消息",
-      "lastTime": 1738713600000,
+      "username": "xxx@chatroom",
+      "displayName": "项目群",
+      "type": 2,
+      "lastTimestamp": 1738713600,
       "unreadCount": 0
     }
   ]
@@ -249,40 +288,50 @@ GET http://127.0.0.1:5031/api/v1/sessions?keyword=工作群&limit=20
 
 ---
 
-### 4. 获取联系人列表
+## 5. 获取联系人列表
 
-获取所有联系人信息。
+> 当使用 POST 时，请将参数放在 JSON Body 中（Content-Type: application/json）
 
 **请求**
-```
+
+```http
 GET /api/v1/contacts
 ```
 
-**参数**
+### 参数
 
-| 参数名 | 类型 | 必填 | 说明 |
-|--------|------|------|------|
-| `keyword` | string | ❌ | 搜索关键词 |
-| `limit` | number | ❌ | 返回数量限制，默认 100 |
+| 参数 | 类型 | 必填 | 说明 |
+| --- | --- | --- | --- |
+| `keyword` | string | 否 | 匹配 `username`、`nickname`、`remark`、`displayName` |
+| `limit` | number | 否 | 默认 `100` |
 
-**示例请求**
-```bash
-GET http://127.0.0.1:5031/api/v1/contacts
+### 响应字段
 
-GET http://127.0.0.1:5031/api/v1/contacts?keyword=张三
-```
+- `success`
+- `count`
+- `contacts[].username`
+- `contacts[].displayName`
+- `contacts[].remark`
+- `contacts[].nickname`
+- `contacts[].alias`
+- `contacts[].avatarUrl`
+- `contacts[].type`
+
+**示例响应**
 
-**响应**
 ```json
 {
   "success": true,
-  "count": 50,
+  "count": 1,
   "contacts": [
     {
-      "userName": "wxid_xxx",
-      "alias": "微信号",
-      "nickName": "昵称",
-      "remark": "备注名"
+      "username": "wxid_xxx",
+      "displayName": "张三",
+      "remark": "客户张三",
+      "nickname": "张三",
+      "alias": "zhangsan",
+      "avatarUrl": "https://example.com/avatar.jpg",
+      "type": "friend"
     }
   ]
 }
@@ -290,60 +339,281 @@ GET http://127.0.0.1:5031/api/v1/contacts?keyword=张三
 
 ---
 
-## ChatLab 格式说明
+## 6. 获取群成员列表
 
-ChatLab 是一种标准化的聊天记录交换格式，版本 0.0.2。
+> 当使用 POST 时，请将参数放在 JSON Body 中（Content-Type: application/json）
 
-### 消息类型映射
+返回群成员的 `wxid`、群昵称、备注、微信号等信息。
 
-| ChatLab Type | 值 | 说明 |
-|--------------|-----|------|
-| TEXT | 0 | 文本消息 |
-| IMAGE | 1 | 图片 |
-| VOICE | 2 | 语音 |
-| VIDEO | 3 | 视频 |
-| FILE | 4 | 文件 |
-| EMOJI | 5 | 表情 |
-| LINK | 7 | 链接 |
-| LOCATION | 8 | 位置 |
-| RED_PACKET | 20 | 红包 |
-| TRANSFER | 21 | 转账 |
-| CALL | 23 | 通话 |
-| SYSTEM | 80 | 系统消息 |
-| RECALL | 81 | 撤回消息 |
-| OTHER | 99 | 其他 |
+**请求**
+
+```http
+GET /api/v1/group-members
+```
+
+### 参数
+
+| 参数 | 类型 | 必填 | 说明 |
+| --- | --- | --- | --- |
+| `chatroomId` | string | 是 | 群 ID，兼容使用 `talker` 传入 |
+| `includeMessageCounts` | string | 否 | `1/true` 时附带成员发言数 |
+| `withCounts` | string | 否 | `includeMessageCounts` 的别名 |
+| `forceRefresh` | string | 否 | `1/true` 时跳过内存缓存强制刷新 |
+
+### 响应字段
+
+- `success`
+- `chatroomId`
+- `count`
+- `fromCache`
+- `updatedAt`
+- `members[].wxid`
+- `members[].displayName`
+- `members[].nickname`
+- `members[].remark`
+- `members[].alias`
+- `members[].groupNickname`
+- `members[].avatarUrl`
+- `members[].isOwner`
+- `members[].isFriend`
+- `members[].messageCount`
+
+**示例请求**
+
+```bash
+curl "http://127.0.0.1:5031/api/v1/group-members?chatroomId=xxx@chatroom"
+curl "http://127.0.0.1:5031/api/v1/group-members?chatroomId=xxx@chatroom&includeMessageCounts=1&forceRefresh=1"
+```
+
+**示例响应**
+
+```json
+{
+  "success": true,
+  "chatroomId": "xxx@chatroom",
+  "count": 2,
+  "fromCache": false,
+  "updatedAt": 1760000000000,
+  "members": [
+    {
+      "wxid": "wxid_member_a",
+      "displayName": "客户A",
+      "nickname": "阿甲",
+      "remark": "客户A",
+      "alias": "kehua",
+      "groupNickname": "甲方",
+      "avatarUrl": "https://example.com/a.jpg",
+      "isOwner": true,
+      "isFriend": true,
+      "messageCount": 128
+    },
+    {
+      "wxid": "wxid_member_b",
+      "displayName": "李四",
+      "nickname": "李四",
+      "remark": "",
+      "alias": "",
+      "groupNickname": "",
+      "avatarUrl": "",
+      "isOwner": false,
+      "isFriend": false,
+      "messageCount": 0
+    }
+  ]
+}
+```
+
+说明：
+
+- `displayName` 是当前应用内的主展示名。
+- `groupNickname` 是成员在该群里的群昵称。
+- `remark` 是你对该联系人的备注。
+- `alias` 是微信号。
+- 当微信源数据里没有群昵称时，`groupNickname` 会为空。
 
 ---
 
-## 使用示例
+## 7. 朋友圈接口
+
+### 7.1 获取朋友圈时间线
+
+```http
+GET /api/v1/sns/timeline
+```
+
+参数：
+
+| 参数 | 类型 | 必填 | 说明 |
+| --- | --- | --- | --- |
+| `limit` | number | 否 | 返回数量，默认 20，范围 `1~200` |
+| `offset` | number | 否 | 偏移量，默认 0 |
+| `usernames` | string | 否 | 发布者过滤，逗号分隔，如 `wxid_a,wxid_b` |
+| `keyword` | string | 否 | 关键词过滤（正文） |
+| `start` | string | 否 | 开始时间，支持 `YYYYMMDD` 或秒/毫秒时间戳 |
+| `end` | string | 否 | 结束时间，支持 `YYYYMMDD` 或秒/毫秒时间戳 |
+| `media` | number | 否 | 是否返回可直接访问的媒体地址，默认 `1` |
+| `replace` | number | 否 | `media=1` 时，是否用解析地址覆盖 `media.url/thumb`，默认 `1` |
+| `inline` | number | 否 | `media=1` 时，是否内联返回 `data:` URL，默认 `0` |
+
+示例：
+
+```bash
+curl "http://127.0.0.1:5031/api/v1/sns/timeline?limit=5"
+curl "http://127.0.0.1:5031/api/v1/sns/timeline?usernames=wxid_a,wxid_b&keyword=旅行"
+curl "http://127.0.0.1:5031/api/v1/sns/timeline?limit=3&media=1&replace=1"
+curl "http://127.0.0.1:5031/api/v1/sns/timeline?limit=3&media=1&inline=1"
+```
+
+媒体字段说明（`media=1`）：
+
+- `media[].url/thumb`：你应该优先直接使用的字段。
+- `replace=1`（默认）时，`media[].url/thumb` 会直接被替换成可访问地址，等价于 `resolvedUrl/resolvedThumbUrl`。
+- `replace=0` 时，`media[].url/thumb` 仍保留微信原始地址；这时再结合下面的 `raw/proxy/resolved` 字段自己决定用哪一个。
+- `media[].rawUrl/rawThumb`：原始朋友圈地址
+- `media[].proxyUrl/proxyThumbUrl`：可直接访问的代理地址
+- `media[].resolvedUrl/resolvedThumbUrl`：最终可用地址（`inline=1` 时可能是 `data:` URL）
+- `media[].token/key/encIdx`：微信源数据里的访问/解密参数。通常不需要你自己处理；如果你手动调用 `/api/v1/sns/media/proxy`，把当前条目的 `url` 和 `key` 原样传回即可。
+- `media[].livePhoto`：实况图的视频部分。外层 `media[].url/thumb` 仍是封面图，`livePhoto` 内部会再提供一组自己的 `url/thumb/raw*/proxy*/resolved*` 字段。
+- `media=0` 时，不会补充 `raw*/proxy*/resolved*`，接口只返回原始 `url/thumb` 以及源字段（如 `key/token/encIdx`）。
+
+### 7.2 获取朋友圈发布者
+
+```http
+GET /api/v1/sns/usernames
+```
+
+### 7.3 获取朋友圈导出统计
+
+```http
+GET /api/v1/sns/export/stats
+```
+
+参数：
+
+| 参数 | 类型 | 必填 | 说明 |
+| --- | --- | --- | --- |
+| `fast` | number | 否 | `1` 使用快速统计（优先缓存） |
+
+### 7.4 朋友圈媒体代理
+
+```http
+GET /api/v1/sns/media/proxy
+```
+
+参数：
+
+| 参数 | 类型 | 必填 | 说明 |
+| --- | --- | --- | --- |
+| `url` | string | 是 | 媒体原始 URL |
+| `key` | string/number | 否 | 解密 key（部分资源需要） |
+
+### 7.5 导出朋友圈
+
+```http
+POST /api/v1/sns/export
+Content-Type: application/json
+```
+
+Body 示例：
+
+```json
+{
+  "outputDir": "C:\\Users\\Alice\\Desktop\\sns-export",
+  "format": "json",
+  "usernames": "wxid_a,wxid_b",
+  "keyword": "旅行",
+  "exportMedia": true,
+  "exportImages": true,
+  "exportLivePhotos": true,
+  "exportVideos": true,
+  "start": "20250101",
+  "end": "20251231"
+}
+```
+
+`format` 支持：`json`、`html`、`arkmejson`（兼容写法：`arkme-json`）。
+
+### 7.6 朋友圈防删开关
+
+```http
+GET  /api/v1/sns/block-delete/status
+POST /api/v1/sns/block-delete/install
+POST /api/v1/sns/block-delete/uninstall
+```
+
+### 7.7 删除单条朋友圈
+
+```http
+DELETE /api/v1/sns/post/{postId}
+```
+
+---
+
+## 8. 访问导出媒体
+
+> 当使用 POST 时，请将参数放在 JSON Body 中（Content-Type: application/json）
+
+通过消息接口启用 `media=1` 后，接口会先把图片、语音、视频、表情导出到本地缓存目录，再返回可访问的 HTTP 地址。
+
+**请求**
+
+```http
+GET /api/v1/media/{relativePath}
+```
+
+### 示例
+
+```bash
+curl "http://127.0.0.1:5031/api/v1/media/xxx@chatroom/images/abc123.jpg"
+curl "http://127.0.0.1:5031/api/v1/media/xxx@chatroom/voices/voice_100.wav"
+curl "http://127.0.0.1:5031/api/v1/media/xxx@chatroom/videos/video_200.mp4"
+curl "http://127.0.0.1:5031/api/v1/media/xxx@chatroom/emojis/emoji_300.gif"
+```
+
+### 支持的 Content-Type
+
+| 扩展名 | Content-Type |
+| --- | --- |
+| `.png` | `image/png` |
+| `.jpg` / `.jpeg` | `image/jpeg` |
+| `.gif` | `image/gif` |
+| `.webp` | `image/webp` |
+| `.wav` | `audio/wav` |
+| `.mp3` | `audio/mpeg` |
+| `.mp4` | `video/mp4` |
+
+常见错误响应：
+
+```json
+{
+  "error": "Media not found"
+}
+```
+
+---
+
+## 9. 使用示例
 
 ### PowerShell
 
 ```powershell
-# 健康检查
-Invoke-RestMethod http://127.0.0.1:5031/health
+$headers = @{ "Authorization" = "Bearer YOUR_TOKEN" }
+$body = @{ talker = "wxid_xxx"; limit = 10 } | ConvertTo-Json
 
-# 获取会话列表
-Invoke-RestMethod http://127.0.0.1:5031/api/v1/sessions
-
-# 获取消息
-Invoke-RestMethod "http://127.0.0.1:5031/api/v1/messages?talker=wxid_xxx&limit=10"
-
-# 获取 ChatLab 格式
-Invoke-RestMethod "http://127.0.0.1:5031/api/v1/messages?talker=wxid_xxx&chatlab=1" | ConvertTo-Json -Depth 10
+Invoke-RestMethod -Uri "http://127.0.0.1:5031/api/v1/messages" -Method POST -Headers $headers -Body $body -ContentType "application/json"
 ```
 
 ### cURL
 
 ```bash
-# 健康检查
-curl http://127.0.0.1:5031/health
+# GET 带 Token Header
+curl -H "Authorization: Bearer YOUR_TOKEN" "http://127.0.0.1:5031/api/v1/messages?talker=wxid_xxx"
 
-# 获取会话列表
-curl http://127.0.0.1:5031/api/v1/sessions
-
-# 获取消息（ChatLab 格式）
-curl "http://127.0.0.1:5031/api/v1/messages?talker=wxid_xxx&chatlab=1"
+# POST 带 JSON Body
+curl -X POST http://127.0.0.1:5031/api/v1/messages \
+  -H "Authorization: Bearer YOUR_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{"talker": "xxx@chatroom", "chatlab": true}'
 ```
 
 ### Python
@@ -352,40 +622,29 @@ curl "http://127.0.0.1:5031/api/v1/messages?talker=wxid_xxx&chatlab=1"
 import requests
 
 BASE_URL = "http://127.0.0.1:5031"
+headers = {"Authorization": "Bearer YOUR_TOKEN", "Content-Type": "application/json"}
 
-# 获取会话列表
-sessions = requests.get(f"{BASE_URL}/api/v1/sessions").json()
-print(sessions)
+# POST 方式获取消息
+messages = requests.post(
+    f"{BASE_URL}/api/v1/messages", 
+    json={"talker": "xxx@chatroom", "limit": 50}, 
+    headers=headers
+).json()
 
-# 获取消息
-messages = requests.get(f"{BASE_URL}/api/v1/messages", params={
-    "talker": "wxid_xxx",
-    "limit": 100,
-    "chatlab": 1
-}).json()
-print(messages)
-```
-
-### JavaScript / Node.js
-
-```javascript
-const BASE_URL = "http://127.0.0.1:5031";
-
-// 获取会话列表
-const sessions = await fetch(`${BASE_URL}/api/v1/sessions`).then(r => r.json());
-console.log(sessions);
-
-// 获取消息（ChatLab 格式）
-const messages = await fetch(`${BASE_URL}/api/v1/messages?talker=wxid_xxx&chatlab=1`)
-  .then(r => r.json());
-console.log(messages);
+# GET 方式获取群成员
+members = requests.get(
+    f"{BASE_URL}/api/v1/group-members",
+    params={"chatroomId": "xxx@chatroom", "includeMessageCounts": 1},
+    headers=headers
+).json()
 ```
 
 ---
 
-## 注意事项
+## 10. 注意事项
 
-1. API 仅监听本地地址 `127.0.0.1`，不对外网开放
-2. 需要先连接数据库才能查询数据
-3. 时间参数格式为 `YYYYMMDD`（如 20260205）
-4. 支持 CORS，可从浏览器前端直接调用
+1. API 仅监听本机 `127.0.0.1`，不对外网开放。
+2. 使用前需要先在 WeFlow 中完成数据库连接。
+3. `start` 和 `end` 支持 `YYYYMMDD` 与时间戳；纯 `YYYYMMDD` 的 `end` 会扩展到当天 `23:59:59`。
+4. 群成员的 `groupNickname` 依赖微信源数据；源数据缺失时不会自动补出。
+5. 媒体访问链接只有在对应消息已经通过 `media=1` 导出后才可访问。

electron/exportWorker.ts

@@ -0,0 +1,56 @@
+import { parentPort, workerData } from 'worker_threads'
+import type { ExportOptions } from './services/exportService'
+
+interface ExportWorkerConfig {
+  sessionIds: string[]
+  outputDir: string
+  options: ExportOptions
+  resourcesPath?: string
+  userDataPath?: string
+  logEnabled?: boolean
+}
+
+const config = workerData as ExportWorkerConfig
+process.env.WEFLOW_WORKER = '1'
+if (config.resourcesPath) {
+  process.env.WCDB_RESOURCES_PATH = config.resourcesPath
+}
+if (config.userDataPath) {
+  process.env.WEFLOW_USER_DATA_PATH = config.userDataPath
+  process.env.WEFLOW_CONFIG_CWD = config.userDataPath
+}
+process.env.WEFLOW_PROJECT_NAME = process.env.WEFLOW_PROJECT_NAME || 'WeFlow'
+
+async function run() {
+  const [{ wcdbService }, { exportService }] = await Promise.all([
+    import('./services/wcdbService'),
+    import('./services/exportService')
+  ])
+
+  wcdbService.setPaths(config.resourcesPath || '', config.userDataPath || '')
+  wcdbService.setLogEnabled(config.logEnabled === true)
+
+  const result = await exportService.exportSessions(
+    Array.isArray(config.sessionIds) ? config.sessionIds : [],
+    String(config.outputDir || ''),
+    config.options || { format: 'json' },
+    (progress) => {
+      parentPort?.postMessage({
+        type: 'export:progress',
+        data: progress
+      })
+    }
+  )
+
+  parentPort?.postMessage({
+    type: 'export:result',
+    data: result
+  })
+}
+
+run().catch((error) => {
+  parentPort?.postMessage({
+    type: 'export:error',
+    error: String(error)
+  })
+})

electron/main.ts

@@ -1,6 +1,7 @@
 import './preload-env'
-import { app, BrowserWindow, ipcMain, nativeTheme, session } from 'electron'
+import { app, BrowserWindow, ipcMain, nativeTheme, session, Tray, Menu, nativeImage } from 'electron'
 import { Worker } from 'worker_threads'
+import { randomUUID } from 'crypto'
 import { join, dirname } from 'path'
 import { autoUpdater } from 'electron-updater'
 import { readFile, writeFile, mkdir, rm, readdir } from 'fs/promises'
@@ -16,6 +17,7 @@ import { groupAnalyticsService } from './services/groupAnalyticsService'
 import { annualReportService } from './services/annualReportService'
 import { exportService, ExportOptions, ExportProgress } from './services/exportService'
 import { KeyService } from './services/keyService'
+import { KeyServiceLinux } from './services/keyServiceLinux'
 import { KeyServiceMac } from './services/keyServiceMac'
 import { voiceTranscribeService } from './services/voiceTranscribeService'
 import { videoService } from './services/videoService'
@@ -27,17 +29,260 @@ import { cloudControlService } from './services/cloudControlService'
 
 import { destroyNotificationWindow, registerNotificationHandlers, showNotification } from './windows/notificationWindow'
 import { httpService } from './services/httpService'
-
+import { messagePushService } from './services/messagePushService'
+import { bizService } from './services/bizService'
 
 // 配置自动更新
 autoUpdater.autoDownload = false
 autoUpdater.autoInstallOnAppQuit = true
 autoUpdater.disableDifferentialDownload = true  // 禁用差分更新，强制全量下载
+// 更新通道策略：
+// - 稳定版（如 4.3.0）默认走 latest
+// - 预览版（如 0.26.2）默认走 preview（0.年.当年发布序号）
+// - 开发版（如 26.4.5）默认走 dev（年.月.日）
+// - 用户可在设置页切换稳定/预览/开发，切换后即时生效
+// 同时区分 Windows x64 / arm64，避免更新清单互相覆盖。
+const appVersion = app.getVersion()
+const inferUpdateTrackFromVersion = (version: string): 'stable' | 'preview' | 'dev' => {
+  const normalized = String(version || '').trim().replace(/^v/i, '')
+  if (/^0\.\d{2}\.\d+$/i.test(normalized)) return 'preview'
+  if (/^\d{2}\.\d{1,2}\.\d{1,2}$/i.test(normalized)) return 'dev'
+  // 兼容旧版命名（如 4.3.0-preview.26.1 / 4.3.0-dev.26.3.4）
+  if (/-preview\.\d+\.\d+$/i.test(normalized)) return 'preview'
+  if (/-dev\.\d+\.\d+\.\d+$/i.test(normalized)) return 'dev'
+  // 兼容 alpha/beta/rc 预发布
+  if (/(alpha|beta|rc)/i.test(normalized)) return 'dev'
+  return 'stable'
+}
+
+const defaultUpdateTrack: 'stable' | 'preview' | 'dev' = (() => {
+  const inferred = inferUpdateTrackFromVersion(appVersion)
+  if (inferred === 'preview' || inferred === 'dev') return inferred
+  return 'stable'
+})()
+let configService: ConfigService | null = null
+
+const normalizeUpdateTrack = (raw: unknown): 'stable' | 'preview' | 'dev' | null => {
+  if (raw === 'stable' || raw === 'preview' || raw === 'dev') return raw
+  return null
+}
+
+const getEffectiveUpdateTrack = (): 'stable' | 'preview' | 'dev' => {
+  const configuredTrack = normalizeUpdateTrack(configService?.get('updateChannel'))
+  return configuredTrack || defaultUpdateTrack
+}
+
+const isRemoteVersionNewer = (latestVersion: string, currentVersion: string): boolean => {
+  const latest = String(latestVersion || '').trim()
+  const current = String(currentVersion || '').trim()
+  if (!latest || !current) return false
+
+  const parseVersion = (version: string) => {
+    const normalized = version.replace(/^v/i, '')
+    const [main, pre = ''] = normalized.split('-', 2)
+    const core = main.split('.').map((segment) => Number.parseInt(segment, 10) || 0)
+    const prerelease = pre ? pre.split('.').map((segment) => /^\d+$/.test(segment) ? Number.parseInt(segment, 10) : segment) : []
+    return { core, prerelease }
+  }
+
+  const compareParsedVersion = (a: ReturnType<typeof parseVersion>, b: ReturnType<typeof parseVersion>): number => {
+    const maxLen = Math.max(a.core.length, b.core.length)
+    for (let i = 0; i < maxLen; i += 1) {
+      const left = a.core[i] || 0
+      const right = b.core[i] || 0
+      if (left > right) return 1
+      if (left < right) return -1
+    }
+
+    const aPre = a.prerelease
+    const bPre = b.prerelease
+    if (aPre.length === 0 && bPre.length === 0) return 0
+    if (aPre.length === 0) return 1
+    if (bPre.length === 0) return -1
+
+    const preMaxLen = Math.max(aPre.length, bPre.length)
+    for (let i = 0; i < preMaxLen; i += 1) {
+      const left = aPre[i]
+      const right = bPre[i]
+      if (left === undefined) return -1
+      if (right === undefined) return 1
+      if (left === right) continue
+
+      const leftNum = typeof left === 'number'
+      const rightNum = typeof right === 'number'
+      if (leftNum && rightNum) return left > right ? 1 : -1
+      if (leftNum) return -1
+      if (rightNum) return 1
+      return String(left) > String(right) ? 1 : -1
+    }
+
+    return 0
+  }
+
+  try {
+    return autoUpdater.currentVersion.compare(latest) < 0
+  } catch {
+    return compareParsedVersion(parseVersion(latest), parseVersion(current)) > 0
+  }
+}
+
+const shouldOfferUpdateForTrack = (latestVersion: string, currentVersion: string): boolean => {
+  if (isRemoteVersionNewer(latestVersion, currentVersion)) return true
+  const effectiveTrack = getEffectiveUpdateTrack()
+  const currentTrack = inferUpdateTrackFromVersion(currentVersion)
+  // 切换通道后，目标通道最新版本与当前版本不同即提示更新（即使是降级）
+  if (effectiveTrack !== currentTrack && latestVersion !== currentVersion) return true
+  return false
+}
+
+let lastAppliedUpdaterChannel: string | null = null
+const resetUpdaterProviderCache = () => {
+  const updater = autoUpdater as any
+  // electron-updater 会缓存 provider；切换 channel 后需清理缓存，避免仍请求旧通道
+  for (const key of ['clientPromise', '_clientPromise', 'updateInfoAndProvider']) {
+    if (Object.prototype.hasOwnProperty.call(updater, key)) {
+      updater[key] = null
+    }
+  }
+}
+
+const applyAutoUpdateChannel = (reason: 'startup' | 'settings' = 'startup') => {
+  const track = getEffectiveUpdateTrack()
+  const currentTrack = inferUpdateTrackFromVersion(appVersion)
+  const baseUpdateChannel = track === 'stable' ? 'latest' : track
+  const nextUpdaterChannel =
+    process.platform === 'win32' && process.arch === 'arm64'
+      ? `${baseUpdateChannel}-arm64`
+      : baseUpdateChannel
+  if (lastAppliedUpdaterChannel && lastAppliedUpdaterChannel !== nextUpdaterChannel) {
+    resetUpdaterProviderCache()
+  }
+  autoUpdater.allowPrerelease = track !== 'stable'
+  // 只要用户当前选择的目标通道与当前安装版本所属通道不同，就允许跨通道更新（含降级）
+  autoUpdater.allowDowngrade = track !== currentTrack
+  autoUpdater.channel = nextUpdaterChannel
+  lastAppliedUpdaterChannel = nextUpdaterChannel
+  console.log(`[Update](${reason}) 当前版本 ${appVersion}，当前轨道: ${currentTrack}，渠道偏好: ${track}，更新通道: ${autoUpdater.channel}，allowDowngrade=${autoUpdater.allowDowngrade}`)
+}
+
+applyAutoUpdateChannel('startup')
 const AUTO_UPDATE_ENABLED =
   process.env.AUTO_UPDATE_ENABLED === 'true' ||
   process.env.AUTO_UPDATE_ENABLED === '1' ||
   (process.env.AUTO_UPDATE_ENABLED == null && !process.env.VITE_DEV_SERVER_URL)
 
+const getLaunchAtStartupUnsupportedReason = (): string | null => {
+  if (process.platform !== 'win32' && process.platform !== 'darwin') {
+    return '当前平台暂不支持开机自启动'
+  }
+  if (!app.isPackaged) {
+    return '仅安装后的 Windows / macOS 版本支持开机自启动'
+  }
+  return null
+}
+
+const isLaunchAtStartupSupported = (): boolean => getLaunchAtStartupUnsupportedReason() == null
+
+const getStoredLaunchAtStartupPreference = (): boolean | undefined => {
+  const value = configService?.get('launchAtStartup')
+  return typeof value === 'boolean' ? value : undefined
+}
+
+const getSystemLaunchAtStartup = (): boolean => {
+  if (!isLaunchAtStartupSupported()) return false
+  try {
+    return app.getLoginItemSettings().openAtLogin === true
+  } catch (error) {
+    console.error('[WeFlow] 读取开机自启动状态失败:', error)
+    return false
+  }
+}
+
+const buildLaunchAtStartupSettings = (enabled: boolean): Parameters<typeof app.setLoginItemSettings>[0] =>
+  process.platform === 'win32'
+    ? { openAtLogin: enabled, path: process.execPath }
+    : { openAtLogin: enabled }
+
+const setSystemLaunchAtStartup = (enabled: boolean): { success: boolean; enabled: boolean; error?: string } => {
+  try {
+    app.setLoginItemSettings(buildLaunchAtStartupSettings(enabled))
+    const effectiveEnabled = app.getLoginItemSettings().openAtLogin === true
+    if (effectiveEnabled !== enabled) {
+      return {
+        success: false,
+        enabled: effectiveEnabled,
+        error: '系统未接受该开机自启动设置'
+      }
+    }
+    return { success: true, enabled: effectiveEnabled }
+  } catch (error) {
+    return {
+      success: false,
+      enabled: getSystemLaunchAtStartup(),
+      error: `设置开机自启动失败: ${String((error as Error)?.message || error)}`
+    }
+  }
+}
+
+const getLaunchAtStartupStatus = (): { enabled: boolean; supported: boolean; reason?: string } => {
+  const unsupportedReason = getLaunchAtStartupUnsupportedReason()
+  if (unsupportedReason) {
+    return {
+      enabled: getStoredLaunchAtStartupPreference() === true,
+      supported: false,
+      reason: unsupportedReason
+    }
+  }
+  return {
+    enabled: getSystemLaunchAtStartup(),
+    supported: true
+  }
+}
+
+const applyLaunchAtStartupPreference = (
+  enabled: boolean
+): { success: boolean; enabled: boolean; supported: boolean; reason?: string; error?: string } => {
+  const unsupportedReason = getLaunchAtStartupUnsupportedReason()
+  if (unsupportedReason) {
+    return {
+      success: false,
+      enabled: getStoredLaunchAtStartupPreference() === true,
+      supported: false,
+      reason: unsupportedReason
+    }
+  }
+
+  const result = setSystemLaunchAtStartup(enabled)
+  configService?.set('launchAtStartup', result.enabled)
+  return {
+    ...result,
+    supported: true
+  }
+}
+
+const syncLaunchAtStartupPreference = () => {
+  if (!configService) return
+
+  const unsupportedReason = getLaunchAtStartupUnsupportedReason()
+  if (unsupportedReason) return
+
+  const storedPreference = getStoredLaunchAtStartupPreference()
+  const systemEnabled = getSystemLaunchAtStartup()
+
+  if (typeof storedPreference !== 'boolean') {
+    configService.set('launchAtStartup', systemEnabled)
+    return
+  }
+
+  if (storedPreference === systemEnabled) return
+
+  const result = setSystemLaunchAtStartup(storedPreference)
+  configService.set('launchAtStartup', result.enabled)
+  if (!result.success && result.error) {
+    console.error('[WeFlow] 同步开机自启动设置失败:', result.error)
+  }
+}
+
 // 使用白名单过滤 PATH，避免被第三方目录中的旧版 VC++ 运行库劫持。
 // 仅保留系统目录（Windows/System32/SysWOW64）和应用自身目录（可执行目录、resources）。
 function sanitizePathEnv() {
@@ -80,7 +325,6 @@ function sanitizePathEnv() {
 sanitizePathEnv()
 
 // 单例服务
-let configService: ConfigService | null = null
 
 // 协议窗口实例
 let agreementWindow: BrowserWindow | null = null
@@ -89,19 +333,161 @@ let onboardingWindow: BrowserWindow | null = null
 let splashWindow: BrowserWindow | null = null
 const sessionChatWindows = new Map<string, BrowserWindow>()
 const sessionChatWindowSources = new Map<string, 'chat' | 'export'>()
-const keyService = process.platform === 'darwin' 
-  ? new KeyServiceMac() as any 
-  : new KeyService()
+
+let keyService: any
+if (process.platform === 'darwin') {
+  keyService = new KeyServiceMac()
+} else if (process.platform === 'linux') {
+  // const { KeyServiceLinux } = require('./services/keyServiceLinux')
+  // keyService = new KeyServiceLinux()
+
+  import('./services/keyServiceLinux').then(({ KeyServiceLinux }) => {
+    keyService = new KeyServiceLinux();
+  });
+
+} else {
+  keyService = new KeyService()
+}
 
 let mainWindowReady = false
 let shouldShowMain = true
 let isAppQuitting = false
+let tray: Tray | null = null
+let isClosePromptVisible = false
+const chatHistoryPayloadStore = new Map<string, { sessionId: string; title?: string; recordList: any[] }>()
+
+type WindowCloseBehavior = 'ask' | 'tray' | 'quit'
 
 // 更新下载状态管理（Issue #294 修复）
 let isDownloadInProgress = false
 let downloadProgressHandler: ((progress: any) => void) | null = null
 let downloadedHandler: (() => void) | null = null
 
+const normalizeReleaseNotes = (rawReleaseNotes: unknown): string => {
+  const merged = (() => {
+    if (typeof rawReleaseNotes === 'string') {
+      return rawReleaseNotes
+    }
+    if (Array.isArray(rawReleaseNotes)) {
+      return rawReleaseNotes
+        .map((item) => {
+          if (!item || typeof item !== 'object') return ''
+          const note = (item as { note?: unknown }).note
+          return typeof note === 'string' ? note : ''
+        })
+        .filter(Boolean)
+        .join('\n\n')
+    }
+    return ''
+  })()
+
+  if (!merged.trim()) return ''
+
+  const normalizeHeadingText = (raw: string): string => {
+    return raw
+      .replace(/<[^>]*>/g, ' ')
+      .replace(/&nbsp;/gi, ' ')
+      .replace(/&amp;/gi, '&')
+      .replace(/&lt;/gi, '<')
+      .replace(/&gt;/gi, '>')
+      .replace(/&quot;/gi, '"')
+      .replace(/&#39;/gi, '\'')
+      .replace(/&#x27;/gi, '\'')
+      .toLowerCase()
+      .replace(/[：:]/g, '')
+      .replace(/\s+/g, '')
+      .trim()
+  }
+
+  const shouldStripReleaseSection = (headingRaw: string): boolean => {
+    const heading = normalizeHeadingText(headingRaw)
+    if (!heading) return false
+    if (heading.startsWith('下载') || heading.startsWith('download')) return true
+
+    if ((heading.includes('macos') || heading.startsWith('mac')) && heading.includes('安装提示')) return true
+    return false
+  }
+
+  // 兼容 electron-updater 直接返回 HTML 的场景（含 dir/anchor 等标签嵌套）
+  const removeDownloadSectionFromHtml = (input: string): string => {
+    const headingPattern = /<h([1-6])\b[^>]*>([\s\S]*?)<\/h\1>/gi
+    const headings: Array<{ start: number; end: number; headingText: string }> = []
+    let match: RegExpExecArray | null
+
+    while ((match = headingPattern.exec(input)) !== null) {
+      const full = match[0]
+      headings.push({
+        start: match.index,
+        end: match.index + full.length,
+        headingText: match[2] || ''
+      })
+    }
+
+    if (headings.length === 0) return input
+
+    const rangesToRemove: Array<{ start: number; end: number }> = []
+    for (let i = 0; i < headings.length; i += 1) {
+      const current = headings[i]
+      if (!shouldStripReleaseSection(current.headingText)) continue
+
+      const nextStart = i + 1 < headings.length ? headings[i + 1].start : input.length
+      rangesToRemove.push({ start: current.start, end: nextStart })
+    }
+
+    if (rangesToRemove.length === 0) return input
+
+    let output = ''
+    let cursor = 0
+    for (const range of rangesToRemove) {
+      output += input.slice(cursor, range.start)
+      cursor = range.end
+    }
+    output += input.slice(cursor)
+    return output
+  }
+
+  // 兼容 Markdown 场景（Action 最终 release note 模板）
+  const removeDownloadSectionFromMarkdown = (input: string): string => {
+    const lines = input.split(/\r?\n/)
+    const output: string[] = []
+    let skipSection = false
+
+    for (const line of lines) {
+      const headingMatch = line.match(/^\s*#{1,6}\s*(.+?)\s*$/)
+      if (headingMatch) {
+        if (shouldStripReleaseSection(headingMatch[1])) {
+          skipSection = true
+          continue
+        }
+        if (skipSection) {
+          skipSection = false
+        }
+      }
+      if (!skipSection) {
+        output.push(line)
+      }
+    }
+
+    return output.join('\n')
+  }
+
+  const cleaned = removeDownloadSectionFromMarkdown(removeDownloadSectionFromHtml(merged))
+    // 兜底：即使没有匹配到标题，也不在弹窗展示 macOS 隔离标记清理命令
+    .replace(/^[ \t>*-]*`?\s*xattr\s+-[a-z]*d[a-z]*\s+com\.apple\.quarantine[^\n]*`?\s*$/gim, '')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim()
+
+  return cleaned
+}
+
+const getDialogReleaseNotes = (rawReleaseNotes: unknown): string => {
+  const track = getEffectiveUpdateTrack()
+  if (track !== 'stable') {
+    return '修复了一些已知问题'
+  }
+  return normalizeReleaseNotes(rawReleaseNotes)
+}
+
 type AnnualReportYearsLoadStrategy = 'cache' | 'native' | 'hybrid'
 type AnnualReportYearsLoadPhase = 'cache' | 'native' | 'scan' | 'done'
 
@@ -252,15 +638,34 @@ const setupCustomTitleBarWindow = (win: BrowserWindow): void => {
   win.webContents.on('did-finish-load', emitMaximizeState)
 }
 
+const getWindowCloseBehavior = (): WindowCloseBehavior => {
+  const behavior = configService?.get('windowCloseBehavior')
+  return behavior === 'tray' || behavior === 'quit' ? behavior : 'ask'
+}
+
+const requestMainWindowCloseConfirmation = (win: BrowserWindow): void => {
+  if (isClosePromptVisible) return
+  isClosePromptVisible = true
+  win.webContents.send('window:confirmCloseRequested', {
+    canMinimizeToTray: Boolean(tray)
+  })
+}
+
 function createWindow(options: { autoShow?: boolean } = {}) {
   // 获取图标路径 - 打包后在 resources 目录
   const { autoShow = true } = options
+  let iconName = 'icon.ico';
+  if (process.platform === 'linux') {
+    iconName = 'icon.png';
+  } else if (process.platform === 'darwin') {
+    iconName = 'icon.icns';
+  }
+
   const isDev = !!process.env.VITE_DEV_SERVER_URL
+
   const iconPath = isDev
-    ? join(__dirname, '../public/icon.ico')
-    : (process.platform === 'darwin' 
-        ? join(process.resourcesPath, 'icon.icns')
-        : join(process.resourcesPath, 'icon.ico'))
+      ? join(__dirname, `../public/${iconName}`)
+      : join(process.resourcesPath, iconName);
 
   const win = new BrowserWindow({
     width: 1400,
@@ -352,14 +757,33 @@ function createWindow(options: { autoShow?: boolean } = {}) {
     callback(false)
   })
 
+  win.on('close', (e) => {
+    if (isAppQuitting || win !== mainWindow) return
+    e.preventDefault()
+    const closeBehavior = getWindowCloseBehavior()
+
+    if (closeBehavior === 'quit') {
+      isAppQuitting = true
+      app.quit()
+      return
+    }
+
+    if (closeBehavior === 'tray' && tray) {
+      win.hide()
+      return
+    }
+
+    requestMainWindowCloseConfirmation(win)
+  })
+
   win.on('closed', () => {
     if (mainWindow !== win) return
 
     mainWindow = null
     mainWindowReady = false
+    isClosePromptVisible = false
 
     if (process.platform !== 'darwin' && !isAppQuitting) {
-      // 隐藏通知窗也是 BrowserWindow，必须销毁，否则会阻止应用退出。
       destroyNotificationWindow()
       if (BrowserWindow.getAllWindows().length === 0) {
         app.quit()
@@ -713,6 +1137,14 @@ function createImageViewerWindow(imagePath: string, liveVideoPath?: string) {
  * 创建独立的聊天记录窗口
  */
 function createChatHistoryWindow(sessionId: string, messageId: number) {
+  return createChatHistoryRouteWindow(`/chat-history/${sessionId}/${messageId}`)
+}
+
+function createChatHistoryPayloadWindow(payloadId: string) {
+  return createChatHistoryRouteWindow(`/chat-history-inline/${payloadId}`)
+}
+
+function createChatHistoryRouteWindow(route: string) {
   const isDev = !!process.env.VITE_DEV_SERVER_URL
   const iconPath = isDev
     ? join(__dirname, '../public/icon.ico')
@@ -747,7 +1179,7 @@ function createChatHistoryWindow(sessionId: string, messageId: number) {
   })
 
   if (process.env.VITE_DEV_SERVER_URL) {
-    win.loadURL(`${process.env.VITE_DEV_SERVER_URL}#/chat-history/${sessionId}/${messageId}`)
+    win.loadURL(`${process.env.VITE_DEV_SERVER_URL}#${route}`)
 
     win.webContents.on('before-input-event', (event, input) => {
       if (input.key === 'F12' || (input.control && input.shift && input.key === 'I')) {
@@ -761,7 +1193,7 @@ function createChatHistoryWindow(sessionId: string, messageId: number) {
     })
   } else {
     win.loadFile(join(__dirname, '../dist/index.html'), {
-      hash: `/chat-history/${sessionId}/${messageId}`
+      hash: route
     })
   }
 
@@ -923,17 +1355,35 @@ const removeMatchedEntriesInDir = async (
 // 注册 IPC 处理器
 function registerIpcHandlers() {
   registerNotificationHandlers()
+  bizService.registerHandlers()
   // 配置相关
   ipcMain.handle('config:get', async (_, key: string) => {
     return configService?.get(key as any)
   })
 
   ipcMain.handle('config:set', async (_, key: string, value: any) => {
-    return configService?.set(key as any, value)
+    let result: unknown
+    if (key === 'launchAtStartup') {
+      result = applyLaunchAtStartupPreference(value === true)
+    } else {
+      result = configService?.set(key as any, value)
+    }
+    if (key === 'updateChannel') {
+      applyAutoUpdateChannel('settings')
+    }
+    void messagePushService.handleConfigChanged(key)
+    return result
   })
 
   ipcMain.handle('config:clear', async () => {
+    if (isLaunchAtStartupSupported() && getSystemLaunchAtStartup()) {
+      const result = setSystemLaunchAtStartup(false)
+      if (!result.success && result.error) {
+        console.error('[WeFlow] 清空配置时关闭开机自启动失败:', result.error)
+      }
+    }
     configService?.clear()
+    messagePushService.handleConfigCleared()
     return true
   })
 
@@ -974,6 +1424,21 @@ function registerIpcHandlers() {
     return app.getVersion()
   })
 
+  ipcMain.handle('app:getLaunchAtStartupStatus', async () => {
+    return getLaunchAtStartupStatus()
+  })
+
+  ipcMain.handle('app:setLaunchAtStartup', async (_, enabled: boolean) => {
+    return applyLaunchAtStartupPreference(enabled === true)
+  })
+
+  ipcMain.handle('app:checkWayland', async () => {
+    if (process.platform !== 'linux') return false;
+
+    const sessionType = process.env.XDG_SESSION_TYPE?.toLowerCase();
+    return Boolean(process.env.WAYLAND_DISPLAY || sessionType === 'wayland');
+  })
+
   ipcMain.handle('log:getPath', async () => {
     return join(app.getPath('userData'), 'logs', 'wcdb.log')
   })
@@ -1036,16 +1501,19 @@ function registerIpcHandlers() {
     if (!AUTO_UPDATE_ENABLED) {
       return { hasUpdate: false }
     }
+    // 每次主动检查前重新应用一次通道配置，确保使用最新选择的更新通道。
+    applyAutoUpdateChannel('settings')
     try {
       const result = await autoUpdater.checkForUpdates()
       if (result && result.updateInfo) {
         const currentVersion = app.getVersion()
         const latestVersion = result.updateInfo.version
-        if (latestVersion !== currentVersion) {
+        if (shouldOfferUpdateForTrack(latestVersion, currentVersion)) {
           return {
             hasUpdate: true,
             version: latestVersion,
-            releaseNotes: result.updateInfo.releaseNotes as string || ''
+            releaseNotes: getDialogReleaseNotes(result.updateInfo.releaseNotes),
+            minimumVersion: (result.updateInfo as any).minimumVersion
           }
         }
       }
@@ -1103,7 +1571,7 @@ function registerIpcHandlers() {
     try {
       console.log('[Update] 开始下载更新...')
       await autoUpdater.downloadUpdate()
-    } catch (error) {
+    } catch (error: any) {
       console.error('[Update] 下载更新失败:', error)
       // 失败时清理状态和监听器
       isDownloadInProgress = false
@@ -1115,7 +1583,10 @@ function registerIpcHandlers() {
         autoUpdater.removeListener('update-downloaded', downloadedHandler)
         downloadedHandler = null
       }
-      throw error
+      
+      // 统一错误提示格式，避免出现 [object Object] 的 JSON 字符串
+      const errorMessage = error.message || (typeof error === 'string' ? error : JSON.stringify(error))
+      throw new Error(errorMessage)
     }
   })
 
@@ -1147,6 +1618,33 @@ function registerIpcHandlers() {
     BrowserWindow.fromWebContents(event.sender)?.close()
   })
 
+  ipcMain.handle('window:respondCloseConfirm', async (_event, action: 'tray' | 'quit' | 'cancel') => {
+    if (!mainWindow || mainWindow.isDestroyed()) {
+      isClosePromptVisible = false
+      return false
+    }
+
+    try {
+      if (action === 'tray') {
+        if (tray) {
+          mainWindow.hide()
+          return true
+        }
+        return false
+      }
+
+      if (action === 'quit') {
+        isAppQuitting = true
+        app.quit()
+        return true
+      }
+
+      return true
+    } finally {
+      isClosePromptVisible = false
+    }
+  })
+
   // 更新窗口控件主题色
   ipcMain.on('window:setTitleBarOverlay', (event, options: { symbolColor: string }) => {
     const win = BrowserWindow.fromWebContents(event.sender)
@@ -1174,6 +1672,23 @@ function registerIpcHandlers() {
     return true
   })
 
+  ipcMain.handle('window:openChatHistoryPayloadWindow', (_, payload: { sessionId: string; title?: string; recordList: any[] }) => {
+    const payloadId = randomUUID()
+    chatHistoryPayloadStore.set(payloadId, {
+      sessionId: String(payload?.sessionId || '').trim(),
+      title: String(payload?.title || '').trim() || '聊天记录',
+      recordList: Array.isArray(payload?.recordList) ? payload.recordList : []
+    })
+    createChatHistoryPayloadWindow(payloadId)
+    return true
+  })
+
+  ipcMain.handle('window:getChatHistoryPayload', (_, payloadId: string) => {
+    const payload = chatHistoryPayloadStore.get(String(payloadId || '').trim())
+    if (!payload) return { success: false, error: '聊天记录载荷不存在或已失效' }
+    return { success: true, payload }
+  })
+
   // 打开会话聊天窗口（同会话仅保留一个窗口并聚焦）
   ipcMain.handle('window:openSessionChatWindow', (_, sessionId: string, options?: OpenSessionChatWindowOptions) => {
     const win = createSessionChatWindow(sessionId, options)
@@ -1346,8 +1861,8 @@ function registerIpcHandlers() {
     return await chatService.resolveTransferDisplayNames(chatroomId, payerUsername, receiverUsername)
   })
 
-  ipcMain.handle('chat:getContacts', async () => {
-    return await chatService.getContacts()
+  ipcMain.handle('chat:getContacts', async (_, options?: { lite?: boolean }) => {
+    return await chatService.getContacts(options)
   })
 
   ipcMain.handle('chat:getCachedMessages', async (_, sessionId: string) => {
@@ -1548,7 +2063,7 @@ function registerIpcHandlers() {
 
   ipcMain.handle('chat:getVoiceTranscript', async (event, sessionId: string, msgId: string, createTime?: number) => {
     return chatService.getVoiceTranscript(sessionId, msgId, createTime, (text) => {
-      event.sender.send('chat:voiceTranscriptPartial', { msgId, text })
+      event.sender.send('chat:voiceTranscriptPartial', { sessionId, msgId, createTime, text })
     })
   })
 
@@ -1556,8 +2071,8 @@ function registerIpcHandlers() {
     return chatService.getMessageById(sessionId, localId)
   })
 
-  ipcMain.handle('chat:execQuery', async (_, kind: string, path: string | null, sql: string) => {
-    return chatService.execQuery(kind, path, sql)
+  ipcMain.handle('chat:searchMessages', async (_, keyword: string, sessionId?: string, limit?: number, offset?: number, beginTimestamp?: number, endTimestamp?: number) => {
+    return chatService.searchMessages(keyword, sessionId, limit, offset, beginTimestamp, endTimestamp)
   })
 
   ipcMain.handle('sns:getTimeline', async (_, limit: number, offset: number, usernames?: string[], keyword?: string, startTime?: number, endTime?: number) => {
@@ -1771,7 +2286,83 @@ function registerIpcHandlers() {
       }
     }
 
-    return exportService.exportSessions(sessionIds, outputDir, options, onProgress)
+    const runMainFallback = async (reason: string) => {
+      console.warn(`[fallback-export-main] ${reason}`)
+      return exportService.exportSessions(sessionIds, outputDir, options, onProgress)
+    }
+
+    const cfg = configService || new ConfigService()
+    configService = cfg
+    const logEnabled = cfg.get('logEnabled')
+    const resourcesPath = app.isPackaged
+      ? join(process.resourcesPath, 'resources')
+      : join(app.getAppPath(), 'resources')
+    const userDataPath = app.getPath('userData')
+    const workerPath = join(__dirname, 'exportWorker.js')
+
+    const runWorker = async () => {
+      return await new Promise<any>((resolve, reject) => {
+        const worker = new Worker(workerPath, {
+          workerData: {
+            sessionIds,
+            outputDir,
+            options,
+            resourcesPath,
+            userDataPath,
+            logEnabled
+          }
+        })
+
+        let settled = false
+        const finalizeResolve = (value: any) => {
+          if (settled) return
+          settled = true
+          worker.removeAllListeners()
+          void worker.terminate()
+          resolve(value)
+        }
+        const finalizeReject = (error: Error) => {
+          if (settled) return
+          settled = true
+          worker.removeAllListeners()
+          void worker.terminate()
+          reject(error)
+        }
+
+        worker.on('message', (msg: any) => {
+          if (msg && msg.type === 'export:progress') {
+            onProgress(msg.data as ExportProgress)
+            return
+          }
+          if (msg && msg.type === 'export:result') {
+            finalizeResolve(msg.data)
+            return
+          }
+          if (msg && msg.type === 'export:error') {
+            finalizeReject(new Error(String(msg.error || '导出 Worker 执行失败')))
+          }
+        })
+
+        worker.on('error', (error) => {
+          finalizeReject(error instanceof Error ? error : new Error(String(error)))
+        })
+
+        worker.on('exit', (code) => {
+          if (settled) return
+          if (code === 0) {
+            finalizeResolve({ success: false, successCount: 0, failCount: 0, error: '导出 Worker 未返回结果' })
+          } else {
+            finalizeReject(new Error(`导出 Worker 异常退出: ${code}`))
+          }
+        })
+      })
+    }
+
+    try {
+      return await runWorker()
+    } catch (error) {
+      return runMainFallback(error instanceof Error ? error.message : String(error))
+    }
   })
 
   ipcMain.handle('export:exportSession', async (_, sessionId: string, outputPath: string, options: ExportOptions) => {
@@ -1882,6 +2473,25 @@ function registerIpcHandlers() {
     return groupAnalyticsService.getGroupMediaStats(chatroomId, startTime, endTime)
   })
 
+  ipcMain.handle(
+    'groupAnalytics:getGroupMemberAnalytics',
+    async (_, chatroomId: string, memberUsername: string, startTime?: number, endTime?: number) => {
+      return groupAnalyticsService.getGroupMemberAnalytics(chatroomId, memberUsername, startTime, endTime)
+    }
+  )
+
+  ipcMain.handle(
+    'groupAnalytics:getGroupMemberMessages',
+    async (
+      _,
+      chatroomId: string,
+      memberUsername: string,
+      options?: { startTime?: number; endTime?: number; limit?: number; cursor?: number }
+    ) => {
+      return groupAnalyticsService.getGroupMemberMessages(chatroomId, memberUsername, options)
+    }
+  )
+
   ipcMain.handle('groupAnalytics:exportGroupMembers', async (_, chatroomId: string, outputPath: string) => {
     return groupAnalyticsService.exportGroupMembers(chatroomId, outputPath)
   })
@@ -2300,26 +2910,27 @@ function registerIpcHandlers() {
 
   // 密钥获取
   ipcMain.handle('key:autoGetDbKey', async (event) => {
-    return keyService.autoGetDbKey(180_000, (message, level) => {
+    return keyService.autoGetDbKey(180_000, (message: string, level: number) => {
       event.sender.send('key:dbKeyStatus', { message, level })
     })
   })
 
   ipcMain.handle('key:autoGetImageKey', async (event, manualDir?: string, wxid?: string) => {
-    return keyService.autoGetImageKey(manualDir, (message) => {
+    return keyService.autoGetImageKey(manualDir, (message: string) => {
       event.sender.send('key:imageKeyStatus', { message })
     }, wxid)
   })
 
   ipcMain.handle('key:scanImageKeyFromMemory', async (event, userDir: string) => {
-    return keyService.autoGetImageKeyByMemoryScan(userDir, (message) => {
+    return keyService.autoGetImageKeyByMemoryScan(userDir, (message: string) => {
       event.sender.send('key:imageKeyStatus', { message })
     })
   })
 
   // HTTP API 服务
-  ipcMain.handle('http:start', async (_, port?: number) => {
-    return httpService.start(port || 5031)
+  ipcMain.handle('http:start', async (_, port?: number, host?: string) => {
+    const bindHost = typeof host === 'string' && host.trim() ? host.trim() : '127.0.0.1'
+    return httpService.start(port || 5031, bindHost)
   })
 
   ipcMain.handle('http:stop', async () => {
@@ -2355,7 +2966,7 @@ function checkForUpdatesOnStartup() {
         const latestVersion = result.updateInfo.version
 
         // 检查是否有新版本
-        if (latestVersion !== currentVersion && mainWindow) {
+        if (shouldOfferUpdateForTrack(latestVersion, currentVersion) && mainWindow) {
           // 检查该版本是否被用户忽略
           const ignoredVersion = configService?.get('ignoredUpdateVersion')
           if (ignoredVersion === latestVersion) {
@@ -2366,7 +2977,8 @@ function checkForUpdatesOnStartup() {
           // 通知渲染进程有新版本
           mainWindow.webContents.send('app:updateAvailable', {
             version: latestVersion,
-            releaseNotes: result.updateInfo.releaseNotes || ''
+            releaseNotes: getDialogReleaseNotes(result.updateInfo.releaseNotes),
+            minimumVersion: (result.updateInfo as any).minimumVersion
           })
         }
       }
@@ -2399,6 +3011,8 @@ app.whenReady().then(async () => {
   // 初始化配置服务
   updateSplashProgress(5, '正在加载配置...')
   configService = new ConfigService()
+  applyAutoUpdateChannel('startup')
+  syncLaunchAtStartupPreference()
 
   // 将用户主题配置推送给 Splash 窗口
   if (splashWindow && !splashWindow.isDestroyed()) {
@@ -2429,6 +3043,10 @@ app.whenReady().then(async () => {
   // 注册 IPC 处理器
   updateSplashProgress(25, '正在初始化...')
   registerIpcHandlers()
+  chatService.addDbMonitorListener((type, json) => {
+    messagePushService.handleDbMonitorChange(type, json)
+  })
+  messagePushService.start()
   await delay(200)
 
   // 检查配置状态
@@ -2439,6 +3057,63 @@ app.whenReady().then(async () => {
   updateSplashProgress(30, '正在加载界面...')
   mainWindow = createWindow({ autoShow: false })
 
+  let iconName = 'icon.ico';
+  if (process.platform === 'linux') {
+    iconName = 'icon.png';
+  } else if (process.platform === 'darwin') {
+    iconName = 'icon.icns';
+  }
+
+  const isDev = !!process.env.VITE_DEV_SERVER_URL
+
+  const resolvedTrayIcon = isDev
+      ? join(__dirname, `../public/${iconName}`)
+      : join(process.resourcesPath, iconName);
+
+
+  try {
+    tray = new Tray(resolvedTrayIcon)
+    tray.setToolTip('WeFlow')
+    const contextMenu = Menu.buildFromTemplate([
+      {
+        label: '显示主窗口',
+        click: () => {
+          if (mainWindow) {
+            mainWindow.show()
+            mainWindow.focus()
+          }
+        }
+      },
+      { type: 'separator' },
+      {
+        label: '退出',
+        click: () => {
+          isAppQuitting = true
+          app.quit()
+        }
+      }
+    ])
+    tray.setContextMenu(contextMenu)
+    tray.on('click', () => {
+      if (mainWindow) {
+        if (mainWindow.isVisible()) {
+          mainWindow.focus()
+        } else {
+          mainWindow.show()
+          mainWindow.focus()
+        }
+      }
+    })
+    tray.on('double-click', () => {
+      if (mainWindow) {
+        mainWindow.show()
+        mainWindow.focus()
+      }
+    })
+  } catch (e) {
+    console.warn('[Tray] Failed to create tray icon:', e)
+  }
+
   // 配置网络服务
   session.defaultSession.webRequest.onBeforeSendHeaders(
     {
@@ -2477,6 +3152,8 @@ app.whenReady().then(async () => {
   // 启动时检测更新（不阻塞启动）
   checkForUpdatesOnStartup()
 
+  await httpService.autoStart()
+
   app.on('activate', () => {
     if (BrowserWindow.getAllWindows().length === 0) {
       mainWindow = createWindow()
@@ -2486,12 +3163,20 @@ app.whenReady().then(async () => {
 
 app.on('before-quit', async () => {
   isAppQuitting = true
+  // 销毁 tray 图标
+  if (tray) { try { tray.destroy() } catch {} tray = null }
   // 通知窗使用 hide 而非 close，退出时主动销毁，避免残留窗口阻塞进程退出。
   destroyNotificationWindow()
+  // 兜底：5秒后强制退出，防止某个异步任务卡住导致进程残留
+  const forceExitTimer = setTimeout(() => {
+    console.warn('[App] Force exit after timeout')
+    app.exit(0)
+  }, 5000)
+  forceExitTimer.unref()
   // 停止 HTTP 服务器，释放 TCP 端口占用，避免进程无法退出
   try { await httpService.stop() } catch {}
   // 终止 wcdb Worker 线程，避免线程阻止进程退出
-  try { wcdbService.shutdown() } catch {}
+  try { await wcdbService.shutdown() } catch {}
 })
 
 app.on('window-all-closed', () => {

electron/preload.ts

@@ -53,6 +53,8 @@ contextBridge.exposeInMainWorld('electronAPI', {
   app: {
     getDownloadsPath: () => ipcRenderer.invoke('app:getDownloadsPath'),
     getVersion: () => ipcRenderer.invoke('app:getVersion'),
+    getLaunchAtStartupStatus: () => ipcRenderer.invoke('app:getLaunchAtStartupStatus'),
+    setLaunchAtStartup: (enabled: boolean) => ipcRenderer.invoke('app:setLaunchAtStartup', enabled),
     checkForUpdates: () => ipcRenderer.invoke('app:checkForUpdates'),
     downloadAndInstall: () => ipcRenderer.invoke('app:downloadAndInstall'),
     ignoreUpdate: (version: string) => ipcRenderer.invoke('app:ignoreUpdate', version),
@@ -63,7 +65,8 @@ contextBridge.exposeInMainWorld('electronAPI', {
     onUpdateAvailable: (callback: (info: { version: string; releaseNotes: string }) => void) => {
       ipcRenderer.on('app:updateAvailable', (_, info) => callback(info))
       return () => ipcRenderer.removeAllListeners('app:updateAvailable')
-    }
+    },
+    checkWayland: () => ipcRenderer.invoke('app:checkWayland'),
   },
 
   // 日志
@@ -94,6 +97,13 @@ contextBridge.exposeInMainWorld('electronAPI', {
       return () => ipcRenderer.removeListener('window:maximizeStateChanged', listener)
     },
     close: () => ipcRenderer.send('window:close'),
+    onCloseConfirmRequested: (callback: (payload: { canMinimizeToTray: boolean }) => void) => {
+      const listener = (_: unknown, payload: { canMinimizeToTray: boolean }) => callback(payload)
+      ipcRenderer.on('window:confirmCloseRequested', listener)
+      return () => ipcRenderer.removeListener('window:confirmCloseRequested', listener)
+    },
+    respondCloseConfirm: (action: 'tray' | 'quit' | 'cancel') =>
+      ipcRenderer.invoke('window:respondCloseConfirm', action),
     openAgreementWindow: () => ipcRenderer.invoke('window:openAgreementWindow'),
     completeOnboarding: () => ipcRenderer.invoke('window:completeOnboarding'),
     openOnboardingWindow: () => ipcRenderer.invoke('window:openOnboardingWindow'),
@@ -106,6 +116,10 @@ contextBridge.exposeInMainWorld('electronAPI', {
       ipcRenderer.invoke('window:openImageViewerWindow', imagePath, liveVideoPath),
     openChatHistoryWindow: (sessionId: string, messageId: number) =>
       ipcRenderer.invoke('window:openChatHistoryWindow', sessionId, messageId),
+    openChatHistoryPayloadWindow: (payload: { sessionId: string; title?: string; recordList: any[] }) =>
+      ipcRenderer.invoke('window:openChatHistoryPayloadWindow', payload),
+    getChatHistoryPayload: (payloadId: string) =>
+      ipcRenderer.invoke('window:getChatHistoryPayload', payloadId),
     openSessionChatWindow: (
       sessionId: string,
       options?: {
@@ -208,16 +222,16 @@ contextBridge.exposeInMainWorld('electronAPI', {
     getMessageDateCounts: (sessionId: string) => ipcRenderer.invoke('chat:getMessageDateCounts', sessionId),
     resolveVoiceCache: (sessionId: string, msgId: string) => ipcRenderer.invoke('chat:resolveVoiceCache', sessionId, msgId),
     getVoiceTranscript: (sessionId: string, msgId: string, createTime?: number) => ipcRenderer.invoke('chat:getVoiceTranscript', sessionId, msgId, createTime),
-    onVoiceTranscriptPartial: (callback: (payload: { msgId: string; text: string }) => void) => {
-      const listener = (_: any, payload: { msgId: string; text: string }) => callback(payload)
+    onVoiceTranscriptPartial: (callback: (payload: { sessionId?: string; msgId: string; createTime?: number; text: string }) => void) => {
+      const listener = (_: any, payload: { sessionId?: string; msgId: string; createTime?: number; text: string }) => callback(payload)
       ipcRenderer.on('chat:voiceTranscriptPartial', listener)
       return () => ipcRenderer.removeListener('chat:voiceTranscriptPartial', listener)
     },
-    execQuery: (kind: string, path: string | null, sql: string) =>
-      ipcRenderer.invoke('chat:execQuery', kind, path, sql),
-    getContacts: () => ipcRenderer.invoke('chat:getContacts'),
+    getContacts: (options?: { lite?: boolean }) => ipcRenderer.invoke('chat:getContacts', options),
     getMessage: (sessionId: string, localId: number) =>
       ipcRenderer.invoke('chat:getMessage', sessionId, localId),
+    searchMessages: (keyword: string, sessionId?: string, limit?: number, offset?: number, beginTimestamp?: number, endTimestamp?: number) =>
+      ipcRenderer.invoke('chat:searchMessages', keyword, sessionId, limit, offset, beginTimestamp, endTimestamp),
     onWcdbChange: (callback: (event: any, data: { type: string; json: string }) => void) => {
       ipcRenderer.on('wcdb-change', callback)
       return () => ipcRenderer.removeListener('wcdb-change', callback)
@@ -235,12 +249,14 @@ contextBridge.exposeInMainWorld('electronAPI', {
     preload: (payloads: Array<{ sessionId?: string; imageMd5?: string; imageDatName?: string }>) =>
       ipcRenderer.invoke('image:preload', payloads),
     onUpdateAvailable: (callback: (payload: { cacheKey: string; imageMd5?: string; imageDatName?: string }) => void) => {
-      ipcRenderer.on('image:updateAvailable', (_, payload) => callback(payload))
-      return () => ipcRenderer.removeAllListeners('image:updateAvailable')
+      const listener = (_: unknown, payload: { cacheKey: string; imageMd5?: string; imageDatName?: string }) => callback(payload)
+      ipcRenderer.on('image:updateAvailable', listener)
+      return () => ipcRenderer.removeListener('image:updateAvailable', listener)
     },
     onCacheResolved: (callback: (payload: { cacheKey: string; imageMd5?: string; imageDatName?: string; localPath: string }) => void) => {
-      ipcRenderer.on('image:cacheResolved', (_, payload) => callback(payload))
-      return () => ipcRenderer.removeAllListeners('image:cacheResolved')
+      const listener = (_: unknown, payload: { cacheKey: string; imageMd5?: string; imageDatName?: string; localPath: string }) => callback(payload)
+      ipcRenderer.on('image:cacheResolved', listener)
+      return () => ipcRenderer.removeListener('image:cacheResolved', listener)
     }
   },
 
@@ -283,6 +299,12 @@ contextBridge.exposeInMainWorld('electronAPI', {
     getGroupMessageRanking: (chatroomId: string, limit?: number, startTime?: number, endTime?: number) => ipcRenderer.invoke('groupAnalytics:getGroupMessageRanking', chatroomId, limit, startTime, endTime),
     getGroupActiveHours: (chatroomId: string, startTime?: number, endTime?: number) => ipcRenderer.invoke('groupAnalytics:getGroupActiveHours', chatroomId, startTime, endTime),
     getGroupMediaStats: (chatroomId: string, startTime?: number, endTime?: number) => ipcRenderer.invoke('groupAnalytics:getGroupMediaStats', chatroomId, startTime, endTime),
+    getGroupMemberAnalytics: (chatroomId: string, memberUsername: string, startTime?: number, endTime?: number) => ipcRenderer.invoke('groupAnalytics:getGroupMemberAnalytics', chatroomId, memberUsername, startTime, endTime),
+    getGroupMemberMessages: (
+      chatroomId: string,
+      memberUsername: string,
+      options?: { startTime?: number; endTime?: number; limit?: number; cursor?: number }
+    ) => ipcRenderer.invoke('groupAnalytics:getGroupMemberMessages', chatroomId, memberUsername, options),
     exportGroupMembers: (chatroomId: string, outputPath: string) => ipcRenderer.invoke('groupAnalytics:exportGroupMembers', chatroomId, outputPath),
     exportGroupMemberMessages: (chatroomId: string, memberUsername: string, outputPath: string, startTime?: number, endTime?: number) =>
       ipcRenderer.invoke('groupAnalytics:exportGroupMemberMessages', chatroomId, memberUsername, outputPath, startTime, endTime)
@@ -338,7 +360,20 @@ contextBridge.exposeInMainWorld('electronAPI', {
       ipcRenderer.invoke('export:exportSession', sessionId, outputPath, options),
     exportContacts: (outputDir: string, options: any) =>
       ipcRenderer.invoke('export:exportContacts', outputDir, options),
-    onProgress: (callback: (payload: { current: number; total: number; currentSession: string; currentSessionId?: string; phase: string }) => void) => {
+    onProgress: (callback: (payload: {
+      current: number
+      total: number
+      currentSession: string
+      currentSessionId?: string
+      phase: string
+      phaseProgress?: number
+      phaseTotal?: number
+      phaseLabel?: string
+      collectedMessages?: number
+      exportedMessages?: number
+      estimatedTotalMessages?: number
+      writtenFiles?: number
+    }) => void) => {
       ipcRenderer.on('export:progress', (_, payload) => callback(payload))
       return () => ipcRenderer.removeAllListeners('export:progress')
     }
@@ -380,6 +415,14 @@ contextBridge.exposeInMainWorld('electronAPI', {
     downloadEmoji: (params: { url: string; encryptUrl?: string; aesKey?: string }) => ipcRenderer.invoke('sns:downloadEmoji', params)
   },
 
+  biz: {
+    listAccounts: (account?: string) => ipcRenderer.invoke('biz:listAccounts', account),
+    listMessages: (username: string, account?: string, limit?: number, offset?: number) =>
+        ipcRenderer.invoke('biz:listMessages', username, account, limit, offset),
+    listPayRecords: (account?: string, limit?: number, offset?: number) =>
+        ipcRenderer.invoke('biz:listPayRecords', account, limit, offset)
+  },
+
 
   // 数据收集
   cloud: {
@@ -390,7 +433,7 @@ contextBridge.exposeInMainWorld('electronAPI', {
 
   // HTTP API 服务
   http: {
-    start: (port?: number) => ipcRenderer.invoke('http:start', port),
+    start: (port?: number, host?: string) => ipcRenderer.invoke('http:start', port, host),
     stop: () => ipcRenderer.invoke('http:stop'),
     status: () => ipcRenderer.invoke('http:status')
   }

electron/services/analyticsService.ts

@@ -68,29 +68,14 @@ class AnalyticsService {
     return new Set(this.getExcludedUsernamesList())
   }
 
-  private escapeSqlValue(value: string): string {
-    return value.replace(/'/g, "''")
-  }
-
   private async getAliasMap(usernames: string[]): Promise<Record<string, string>> {
     const map: Record<string, string> = {}
     if (usernames.length === 0) return map
 
-    // C++ 层不支持参数绑定，直接内联转义后的字符串值
-    const chunkSize = 200
-    for (let i = 0; i < usernames.length; i += chunkSize) {
-      const chunk = usernames.slice(i, i + chunkSize)
-      const inList = chunk.map((u) => `'${this.escapeSqlValue(u)}'`).join(',')
-      const sql = `SELECT username, alias FROM contact WHERE username IN (${inList})`
-      const result = await wcdbService.execQuery('contact', null, sql)
-      if (!result.success || !result.rows) continue
-      for (const row of result.rows as Record<string, any>[]) {
-        const username = row.username || ''
-        const alias = row.alias || ''
-        if (username && alias) {
-          map[username] = alias
-        }
-      }
+    const result = await wcdbService.getContactAliasMap(usernames)
+    if (!result.success || !result.map) return map
+    for (const [username, alias] of Object.entries(result.map)) {
+      if (username && alias) map[username] = alias
     }
 
     return map

electron/services/annualReportService.ts

@@ -278,16 +278,16 @@ class AnnualReportService {
       return cached || null
     }
 
-    const result = await wcdbService.execQuery('message', dbPath, `PRAGMA table_info(${this.quoteSqlIdentifier(tableName)})`)
-    if (!result.success || !Array.isArray(result.rows) || result.rows.length === 0) {
+    const result = await wcdbService.getMessageTableColumns(dbPath, tableName)
+    if (!result.success || !Array.isArray(result.columns) || result.columns.length === 0) {
       this.availableYearsColumnCache.set(cacheKey, '')
       return null
     }
 
     const candidates = ['create_time', 'createtime', 'msg_create_time', 'msg_time', 'msgtime', 'time']
     const columns = new Set<string>()
-    for (const row of result.rows as Record<string, any>[]) {
-      const name = String(row.name || row.column_name || row.columnName || '').trim().toLowerCase()
+    for (const columnName of result.columns) {
+      const name = String(columnName || '').trim().toLowerCase()
       if (name) columns.add(name)
     }
 
@@ -309,10 +309,11 @@ class AnnualReportService {
     const tried = new Set<string>()
 
     const queryByColumn = async (column: string): Promise<{ first: number; last: number } | null> => {
-      const sql = `SELECT MIN(${this.quoteSqlIdentifier(column)}) AS first_ts, MAX(${this.quoteSqlIdentifier(column)}) AS last_ts FROM ${this.quoteSqlIdentifier(tableName)}`
-      const result = await wcdbService.execQuery('message', dbPath, sql)
-      if (!result.success || !Array.isArray(result.rows) || result.rows.length === 0) return null
-      const row = result.rows[0] as Record<string, any>
+      const result = await wcdbService.getMessageTableTimeRange(dbPath, tableName)
+      if (!result.success || !result.data) return null
+      const row = result.data as Record<string, any>
+      const actualColumn = String(row.column || '').trim().toLowerCase()
+      if (column && actualColumn && column.toLowerCase() !== actualColumn) return null
       const first = this.toUnixTimestamp(row.first_ts ?? row.firstTs ?? row.min_ts ?? row.minTs)
       const last = this.toUnixTimestamp(row.last_ts ?? row.lastTs ?? row.max_ts ?? row.maxTs)
       return { first, last }
@@ -1134,7 +1135,7 @@ class AnnualReportService {
 
               const now = Date.now()
               if (now - lastProgressAt > 200) {
-                let progress = 30
+                let progress: number
                 if (totalMessagesForProgress > 0) {
                   const ratio = Math.min(1, processedMessages / totalMessagesForProgress)
                   progress = 30 + Math.floor(ratio * 50)

electron/services/bizService.ts

@@ -0,0 +1,243 @@
+import { join } from 'path'
+import { readdirSync, existsSync } from 'fs'
+import { wcdbService } from './wcdbService'
+import { ConfigService } from './config'
+import { chatService, Message } from './chatService'
+import { ipcMain } from 'electron'
+import { createHash } from 'crypto'
+
+export interface BizAccount {
+  username: string
+  name: string
+  avatar: string
+  type: number
+  last_time: number
+  formatted_last_time: string
+}
+
+export interface BizMessage {
+  local_id: number
+  create_time: number
+  title: string
+  des: string
+  url: string
+  cover: string
+  content_list: any[]
+}
+
+export interface BizPayRecord {
+  local_id: number
+  create_time: number
+  title: string
+  description: string
+  merchant_name: string
+  merchant_icon: string
+  timestamp: number
+  formatted_time: string
+}
+
+export class BizService {
+  private configService: ConfigService
+
+  constructor() {
+    this.configService = new ConfigService()
+  }
+
+  private extractXmlValue(xml: string, tagName: string): string {
+    const regex = new RegExp(`<${tagName}>([\\s\\S]*?)</${tagName}>`, 'i')
+    const match = regex.exec(xml)
+    if (match) {
+      return match[1].replace(/<!\[CDATA\[/g, '').replace(/\]\]>/g, '').trim()
+    }
+    return ''
+  }
+
+  private parseBizContentList(xmlStr: string): any[] {
+    if (!xmlStr) return []
+    const contentList: any[] = []
+    try {
+      const itemRegex = /<item>([\s\S]*?)<\/item>/gi
+      let match: RegExpExecArray | null
+      while ((match = itemRegex.exec(xmlStr)) !== null) {
+        const itemXml = match[1]
+        const itemStruct = {
+          title: this.extractXmlValue(itemXml, 'title'),
+          url: this.extractXmlValue(itemXml, 'url'),
+          cover: this.extractXmlValue(itemXml, 'cover') || this.extractXmlValue(itemXml, 'thumburl'),
+          summary: this.extractXmlValue(itemXml, 'summary') || this.extractXmlValue(itemXml, 'digest')
+        }
+        if (itemStruct.title) contentList.push(itemStruct)
+      }
+    } catch (e) { }
+    return contentList
+  }
+
+  private parsePayXml(xmlStr: string): any {
+    if (!xmlStr) return null
+    try {
+      const title = this.extractXmlValue(xmlStr, 'title')
+      const description = this.extractXmlValue(xmlStr, 'des')
+      const merchantName = this.extractXmlValue(xmlStr, 'display_name') || '微信支付'
+      const merchantIcon = this.extractXmlValue(xmlStr, 'icon_url')
+      const pubTime = parseInt(this.extractXmlValue(xmlStr, 'pub_time') || '0')
+      if (!title && !description) return null
+      return { title, description, merchant_name: merchantName, merchant_icon: merchantIcon, timestamp: pubTime }
+    } catch (e) { return null }
+  }
+
+  async listAccounts(account?: string): Promise<BizAccount[]> {
+    try {
+      // 1. 获取公众号联系人列表
+      const contactsResult = await chatService.getContacts({ lite: true })
+      if (!contactsResult.success || !contactsResult.contacts) return []
+
+      const officialContacts = contactsResult.contacts.filter(c => c.type === 'official')
+      const usernames = officialContacts.map(c => c.username)
+
+      // 获取头像和昵称等补充信息
+      const enrichment = await chatService.enrichSessionsContactInfo(usernames)
+      const contactInfoMap = enrichment.success && enrichment.contacts ? enrichment.contacts : {}
+
+      const root = this.configService.get('dbPath')
+      const myWxid = this.configService.get('myWxid')
+      const accountWxid = account || myWxid
+      if (!root || !accountWxid) return []
+
+      const bizLatestTime: Record<string, number> = {}
+
+      try {
+        const sessionsRes = await wcdbService.getSessions()
+        if (sessionsRes.success && sessionsRes.sessions) {
+          for (const session of sessionsRes.sessions) {
+            const uname = session.username || session.strUsrName || session.userName || session.id
+            // 适配日志中发现的字段，注意转为整型数字
+            const timeStr = session.last_timestamp || session.sort_timestamp || session.nTime || session.timestamp || '0'
+            const time = parseInt(timeStr.toString(), 10)
+
+            if (usernames.includes(uname) && time > 0) {
+              bizLatestTime[uname] = time
+            }
+          }
+        }
+      } catch (e) {
+        console.error('获取 Sessions 失败:', e)
+      }
+
+      // 3. 格式化时间显示
+      const formatBizTime = (ts: number) => {
+        if (!ts) return ''
+        const date = new Date(ts * 1000)
+        const now = new Date()
+        const isToday = date.toDateString() === now.toDateString()
+        if (isToday) return date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit', hour12: false })
+
+        const yesterday = new Date(now)
+        yesterday.setDate(now.getDate() - 1)
+        if (date.toDateString() === yesterday.toDateString()) return '昨天'
+
+        const isThisYear = date.getFullYear() === now.getFullYear()
+        if (isThisYear) return `${date.getMonth() + 1}/${date.getDate()}`
+
+        return `${date.getFullYear().toString().slice(-2)}/${date.getMonth() + 1}/${date.getDate()}`
+      }
+
+      // 4. 组装数据
+      const result: BizAccount[] = officialContacts.map(contact => {
+        const uname = contact.username
+        const info = contactInfoMap[uname]
+        const lastTime = bizLatestTime[uname] || 0
+        return {
+          username: uname,
+          name: info?.displayName || contact.displayName || uname,
+          avatar: info?.avatarUrl || '',
+          type: 0,
+          last_time: lastTime,
+          formatted_last_time: formatBizTime(lastTime)
+        }
+      })
+
+      // 5. 补充公众号类型 (订阅号/服务号)
+      const contactDbPath = join(root, accountWxid, 'db_storage', 'contact', 'contact.db')
+      if (existsSync(contactDbPath)) {
+        const bizInfoRes = await wcdbService.execQuery('contact', contactDbPath, 'SELECT username, type FROM biz_info')
+        if (bizInfoRes.success && bizInfoRes.rows) {
+          const typeMap: Record<string, number> = {}
+          for (const r of bizInfoRes.rows) typeMap[r.username] = r.type
+          for (const acc of result) if (typeMap[acc.username] !== undefined) acc.type = typeMap[acc.username]
+        }
+      }
+
+      // 6. 排序输出
+      return result
+          .filter(acc => !acc.name.includes('广告'))
+          .sort((a, b) => {
+            if (a.username === 'gh_3dfda90e39d6') return -1 // 微信支付置顶
+            if (b.username === 'gh_3dfda90e39d6') return 1
+            return b.last_time - a.last_time // 按最新时间降序排列
+          })
+    } catch (e) {
+      console.error('获取账号列表发生错误:', e)
+      return []
+    }
+  }
+
+  async listMessages(username: string, account?: string, limit: number = 20, offset: number = 0): Promise<BizMessage[]> {
+    try {
+      // 仅保留核心路径：利用 chatService 的自动路由能力
+      const res = await chatService.getMessages(username, offset, limit)
+      if (!res.success || !res.messages) return []
+
+      return res.messages.map(msg => {
+        const bizMsg: BizMessage = {
+          local_id: msg.localId,
+          create_time: msg.createTime,
+          title: msg.linkTitle || msg.parsedContent || '',
+          des: msg.appMsgDesc || '',
+          url: msg.linkUrl || '',
+          cover: msg.linkThumb || msg.appMsgThumbUrl || '',
+          content_list: []
+        }
+        if (msg.rawContent) {
+          bizMsg.content_list = this.parseBizContentList(msg.rawContent)
+          if (bizMsg.content_list.length > 0 && !bizMsg.title) {
+            bizMsg.title = bizMsg.content_list[0].title
+            bizMsg.cover = bizMsg.cover || bizMsg.content_list[0].cover
+          }
+        }
+        return bizMsg
+      })
+    } catch (e) { return [] }
+  }
+
+  async listPayRecords(account?: string, limit: number = 20, offset: number = 0): Promise<BizPayRecord[]> {
+    const username = 'gh_3dfda90e39d6'
+    try {
+      const res = await chatService.getMessages(username, offset, limit)
+      if (!res.success || !res.messages) return []
+
+      const records: BizPayRecord[] = []
+      for (const msg of res.messages) {
+        if (!msg.rawContent) continue
+        const parsedData = this.parsePayXml(msg.rawContent)
+        if (parsedData) {
+          records.push({
+            local_id: msg.localId,
+            create_time: msg.createTime,
+            ...parsedData,
+            timestamp: parsedData.timestamp || msg.createTime,
+            formatted_time: new Date((parsedData.timestamp || msg.createTime) * 1000).toLocaleString()
+          })
+        }
+      }
+      return records
+    } catch (e) { return [] }
+  }
+
+  registerHandlers() {
+    ipcMain.handle('biz:listAccounts', (_, account) => this.listAccounts(account))
+    ipcMain.handle('biz:listMessages', (_, username, account, limit, offset) => this.listMessages(username, account, limit, offset))
+    ipcMain.handle('biz:listPayRecords', (_, account, limit, offset) => this.listPayRecords(account, limit, offset))
+  }
+}
+
+export const bizService = new BizService()

electron/services/cloudControlService.ts

@@ -14,15 +14,32 @@ class CloudControlService {
   private deviceId: string = ''
   private timer: NodeJS.Timeout | null = null
   private pages: Set<string> = new Set()
+  private platformVersionCache: string | null = null
+  private pendingReports: UsageStats[] = []
+  private flushInProgress = false
+  private retryDelayMs = 5_000
+  private consecutiveFailures = 0
+  private circuitOpenedAt = 0
+  private nextDelayOverrideMs: number | null = null
+  private initialized = false
+
+  private static readonly BASE_FLUSH_MS = 300_000
+  private static readonly JITTER_MS = 30_000
+  private static readonly MAX_BUFFER_REPORTS = 200
+  private static readonly MAX_BATCH_REPORTS = 20
+  private static readonly MAX_RETRY_MS = 120_000
+  private static readonly CIRCUIT_FAIL_THRESHOLD = 5
+  private static readonly CIRCUIT_COOLDOWN_MS = 120_000
 
   async init() {
+    if (this.initialized) return
+    this.initialized = true
     this.deviceId = this.getDeviceId()
     await wcdbService.cloudInit(300)
-    await this.reportOnline()
-
-    this.timer = setInterval(() => {
-      this.reportOnline()
-    }, 300000)
+    this.enqueueCurrentReport()
+    await this.flushQueue(true)
+    this.scheduleNextFlush(this.nextDelayOverrideMs ?? undefined)
+    this.nextDelayOverrideMs = null
   }
 
   private getDeviceId(): string {
@@ -32,8 +49,8 @@ class CloudControlService {
     return crypto.createHash('md5').update(machineId).digest('hex')
   }
 
-  private async reportOnline() {
-    const data: UsageStats = {
+  private buildCurrentReport(): UsageStats {
+    return {
       appVersion: app.getVersion(),
       platform: this.getPlatformVersion(),
       deviceId: this.deviceId,
@@ -41,13 +58,76 @@ class CloudControlService {
       online: true,
       pages: Array.from(this.pages)
     }
+  }
 
-    await wcdbService.cloudReport(JSON.stringify(data))
+  private enqueueCurrentReport() {
+    const report = this.buildCurrentReport()
+    this.pendingReports.push(report)
+    if (this.pendingReports.length > CloudControlService.MAX_BUFFER_REPORTS) {
+      this.pendingReports.splice(0, this.pendingReports.length - CloudControlService.MAX_BUFFER_REPORTS)
+    }
     this.pages.clear()
   }
 
+  private isCircuitOpen(nowMs: number): boolean {
+    if (this.circuitOpenedAt <= 0) return false
+    return nowMs-this.circuitOpenedAt < CloudControlService.CIRCUIT_COOLDOWN_MS
+  }
+
+  private scheduleNextFlush(delayMs?: number) {
+    if (this.timer) {
+      clearTimeout(this.timer)
+      this.timer = null
+    }
+    const jitter = Math.floor(Math.random() * CloudControlService.JITTER_MS)
+    const nextDelay = Math.max(1_000, Number(delayMs) > 0 ? Number(delayMs) : CloudControlService.BASE_FLUSH_MS + jitter)
+    this.timer = setTimeout(() => {
+      this.enqueueCurrentReport()
+      this.flushQueue(false).finally(() => {
+        this.scheduleNextFlush(this.nextDelayOverrideMs ?? undefined)
+        this.nextDelayOverrideMs = null
+      })
+    }, nextDelay)
+  }
+
+  private async flushQueue(force: boolean) {
+    if (this.flushInProgress) return
+    if (this.pendingReports.length === 0) return
+    const now = Date.now()
+    if (!force && this.isCircuitOpen(now)) {
+      return
+    }
+    this.flushInProgress = true
+    try {
+      while (this.pendingReports.length > 0) {
+        const batch = this.pendingReports.slice(0, CloudControlService.MAX_BATCH_REPORTS)
+        const result = await wcdbService.cloudReport(JSON.stringify(batch))
+        if (!result || result.success !== true) {
+          this.consecutiveFailures += 1
+          this.retryDelayMs = Math.min(CloudControlService.MAX_RETRY_MS, this.retryDelayMs * 2)
+          if (this.consecutiveFailures >= CloudControlService.CIRCUIT_FAIL_THRESHOLD) {
+            this.circuitOpenedAt = Date.now()
+          }
+          this.nextDelayOverrideMs = this.retryDelayMs
+          return
+        }
+        this.pendingReports.splice(0, batch.length)
+        this.consecutiveFailures = 0
+        this.retryDelayMs = 5_000
+        this.circuitOpenedAt = 0
+      }
+    } finally {
+      this.flushInProgress = false
+    }
+  }
+
   private getPlatformVersion(): string {
+    if (this.platformVersionCache) {
+      return this.platformVersionCache
+    }
+
     const os = require('os')
+    const fs = require('fs')
     const platform = process.platform
 
     if (platform === 'win32') {
@@ -59,21 +139,79 @@ class CloudControlService {
 
       // Windows 11 是 10.0.22000+，且主版本必须是 10.0
       if (major === 10 && minor === 0 && build >= 22000) {
-        return 'Windows 11'
+        this.platformVersionCache = 'Windows 11'
+        return this.platformVersionCache
       } else if (major === 10) {
-        return 'Windows 10'
+        this.platformVersionCache = 'Windows 10'
+        return this.platformVersionCache
       }
-      return `Windows ${release}`
+      this.platformVersionCache = `Windows ${release}`
+      return this.platformVersionCache
     }
 
     if (platform === 'darwin') {
       // `os.release()` returns Darwin kernel version (e.g. 25.3.0),
       // while cloud reporting expects the macOS product version (e.g. 26.3).
       const macVersion = typeof process.getSystemVersion === 'function' ? process.getSystemVersion() : os.release()
-      return `macOS ${macVersion}`
+      this.platformVersionCache = `macOS ${macVersion}`
+      return this.platformVersionCache
     }
 
-    return platform
+    if (platform === 'linux') {
+      try {
+        const osReleasePaths = ['/etc/os-release', '/usr/lib/os-release']
+        for (const filePath of osReleasePaths) {
+          if (!fs.existsSync(filePath)) {
+            continue
+          }
+
+          const content = fs.readFileSync(filePath, 'utf8')
+          const values: Record<string, string> = {}
+
+          for (const line of content.split('\n')) {
+            const trimmed = line.trim()
+            if (!trimmed || trimmed.startsWith('#')) {
+              continue
+            }
+
+            const separatorIndex = trimmed.indexOf('=')
+            if (separatorIndex <= 0) {
+              continue
+            }
+
+            const key = trimmed.slice(0, separatorIndex)
+            let value = trimmed.slice(separatorIndex + 1).trim()
+            if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith('\'') && value.endsWith('\''))) {
+              value = value.slice(1, -1)
+            }
+            values[key] = value
+          }
+
+          if (values.PRETTY_NAME) {
+            this.platformVersionCache = values.PRETTY_NAME
+            return this.platformVersionCache
+          }
+
+          if (values.NAME && values.VERSION_ID) {
+            this.platformVersionCache = `${values.NAME} ${values.VERSION_ID}`
+            return this.platformVersionCache
+          }
+
+          if (values.NAME) {
+            this.platformVersionCache = values.NAME
+            return this.platformVersionCache
+          }
+        }
+      } catch (error) {
+        console.warn('[CloudControl] Failed to detect Linux distro version:', error)
+      }
+
+      this.platformVersionCache = `Linux ${os.release()}`
+      return this.platformVersionCache
+    }
+
+    this.platformVersionCache = platform
+    return this.platformVersionCache
   }
 
   recordPage(pageName: string) {
@@ -82,9 +220,16 @@ class CloudControlService {
 
   stop() {
     if (this.timer) {
-      clearInterval(this.timer)
+      clearTimeout(this.timer)
       this.timer = null
     }
+    this.pendingReports = []
+    this.flushInProgress = false
+    this.retryDelayMs = 5_000
+    this.consecutiveFailures = 0
+    this.circuitOpenedAt = 0
+    this.nextDelayOverrideMs = null
+    this.initialized = false
     wcdbService.cloudStop()
   }
 
@@ -94,4 +239,3 @@ class CloudControlService {
 }
 
 export const cloudControlService = new CloudControlService()
-

electron/services/config.ts

@@ -16,7 +16,7 @@ interface ConfigSchema {
   imageXorKey: number
   imageAesKey: string
   wxidConfigs: Record<string, { decryptKey?: string; imageXorKey?: number; imageAesKey?: string; updatedAt?: number }>
-
+  exportPath?: string;
   // 缓存相关
   cachePath: string
   lastOpenedDb: string
@@ -27,6 +27,7 @@ interface ConfigSchema {
   themeId: string
   language: string
   logEnabled: boolean
+  launchAtStartup?: boolean
   llmModelPath: string
   whisperModelName: string
   whisperModelDir: string
@@ -34,6 +35,7 @@ interface ConfigSchema {
   autoTranscribeVoice: boolean
   transcribeLanguages: string[]
   exportDefaultConcurrency: number
+  exportDefaultImageDeepSearchOnMiss: boolean
   analyticsExcludedUsernames: string[]
 
   // 安全相关
@@ -44,17 +46,25 @@ interface ConfigSchema {
 
   // 更新相关
   ignoredUpdateVersion: string
+  updateChannel: 'auto' | 'stable' | 'preview' | 'dev'
 
   // 通知
   notificationEnabled: boolean
-  notificationPosition: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left'
+  notificationPosition: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'top-center'
   notificationFilterMode: 'all' | 'whitelist' | 'blacklist'
   notificationFilterList: string[]
+  messagePushEnabled: boolean
+  httpApiEnabled: boolean
+  httpApiPort: number
+  httpApiHost: string
+  httpApiToken: string
+  windowCloseBehavior: 'ask' | 'tray' | 'quit'
+  quoteLayout: 'quote-top' | 'quote-bottom'
   wordCloudExcludeWords: string[]
 }
 
 // 需要 safeStorage 加密的字段（普通模式）
-const ENCRYPTED_STRING_KEYS: Set<string> = new Set(['decryptKey', 'imageAesKey', 'authPassword'])
+const ENCRYPTED_STRING_KEYS: Set<string> = new Set(['decryptKey', 'imageAesKey', 'authPassword', 'httpApiToken'])
 const ENCRYPTED_BOOL_KEYS: Set<string> = new Set(['authEnabled', 'authUseHello'])
 const ENCRYPTED_NUMBER_KEYS: Set<string> = new Set(['imageXorKey'])
 
@@ -82,43 +92,78 @@ export class ConfigService {
       return ConfigService.instance
     }
     ConfigService.instance = this
-    this.store = new Store<ConfigSchema>({
+    const defaults: ConfigSchema = {
+      dbPath: '',
+      decryptKey: '',
+      myWxid: '',
+      onboardingDone: false,
+      imageXorKey: 0,
+      imageAesKey: '',
+      wxidConfigs: {},
+      cachePath: '',
+      lastOpenedDb: '',
+      lastSession: '',
+      theme: 'system',
+      themeId: 'cloud-dancer',
+      language: 'zh-CN',
+      logEnabled: false,
+      llmModelPath: '',
+      whisperModelName: 'base',
+      whisperModelDir: '',
+      whisperDownloadSource: 'tsinghua',
+      autoTranscribeVoice: false,
+      transcribeLanguages: ['zh'],
+      exportDefaultConcurrency: 4,
+      exportDefaultImageDeepSearchOnMiss: true,
+      analyticsExcludedUsernames: [],
+      authEnabled: false,
+      authPassword: '',
+      authUseHello: false,
+      authHelloSecret: '',
+      ignoredUpdateVersion: '',
+      updateChannel: 'auto',
+      notificationEnabled: true,
+      notificationPosition: 'top-right',
+      notificationFilterMode: 'all',
+      notificationFilterList: [],
+      httpApiToken: '',
+      httpApiEnabled: false,
+      httpApiPort: 5031,
+      httpApiHost: '0.0.0.0',
+      messagePushEnabled: false,
+      windowCloseBehavior: 'ask',
+      quoteLayout: 'quote-top',
+      wordCloudExcludeWords: []
+    }
+
+    const storeOptions: any = {
       name: 'WeFlow-config',
-      defaults: {
-        dbPath: '',
-        decryptKey: '',
-        myWxid: '',
-        onboardingDone: false,
-        imageXorKey: 0,
-        imageAesKey: '',
-        wxidConfigs: {},
-        cachePath: '',
-        lastOpenedDb: '',
-        lastSession: '',
-        theme: 'system',
-        themeId: 'cloud-dancer',
-        language: 'zh-CN',
-        logEnabled: false,
-        llmModelPath: '',
-        whisperModelName: 'base',
-        whisperModelDir: '',
-        whisperDownloadSource: 'tsinghua',
-        autoTranscribeVoice: false,
-        transcribeLanguages: ['zh'],
-        exportDefaultConcurrency: 4,
-        analyticsExcludedUsernames: [],
-        authEnabled: false,
-        authPassword: '',
-        authUseHello: false,
-        authHelloSecret: '',
-        ignoredUpdateVersion: '',
-        notificationEnabled: true,
-        notificationPosition: 'top-right',
-        notificationFilterMode: 'all',
-        notificationFilterList: [],
-        wordCloudExcludeWords: []
+      defaults,
+      projectName: String(process.env.WEFLOW_PROJECT_NAME || 'WeFlow').trim() || 'WeFlow'
+    }
+    const runningInWorker = process.env.WEFLOW_WORKER === '1'
+    if (runningInWorker) {
+      const cwd = String(process.env.WEFLOW_CONFIG_CWD || process.env.WEFLOW_USER_DATA_PATH || '').trim()
+      if (cwd) {
+        storeOptions.cwd = cwd
       }
-    })
+    }
+
+    try {
+      this.store = new Store<ConfigSchema>(storeOptions)
+    } catch (error) {
+      const message = String((error as Error)?.message || error || '')
+      if (message.includes('projectName')) {
+        const fallbackOptions = {
+          ...storeOptions,
+          projectName: 'WeFlow',
+          cwd: storeOptions.cwd || process.env.WEFLOW_CONFIG_CWD || process.env.WEFLOW_USER_DATA_PATH || process.cwd()
+        }
+        this.store = new Store<ConfigSchema>(fallbackOptions)
+      } else {
+        throw error
+      }
+    }
     this.migrateAuthFields()
   }
 
@@ -628,11 +673,9 @@ export class ConfigService {
 
     // 即使 authEnabled 被删除/篡改，如果密钥是 lock: 格式，说明曾开启过应用锁
     const rawDecryptKey: any = this.store.get('decryptKey')
-    if (typeof rawDecryptKey === 'string' && rawDecryptKey.startsWith(LOCK_PREFIX)) {
-      return true
-    }
+    return typeof rawDecryptKey === 'string' && rawDecryptKey.startsWith(LOCK_PREFIX);
+
 
-    return false
   }
 
   // === 工具方法 ===
@@ -658,8 +701,16 @@ export class ConfigService {
     }
   }
 
+  private getUserDataPath(): string {
+    const workerUserDataPath = String(process.env.WEFLOW_USER_DATA_PATH || process.env.WEFLOW_CONFIG_CWD || '').trim()
+    if (workerUserDataPath) {
+      return workerUserDataPath
+    }
+    return app?.getPath?.('userData') || process.cwd()
+  }
+
   getCacheBasePath(): string {
-    return join(app.getPath('userData'), 'cache')
+    return join(this.getUserDataPath(), 'cache')
   }
 
   getAll(): Partial<ConfigSchema> {

electron/services/contactExportService.ts

@@ -93,6 +93,9 @@ class ContactExportService {
                 displayName: c.displayName,
                 remark: c.remark,
                 nickname: c.nickname,
+                alias: c.alias,
+                labels: Array.isArray(c.labels) ? c.labels : [],
+                detailDescription: c.detailDescription,
                 type: c.type
             }))
         }
@@ -103,12 +106,15 @@ class ContactExportService {
      * 导出为CSV格式
      */
     private async exportToCSV(contacts: any[], outputPath: string): Promise<void> {
-        const headers = ['用户名', '显示名称', '备注', '昵称', '类型']
+        const headers = ['用户名', '显示名称', '备注', '昵称', '微信号', '标签', '详细描述', '类型']
         const rows = contacts.map(c => [
             c.username || '',
             c.displayName || '',
             c.remark || '',
             c.nickname || '',
+            c.alias || '',
+            Array.isArray(c.labels) ? c.labels.join(' | ') : '',
+            c.detailDescription || '',
             this.getTypeLabel(c.type)
         ])
 
@@ -137,9 +143,13 @@ class ContactExportService {
                     lines.push(`NICKNAME:${c.nickname}`)
                 }
 
-                // 备注
-                if (c.remark) {
-                    lines.push(`NOTE:${c.remark}`)
+                const noteParts = [
+                    c.remark ? String(c.remark) : '',
+                    Array.isArray(c.labels) && c.labels.length > 0 ? `标签: ${c.labels.join(', ')}` : '',
+                    c.detailDescription ? `详细描述: ${c.detailDescription}` : ''
+                ].filter(Boolean)
+                if (noteParts.length > 0) {
+                    lines.push(`NOTE:${noteParts.join('\\n')}`)
                 }
 
                 // 微信ID

electron/services/dbPathService.ts

@@ -1,13 +1,90 @@
 import { join, basename } from 'path'
-import { existsSync, readdirSync, statSync } from 'fs'
+import { existsSync, readdirSync, statSync, readFileSync } from 'fs'
 import { homedir } from 'os'
+import { createDecipheriv } from 'crypto'
 
 export interface WxidInfo {
   wxid: string
   modifiedTime: number
+  nickname?: string
+  avatarUrl?: string
 }
 
 export class DbPathService {
+  private readVarint(buf: Buffer, offset: number): { value: number, length: number } {
+    let value = 0;
+    let length = 0;
+    let shift = 0;
+    while (offset < buf.length && shift < 32) {
+      const b = buf[offset++];
+      value |= (b & 0x7f) << shift;
+      length++;
+      if ((b & 0x80) === 0) break;
+      shift += 7;
+    }
+    return { value, length };
+  }
+
+  private extractMmkvString(buf: Buffer, keyName: string): string {
+    const keyBuf = Buffer.from(keyName, 'utf8');
+    const idx = buf.indexOf(keyBuf);
+    if (idx === -1) return '';
+
+    try {
+      let offset = idx + keyBuf.length;
+      const v1 = this.readVarint(buf, offset);
+      offset += v1.length;
+      const v2 = this.readVarint(buf, offset);
+      offset += v2.length;
+
+      // 合理性检查
+      if (v2.value > 0 && v2.value <= 10000 && offset + v2.value <= buf.length) {
+        return buf.toString('utf8', offset, offset + v2.value);
+      }
+    } catch { }
+    return '';
+  }
+
+  private parseGlobalConfig(rootPath: string): { wxid: string, nickname: string, avatarUrl: string } | null {
+    try {
+      const configPath = join(rootPath, 'all_users', 'config', 'global_config');
+      if (!existsSync(configPath)) return null;
+
+      const fullData = readFileSync(configPath);
+      if (fullData.length <= 4) return null;
+      const encryptedData = fullData.subarray(4);
+
+      const key = Buffer.alloc(16, 0);
+      Buffer.from('xwechat_crypt_key').copy(key);   // 直接硬编码，iv更是不重要
+      const iv = Buffer.alloc(16, 0);
+
+      const decipher = createDecipheriv('aes-128-cfb', key, iv);
+      decipher.setAutoPadding(false);
+      const decrypted = Buffer.concat([decipher.update(encryptedData), decipher.final()]);
+
+      const wxid = this.extractMmkvString(decrypted, 'mmkv_key_user_name');
+      const nickname = this.extractMmkvString(decrypted, 'mmkv_key_nick_name');
+      let avatarUrl = this.extractMmkvString(decrypted, 'mmkv_key_head_img_url');
+
+      if (!avatarUrl && decrypted.includes('http')) {
+        const httpIdx = decrypted.indexOf('http');
+        const nullIdx = decrypted.indexOf(0x00, httpIdx);
+        if (nullIdx !== -1) {
+          avatarUrl = decrypted.toString('utf8', httpIdx, nullIdx);
+        }
+      }
+
+      if (wxid || nickname) {
+        return { wxid, nickname, avatarUrl };
+      }
+      return null;
+    } catch (e) {
+      console.error('解析 global_config 失败:', e);
+      return null;
+    }
+  }
+
+
   /**
    * 自动检测微信数据库根目录
    */
@@ -16,27 +93,39 @@ export class DbPathService {
       const possiblePaths: string[] = []
       const home = homedir()
 
-      // macOS 微信路径（固定）
       if (process.platform === 'darwin') {
+        // macOS 微信 4.0.5+ 新路径（优先检测）
+        const appSupportBase = join(home, 'Library', 'Containers', 'com.tencent.xinWeChat', 'Data', 'Library', 'Application Support', 'com.tencent.xinWeChat')
+        if (existsSync(appSupportBase)) {
+          try {
+            const entries = readdirSync(appSupportBase)
+            for (const entry of entries) {
+              // 匹配形如 2.0b4.0.9 的版本目录
+              if (/^\d+\.\d+b\d+\.\d+/.test(entry) || /^\d+\.\d+\.\d+/.test(entry)) {
+                possiblePaths.push(join(appSupportBase, entry))
+              }
+            }
+          } catch { }
+        }
+        // macOS 旧路径兜底
         possiblePaths.push(join(home, 'Library', 'Containers', 'com.tencent.xinWeChat', 'Data', 'Documents', 'xwechat_files'))
       } else {
         // Windows 微信4.x 数据目录
         possiblePaths.push(join(home, 'Documents', 'xwechat_files'))
       }
 
-
       for (const path of possiblePaths) {
-        if (existsSync(path)) {
-          const rootName = path.split(/[/\\]/).pop()?.toLowerCase()
-          if (rootName !== 'xwechat_files' && rootName !== 'wechat files') {
-            continue
-          }
+        if (!existsSync(path)) continue
 
-          // 检查是否有有效的账号目录
-          const accounts = this.findAccountDirs(path)
-          if (accounts.length > 0) {
-            return { success: true, path }
-          }
+        // 检查是否有有效的账号目录，或本身就是账号目录
+        const accounts = this.findAccountDirs(path)
+        if (accounts.length > 0) {
+          return { success: true, path }
+        }
+
+        // 如果该目录本身就是账号目录（直接包含 db_storage 等）
+        if (this.isAccountDir(path)) {
+          return { success: true, path }
         }
       }
 
@@ -135,21 +224,16 @@ export class DbPathService {
         for (const entry of entries) {
           const entryPath = join(rootPath, entry)
           let stat: ReturnType<typeof statSync>
-          try {
-            stat = statSync(entryPath)
-          } catch {
-            continue
-          }
-
+          try { stat = statSync(entryPath) } catch { continue }
           if (!stat.isDirectory()) continue
           const lower = entry.toLowerCase()
           if (lower === 'all_users') continue
           if (!entry.includes('_')) continue
-
           wxids.push({ wxid: entry, modifiedTime: stat.mtimeMs })
         }
       }
 
+
       if (wxids.length === 0) {
         const rootName = basename(rootPath)
         if (rootName.includes('_') && rootName.toLowerCase() !== 'all_users') {
@@ -159,12 +243,25 @@ export class DbPathService {
       }
     } catch { }
 
-    return wxids.sort((a, b) => {
+    const sorted = wxids.sort((a, b) => {
       if (b.modifiedTime !== a.modifiedTime) return b.modifiedTime - a.modifiedTime
       return a.wxid.localeCompare(b.wxid)
-    })
+    });
+
+    const globalInfo = this.parseGlobalConfig(rootPath);
+    if (globalInfo) {
+      for (const w of sorted) {
+        if (w.wxid.startsWith(globalInfo.wxid) || sorted.length === 1) {
+          w.nickname = globalInfo.nickname;
+          w.avatarUrl = globalInfo.avatarUrl;
+        }
+      }
+    }
+
+    return sorted;
   }
 
+
   /**
    * 扫描 wxid 列表
    */
@@ -187,10 +284,21 @@ export class DbPathService {
       }
     } catch { }
 
-    return wxids.sort((a, b) => {
+    const sorted = wxids.sort((a, b) => {
       if (b.modifiedTime !== a.modifiedTime) return b.modifiedTime - a.modifiedTime
       return a.wxid.localeCompare(b.wxid)
-    })
+    });
+
+    const globalInfo = this.parseGlobalConfig(rootPath);
+    if (globalInfo) {
+      for (const w of sorted) {
+        if (w.wxid.startsWith(globalInfo.wxid) || sorted.length === 1) {
+          w.nickname = globalInfo.nickname;
+          w.avatarUrl = globalInfo.avatarUrl;
+        }
+      }
+    }
+    return sorted;
   }
 
   /**
@@ -199,6 +307,20 @@ export class DbPathService {
   getDefaultPath(): string {
     const home = homedir()
     if (process.platform === 'darwin') {
+      // 优先返回 4.0.5+ 新路径
+      const appSupportBase = join(home, 'Library', 'Containers', 'com.tencent.xinWeChat', 'Data', 'Library', 'Application Support', 'com.tencent.xinWeChat')
+      if (existsSync(appSupportBase)) {
+        try {
+          const entries = readdirSync(appSupportBase)
+          for (const entry of entries) {
+            if (/^\d+\.\d+b\d+\.\d+/.test(entry) || /^\d+\.\d+\.\d+/.test(entry)) {
+              const candidate = join(appSupportBase, entry)
+              if (existsSync(candidate)) return candidate
+            }
+          }
+        } catch { }
+      }
+      // 旧版本路径兜底
       return join(home, 'Library', 'Containers', 'com.tencent.xinWeChat', 'Data', 'Documents', 'xwechat_files')
     }
     return join(home, 'Documents', 'xwechat_files')

electron/services/exportHtml.css

@@ -186,6 +186,33 @@ body {
   word-break: break-word;
 }
 
+.quoted-message {
+  border-left: 3px solid rgba(79, 70, 229, 0.35);
+  background: rgba(79, 70, 229, 0.06);
+  border-radius: 12px;
+  padding: 8px 10px;
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+
+.message.sent .quoted-message {
+  background: rgba(37, 99, 235, 0.08);
+  border-left-color: rgba(37, 99, 235, 0.35);
+}
+
+.quoted-sender {
+  font-size: 12px;
+  color: #374151;
+  font-weight: 600;
+}
+
+.quoted-text {
+  font-size: 13px;
+  color: #4b5563;
+  word-break: break-word;
+}
+
 .message-link-card {
   color: #2563eb;
   text-decoration: underline;

electron/services/exportHtmlStyles.ts

@@ -186,6 +186,33 @@ body {
   word-break: break-word;
 }
 
+.quoted-message {
+  border-left: 3px solid rgba(79, 70, 229, 0.35);
+  background: rgba(79, 70, 229, 0.06);
+  border-radius: 12px;
+  padding: 8px 10px;
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+
+.message.sent .quoted-message {
+  background: rgba(37, 99, 235, 0.08);
+  border-left-color: rgba(37, 99, 235, 0.35);
+}
+
+.quoted-sender {
+  font-size: 12px;
+  color: #374151;
+  font-weight: 600;
+}
+
+.quoted-text {
+  font-size: 13px;
+  color: #4b5563;
+  word-break: break-word;
+}
+
 .message-link-card {
   color: #2563eb;
   text-decoration: underline;

electron/services/groupAnalyticsService.ts

@@ -5,6 +5,7 @@ import { ConfigService } from './config'
 import { wcdbService } from './wcdbService'
 import { chatService } from './chatService'
 import type { Message } from './chatService'
+import type { ChatStatistics } from './analyticsService'
 
 export interface GroupChatInfo {
   username: string
@@ -49,6 +50,19 @@ export interface GroupMediaStats {
   total: number
 }
 
+export interface GroupMemberAnalytics {
+  statistics: ChatStatistics
+  timeDistribution: Record<number, number>
+  commonPhrases?: Array<{ phrase: string; count: number }>
+  commonEmojis?: Array<{ emoji: string; count: number }>
+}
+
+export interface GroupMemberMessagesPage {
+  messages: Message[]
+  hasMore: boolean
+  nextCursor: number
+}
+
 interface GroupMemberContactInfo {
   remark: string
   nickName: string
@@ -224,10 +238,9 @@ class GroupAnalyticsService {
     }
 
     try {
-      const escapedChatroomId = chatroomId.replace(/'/g, "''")
-      const roomResult = await wcdbService.execQuery('contact', null, `SELECT * FROM chat_room WHERE username='${escapedChatroomId}' LIMIT 1`)
-      if (roomResult.success && roomResult.rows && roomResult.rows.length > 0) {
-        const owner = tryResolve(roomResult.rows[0])
+      const roomExt = await wcdbService.getChatRoomExtBuffer(chatroomId)
+      if (roomExt.success && roomExt.extBuffer) {
+        const owner = tryResolve({ ext_buffer: roomExt.extBuffer })
         if (owner) return owner
       }
     } catch {
@@ -252,26 +265,78 @@ class GroupAnalyticsService {
   }
 
   /**
-   * 从 DLL 获取群成员的群昵称
+   * 从后端获取群成员群昵称，并在前端进行唯一性净化防串号。
    */
   private async getGroupNicknamesForRoom(chatroomId: string, candidates: string[] = []): Promise<Map<string, string>> {
     try {
-      const escapedChatroomId = chatroomId.replace(/'/g, "''")
-      const sql = `SELECT ext_buffer FROM chat_room WHERE username='${escapedChatroomId}' LIMIT 1`
-      const result = await wcdbService.execQuery('contact', null, sql)
-      if (!result.success || !result.rows || result.rows.length === 0) {
+      const dllResult = await wcdbService.getGroupNicknames(chatroomId)
+      if (!dllResult.success || !dllResult.nicknames) {
         return new Map<string, string>()
       }
-
-      const extBuffer = this.decodeExtBuffer((result.rows[0] as any).ext_buffer)
-      if (!extBuffer) return new Map<string, string>()
-      return this.parseGroupNicknamesFromExtBuffer(extBuffer, candidates)
+      return this.buildTrustedGroupNicknameMap(Object.entries(dllResult.nicknames), candidates)
     } catch (e) {
-      console.error('getGroupNicknamesForRoom error:', e)
+      console.error('getGroupNicknamesForRoom dll error:', e)
       return new Map<string, string>()
     }
   }
 
+  private normalizeGroupNicknameIdentity(value: string): string {
+    const raw = String(value || '').trim()
+    if (!raw) return ''
+    return raw.toLowerCase()
+  }
+
+  private buildTrustedGroupNicknameMap(
+    entries: Iterable<[string, string]>,
+    candidates: string[] = []
+  ): Map<string, string> {
+    const candidateSet = new Set(
+      this.buildGroupNicknameIdCandidates(candidates)
+        .map((id) => this.normalizeGroupNicknameIdentity(id))
+        .filter(Boolean)
+    )
+
+    const buckets = new Map<string, Set<string>>()
+    for (const [memberIdRaw, nicknameRaw] of entries) {
+      const identity = this.normalizeGroupNicknameIdentity(memberIdRaw || '')
+      if (!identity) continue
+      if (candidateSet.size > 0 && !candidateSet.has(identity)) continue
+
+      const nickname = this.normalizeGroupNickname(nicknameRaw || '')
+      if (!nickname) continue
+
+      const slot = buckets.get(identity)
+      if (slot) {
+        slot.add(nickname)
+      } else {
+        buckets.set(identity, new Set([nickname]))
+      }
+    }
+
+    const trusted = new Map<string, string>()
+    for (const [identity, nicknameSet] of buckets.entries()) {
+      if (nicknameSet.size !== 1) continue
+      trusted.set(identity, Array.from(nicknameSet)[0])
+    }
+    return trusted
+  }
+
+  private mergeGroupNicknameEntries(
+    target: Map<string, string>,
+    entries: Iterable<[string, string]>
+  ): void {
+    for (const [memberIdRaw, nicknameRaw] of entries) {
+      const nickname = this.normalizeGroupNickname(nicknameRaw || '')
+      if (!nickname) continue
+      for (const alias of this.buildIdCandidates([memberIdRaw])) {
+        if (!alias) continue
+        if (!target.has(alias)) target.set(alias, nickname)
+        const lower = alias.toLowerCase()
+        if (!target.has(lower)) target.set(lower, nickname)
+      }
+    }
+  }
+
   private looksLikeHex(s: string): boolean {
     if (s.length % 2 !== 0) return false
     return /^[0-9a-fA-F]+$/.test(s)
@@ -444,6 +509,16 @@ class GroupAnalyticsService {
     return Array.from(set)
   }
 
+  private buildGroupNicknameIdCandidates(values: Array<string | undefined | null>): string[] {
+    const set = new Set<string>()
+    for (const rawValue of values) {
+      const raw = String(rawValue || '').trim()
+      if (!raw) continue
+      set.add(raw)
+    }
+    return Array.from(set)
+  }
+
   private toNonNegativeInteger(value: unknown): number {
     const parsed = Number(value)
     if (!Number.isFinite(parsed)) return 0
@@ -550,19 +625,9 @@ class GroupAnalyticsService {
       const batch = candidates.slice(i, i + batchSize)
       if (batch.length === 0) continue
 
-      const inList = batch.map((username) => `'${username.replace(/'/g, "''")}'`).join(',')
-      const lightweightSql = `
-        SELECT username, user_name, encrypt_username, encrypt_user_name, remark, nick_name, alias, local_type
-        FROM contact
-        WHERE username IN (${inList})
-      `
-      let result = await wcdbService.execQuery('contact', null, lightweightSql)
-      if (!result.success || !result.rows) {
-        // 兼容历史/变体列名，轻查询失败时回退全字段查询，避免好友标识丢失
-        result = await wcdbService.execQuery('contact', null, `SELECT * FROM contact WHERE username IN (${inList})`)
-      }
-      if (!result.success || !result.rows) continue
-      appendContactsToLookup(result.rows as Record<string, unknown>[])
+      const result = await wcdbService.getContactsCompact(batch)
+      if (!result.success || !result.contacts) continue
+      appendContactsToLookup(result.contacts as Record<string, unknown>[])
     }
     return lookup
   }
@@ -642,30 +707,23 @@ class GroupAnalyticsService {
   }
 
   private resolveGroupNicknameByCandidates(groupNicknames: Map<string, string>, candidates: string[]): string {
-    const idCandidates = this.buildIdCandidates(candidates)
+    const idCandidates = this.buildGroupNicknameIdCandidates(candidates)
     if (idCandidates.length === 0) return ''
 
+    let resolved = ''
     for (const id of idCandidates) {
-      const exact = this.normalizeGroupNickname(groupNicknames.get(id) || '')
-      if (exact) return exact
-    }
-
-    for (const id of idCandidates) {
-      const lower = id.toLowerCase()
-      let found = ''
-      let matched = 0
-      for (const [key, value] of groupNicknames.entries()) {
-        if (String(key || '').toLowerCase() !== lower) continue
-        const normalized = this.normalizeGroupNickname(value || '')
-        if (!normalized) continue
-        found = normalized
-        matched += 1
-        if (matched > 1) return ''
+      const normalizedId = this.normalizeGroupNicknameIdentity(id)
+      if (!normalizedId) continue
+      const candidateNickname = this.normalizeGroupNickname(groupNicknames.get(normalizedId) || '')
+      if (!candidateNickname) continue
+      if (!resolved) {
+        resolved = candidateNickname
+        continue
       }
-      if (matched === 1 && found) return found
+      if (resolved !== candidateNickname) return ''
     }
 
-    return ''
+    return resolved
   }
 
   private sanitizeWorksheetName(name: string): string {
@@ -741,36 +799,271 @@ class GroupAnalyticsService {
     return ''
   }
 
+  private normalizeCursorTimestamp(value: number): number {
+    if (!Number.isFinite(value) || value <= 0) return 0
+    const normalized = Math.floor(value)
+    return normalized > 10000000000 ? Math.floor(normalized / 1000) : normalized
+  }
+
+  private extractRowSenderUsername(row: Record<string, any>, myWxid?: string): string {
+    const isSendRaw = row.computed_is_send ?? row.is_send ?? row.isSend ?? row.WCDB_CT_is_send
+    if (isSendRaw != null && parseInt(isSendRaw, 10) === 1 && myWxid) {
+      return myWxid
+    }
+
+    const candidates = [
+      row.sender_username,
+      row.senderUsername,
+      row.sender,
+      row.WCDB_CT_sender_username
+    ]
+    for (const candidate of candidates) {
+      const value = String(candidate || '').trim()
+      if (value) return value
+    }
+    for (const [key, value] of Object.entries(row)) {
+      const normalizedKey = key.toLowerCase()
+      if (
+        normalizedKey === 'sender_username' ||
+        normalizedKey === 'senderusername' ||
+        normalizedKey === 'sender' ||
+        normalizedKey === 'wcdb_ct_sender_username'
+      ) {
+        const normalizedValue = String(value || '').trim()
+        if (normalizedValue) return normalizedValue
+      }
+    }
+    
+    // Fallback: fast extract from raw content to avoid full parse
+    const rawContent = String(row.StrContent || row.message_content || row.content || row.msg_content || '').trim()
+    if (rawContent) {
+      const match = /^\s*([a-zA-Z0-9_@-]{4,}):(?!\/\/)\s*(?:\r?\n|<br\s*\/?>)/i.exec(rawContent)
+      if (match && match[1]) {
+        return match[1].trim()
+      }
+    }
+    
+    return ''
+  }
+
+  private parseSingleMessageRow(row: Record<string, any>): Message | null {
+    try {
+      const mapped = chatService.mapRowsToMessagesForApi([row])
+      if (Array.isArray(mapped) && mapped.length > 0) {
+        const msg = mapped[0]
+        if (!msg.localType) {
+          msg.localType = parseInt(row.Type || row.type || row.local_type || row.msg_type || '0', 10)
+        }
+        if (!msg.createTime) {
+          msg.createTime = parseInt(row.CreateTime || row.create_time || row.createTime || row.msg_time || '0', 10)
+        }
+        return msg
+      }
+      return null
+    } catch {
+      return null
+    }
+  }
+
+  private async openMemberMessageCursor(
+    chatroomId: string,
+    batchSize: number,
+    ascending: boolean,
+    startTime: number,
+    endTime: number
+  ): Promise<{ success: boolean; cursor?: number; error?: string }> {
+    const beginTimestamp = this.normalizeCursorTimestamp(startTime)
+    const endTimestamp = this.normalizeCursorTimestamp(endTime)
+    const liteResult = await wcdbService.openMessageCursorLite(chatroomId, batchSize, ascending, beginTimestamp, endTimestamp)
+    if (liteResult.success && liteResult.cursor) return liteResult
+    return wcdbService.openMessageCursor(chatroomId, batchSize, ascending, beginTimestamp, endTimestamp)
+  }
+
   private async collectMessagesByMember(
     chatroomId: string,
     memberUsername: string,
     startTime: number,
     endTime: number
   ): Promise<{ success: boolean; data?: Message[]; error?: string }> {
-    const batchSize = 500
+    const batchSize = 800
     const matchedMessages: Message[] = []
-    let offset = 0
+    const senderMatchCache = new Map<string, boolean>()
+    const matchesTargetSender = (sender: string | null | undefined): boolean => {
+      const key = String(sender || '').trim().toLowerCase()
+      if (!key) return false
+      const cached = senderMatchCache.get(key)
+      if (typeof cached === 'boolean') return cached
+      const matched = this.isSameAccountIdentity(memberUsername, sender)
+      senderMatchCache.set(key, matched)
+      return matched
+    }
 
-    while (true) {
-      const batch = await chatService.getMessages(chatroomId, offset, batchSize, startTime, endTime, true)
-      if (!batch.success || !batch.messages) {
-        return { success: false, error: batch.error || '获取群消息失败' }
-      }
+    const cursorResult = await this.openMemberMessageCursor(chatroomId, batchSize, true, startTime, endTime)
+    if (!cursorResult.success || !cursorResult.cursor) {
+      return { success: false, error: cursorResult.error || '创建群消息游标失败' }
+    }
 
-      for (const message of batch.messages) {
-        if (this.isSameAccountIdentity(memberUsername, message.senderUsername)) {
-          matchedMessages.push(message)
+    const cursor = cursorResult.cursor
+    try {
+      while (true) {
+        const batch = await wcdbService.fetchMessageBatch(cursor)
+        if (!batch.success) {
+          return { success: false, error: batch.error || '获取群消息失败' }
         }
-      }
+        const rows = Array.isArray(batch.rows) ? batch.rows as Record<string, any>[] : []
+        if (rows.length === 0) break
 
-      const fetchedCount = batch.messages.length
-      if (fetchedCount <= 0 || !batch.hasMore) break
-      offset += fetchedCount
+        for (const row of rows) {
+          const senderFromRow = this.extractRowSenderUsername(row, String(this.configService.get('myWxid') || '').trim())
+          if (senderFromRow && !matchesTargetSender(senderFromRow)) {
+            continue
+          }
+          const message = this.parseSingleMessageRow(row)
+          if (!message) continue
+          if (matchesTargetSender(message.senderUsername)) {
+            matchedMessages.push(message)
+          }
+        }
+
+        if (!batch.hasMore) break
+      }
+    } finally {
+      await wcdbService.closeMessageCursor(cursor)
     }
 
     return { success: true, data: matchedMessages }
   }
 
+  async getGroupMemberMessages(
+    chatroomId: string,
+    memberUsername: string,
+    options?: { startTime?: number; endTime?: number; limit?: number; cursor?: number }
+  ): Promise<{ success: boolean; data?: GroupMemberMessagesPage; error?: string }> {
+    try {
+      const conn = await this.ensureConnected()
+      if (!conn.success) return { success: false, error: conn.error }
+
+      const normalizedChatroomId = String(chatroomId || '').trim()
+      const normalizedMemberUsername = String(memberUsername || '').trim()
+      if (!normalizedChatroomId) return { success: false, error: '群聊ID不能为空' }
+      if (!normalizedMemberUsername) return { success: false, error: '成员ID不能为空' }
+
+      const startTimeValue = Number.isFinite(options?.startTime) && typeof options?.startTime === 'number'
+        ? Math.max(0, Math.floor(options.startTime))
+        : 0
+      const endTimeValue = Number.isFinite(options?.endTime) && typeof options?.endTime === 'number'
+        ? Math.max(0, Math.floor(options.endTime))
+        : 0
+      const limit = Number.isFinite(options?.limit) && typeof options?.limit === 'number'
+        ? Math.max(1, Math.min(100, Math.floor(options.limit)))
+        : 50
+      let cursor = Number.isFinite(options?.cursor) && typeof options?.cursor === 'number'
+        ? Math.max(0, Math.floor(options.cursor))
+        : 0
+
+      const matchedMessages: Message[] = []
+      const senderMatchCache = new Map<string, boolean>()
+      const matchesTargetSender = (sender: string | null | undefined): boolean => {
+        const key = String(sender || '').trim().toLowerCase()
+        if (!key) return false
+        const cached = senderMatchCache.get(key)
+        if (typeof cached === 'boolean') return cached
+        const matched = this.isSameAccountIdentity(normalizedMemberUsername, sender)
+        senderMatchCache.set(key, matched)
+        return matched
+      }
+      const batchSize = Math.max(limit * 4, 240)
+      let hasMore = false
+
+      const cursorResult = await this.openMemberMessageCursor(
+        normalizedChatroomId,
+        batchSize,
+        false,
+        startTimeValue,
+        endTimeValue
+      )
+      if (!cursorResult.success || !cursorResult.cursor) {
+        return { success: false, error: cursorResult.error || '创建群成员消息游标失败' }
+      }
+
+      let consumedRows = 0
+      const dbCursor = cursorResult.cursor
+
+      try {
+        while (matchedMessages.length < limit) {
+          const batch = await wcdbService.fetchMessageBatch(dbCursor)
+          if (!batch.success) {
+            return { success: false, error: batch.error || '获取群成员消息失败' }
+          }
+
+          const rows = Array.isArray(batch.rows) ? batch.rows as Record<string, any>[] : []
+          if (rows.length === 0) {
+            hasMore = false
+            break
+          }
+
+          let startIndex = 0
+          if (cursor > consumedRows) {
+            const skipCount = Math.min(cursor - consumedRows, rows.length)
+            consumedRows += skipCount
+            startIndex = skipCount
+            if (startIndex >= rows.length) {
+              if (!batch.hasMore) {
+                hasMore = false
+                break
+              }
+              continue
+            }
+          }
+
+          for (let index = startIndex; index < rows.length; index += 1) {
+            const row = rows[index]
+            consumedRows += 1
+
+            const senderFromRow = this.extractRowSenderUsername(row, String(this.configService.get('myWxid') || '').trim())
+            if (senderFromRow && !matchesTargetSender(senderFromRow)) {
+              continue
+            }
+
+            const message = this.parseSingleMessageRow(row)
+            if (!message) continue
+            if (!matchesTargetSender(message.senderUsername)) {
+              continue
+            }
+
+            matchedMessages.push(message)
+            if (matchedMessages.length >= limit) {
+              cursor = consumedRows
+              hasMore = index < rows.length - 1 || batch.hasMore === true
+              break
+            }
+          }
+
+          if (matchedMessages.length >= limit) break
+
+          cursor = consumedRows
+          if (!batch.hasMore) {
+            hasMore = false
+            break
+          }
+        }
+      } finally {
+        await wcdbService.closeMessageCursor(dbCursor)
+      }
+
+      return {
+        success: true,
+        data: {
+          messages: matchedMessages,
+          hasMore,
+          nextCursor: cursor
+        }
+      }
+    } catch (e) {
+      return { success: false, error: String(e) }
+    }
+  }
+
   async getGroupChats(): Promise<{ success: boolean; data?: GroupChatInfo[]; error?: string }> {
     try {
       const conn = await this.ensureConnected()
@@ -1207,6 +1500,154 @@ class GroupAnalyticsService {
     }
   }
 
+  async getGroupMemberAnalytics(
+    chatroomId: string,
+    memberUsername: string,
+    startTime?: number,
+    endTime?: number
+  ): Promise<{ success: boolean; data?: GroupMemberAnalytics; error?: string }> {
+    try {
+      const conn = await this.ensureConnected()
+      if (!conn.success) return { success: false, error: conn.error }
+
+      const normalizedChatroomId = String(chatroomId || '').trim()
+      const normalizedMemberUsername = String(memberUsername || '').trim()
+
+      const batchSize = 10000
+      const senderMatchCache = new Map<string, boolean>()
+      const matchesTargetSender = (sender: string | null | undefined): boolean => {
+        const key = String(sender || '').trim().toLowerCase()
+        if (!key) return false
+        const cached = senderMatchCache.get(key)
+        if (typeof cached === 'boolean') return cached
+        const matched = this.isSameAccountIdentity(normalizedMemberUsername, sender)
+        senderMatchCache.set(key, matched)
+        return matched
+      }
+
+      const cursorResult = await this.openMemberMessageCursor(normalizedChatroomId, batchSize, true, startTime || 0, endTime || 0)
+      if (!cursorResult.success || !cursorResult.cursor) {
+        return { success: false, error: cursorResult.error || '创建游标失败' }
+      }
+
+      const cursor = cursorResult.cursor
+      const stats: ChatStatistics = {
+        totalMessages: 0,
+        textMessages: 0,
+        imageMessages: 0,
+        voiceMessages: 0,
+        videoMessages: 0,
+        emojiMessages: 0,
+        otherMessages: 0,
+        sentMessages: 0, // In group, we only fetch messages of this member, so sentMessages = totalMessages
+        receivedMessages: 0, // No meaning here
+        firstMessageTime: null,
+        lastMessageTime: null,
+        activeDays: 0,
+        messageTypeCounts: {}
+      }
+      
+      const hourlyDistribution: Record<number, number> = {}
+      for (let i = 0; i < 24; i++) hourlyDistribution[i] = 0
+      const dailySet = new Set<string>()
+      const textTypes = [1, 244813135921]
+
+      const phraseCounts = new Map<string, number>()
+      const emojiCounts = new Map<string, number>()
+
+      const myWxid = String(this.configService.get('myWxid') || '').trim()
+
+      try {
+        while (true) {
+          const batch = await wcdbService.fetchMessageBatch(cursor)
+          if (!batch.success) {
+            return { success: false, error: batch.error || '获取分析数据失败' }
+          }
+          const rows = Array.isArray(batch.rows) ? batch.rows as Record<string, any>[] : []
+          if (rows.length === 0) break
+
+          for (const row of rows) {
+            let senderFromRow = this.extractRowSenderUsername(row, myWxid)
+            
+            const isSendRaw = row.computed_is_send ?? row.is_send ?? row.isSend ?? row.WCDB_CT_is_send
+            const isSend = isSendRaw != null ? parseInt(isSendRaw, 10) === 1 : false
+            
+            if (isSend) {
+              senderFromRow = myWxid
+            }
+
+            if (!senderFromRow || !matchesTargetSender(senderFromRow)) {
+              continue
+            }
+            
+            const msgType = parseInt(row.Type || row.type || row.local_type || row.msg_type || '0', 10)
+            const createTime = parseInt(row.CreateTime || row.create_time || row.createTime || row.msg_time || '0', 10)
+            
+            let content = String(row.StrContent || row.message_content || row.content || row.msg_content || '')
+            if (content) {
+              content = content.replace(/^\s*([a-zA-Z0-9_@-]{4,}):(?!\/\/)\s*(?:\r?\n|<br\s*\/?>)/i, '')
+            }
+
+            stats.totalMessages++
+            if (textTypes.includes(msgType)) {
+              stats.textMessages++
+              if (content) {
+                const text = content.trim()
+                if (text && text.length <= 20) {
+                  phraseCounts.set(text, (phraseCounts.get(text) || 0) + 1)
+                }
+                const emojiMatches = text.match(/\[.*?\]/g)
+                if (emojiMatches) {
+                  for (const em of emojiMatches) {
+                    emojiCounts.set(em, (emojiCounts.get(em) || 0) + 1)
+                  }
+                }
+              }
+            }
+            else if (msgType === 3) stats.imageMessages++
+            else if (msgType === 34) stats.voiceMessages++
+            else if (msgType === 43) stats.videoMessages++
+            else if (msgType === 47) stats.emojiMessages++
+            else stats.otherMessages++
+
+            stats.sentMessages++
+            
+            stats.messageTypeCounts[msgType] = (stats.messageTypeCounts[msgType] || 0) + 1
+            
+            if (createTime > 0) {
+              if (stats.firstMessageTime === null || createTime < stats.firstMessageTime) stats.firstMessageTime = createTime
+              if (stats.lastMessageTime === null || createTime > stats.lastMessageTime) stats.lastMessageTime = createTime
+              
+              const d = new Date(createTime * 1000)
+              const hour = d.getHours()
+              hourlyDistribution[hour]++
+              dailySet.add(`${d.getFullYear()}-${d.getMonth()}-${d.getDate()}`)
+            }
+          }
+          if (!batch.hasMore) break
+        }
+      } finally {
+        await wcdbService.closeMessageCursor(cursor)
+      }
+      
+      stats.activeDays = dailySet.size
+
+      const commonPhrases = Array.from(phraseCounts.entries())
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 10)
+        .map(([phrase, count]) => ({ phrase, count }))
+        
+      const commonEmojis = Array.from(emojiCounts.entries())
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 10)
+        .map(([emoji, count]) => ({ emoji, count }))
+
+      return { success: true, data: { statistics: stats, timeDistribution: hourlyDistribution, commonPhrases, commonEmojis } }
+    } catch (e) {
+      return { success: false, error: String(e) }
+    }
+  }
+
   async exportGroupMemberMessages(
     chatroomId: string,
     memberUsername: string,

electron/services/httpService.ts

@@ -11,6 +11,8 @@ import { wcdbService } from './wcdbService'
 import { ConfigService } from './config'
 import { videoService } from './videoService'
 import { imageDecryptService } from './imageDecryptService'
+import { groupAnalyticsService } from './groupAnalyticsService'
+import { snsService } from './snsService'
 
 // ChatLab 格式定义
 interface ChatLabHeader {
@@ -100,8 +102,11 @@ class HttpService {
   private server: http.Server | null = null
   private configService: ConfigService
   private port: number = 5031
+  private host: string = '127.0.0.1'
   private running: boolean = false
   private connections: Set<import('net').Socket> = new Set()
+  private messagePushClients: Set<http.ServerResponse> = new Set()
+  private messagePushHeartbeatTimer: ReturnType<typeof setInterval> | null = null
   private connectionMutex: boolean = false
 
   constructor() {
@@ -111,12 +116,13 @@ class HttpService {
   /**
    * 启动 HTTP 服务
    */
-  async start(port: number = 5031): Promise<{ success: boolean; port?: number; error?: string }> {
+  async start(port: number = 5031, host: string = '127.0.0.1'): Promise<{ success: boolean; port?: number; error?: string }> {
     if (this.running && this.server) {
       return { success: true, port: this.port }
     }
 
     this.port = port
+    this.host = host
 
     return new Promise((resolve) => {
       this.server = http.createServer((req, res) => this.handleRequest(req, res))
@@ -150,9 +156,10 @@ class HttpService {
         }
       })
 
-      this.server.listen(this.port, '127.0.0.1', () => {
+      this.server.listen(this.port, this.host, () => {
         this.running = true
-        console.log(`[HttpService] HTTP API server started on http://127.0.0.1:${this.port}`)
+        this.startMessagePushHeartbeat()
+        console.log(`[HttpService] HTTP API server started on http://${this.host}:${this.port}`)
         resolve({ success: true, port: this.port })
       })
     })
@@ -164,6 +171,16 @@ class HttpService {
   async stop(): Promise<void> {
     return new Promise((resolve) => {
       if (this.server) {
+        for (const client of this.messagePushClients) {
+          try {
+            client.end()
+          } catch {}
+        }
+        this.messagePushClients.clear()
+        if (this.messagePushHeartbeatTimer) {
+          clearInterval(this.messagePushHeartbeatTimer)
+          this.messagePushHeartbeatTimer = null
+        }
         // 使用互斥锁保护连接集合操作
         this.connectionMutex = true
         const socketsToClose = Array.from(this.connections)
@@ -210,43 +227,207 @@ class HttpService {
     return this.getApiMediaExportPath()
   }
 
-  /**
-   * 处理 HTTP 请求
-   */
-  private async handleRequest(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
-    // 设置 CORS 头
-    res.setHeader('Access-Control-Allow-Origin', '*')
-    res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS')
-    res.setHeader('Access-Control-Allow-Headers', 'Content-Type')
+  getMessagePushStreamUrl(): string {
+    return `http://${this.host}:${this.port}/api/v1/push/messages`
+  }
 
-    if (req.method === 'OPTIONS') {
-      res.writeHead(204)
-      res.end()
+  broadcastMessagePush(payload: Record<string, unknown>): void {
+    if (!this.running || this.messagePushClients.size === 0) return
+    const eventBody = `event: message.new\ndata: ${JSON.stringify(payload)}\n\n`
+
+    for (const client of Array.from(this.messagePushClients)) {
+      try {
+        if (client.writableEnded || client.destroyed) {
+          this.messagePushClients.delete(client)
+          continue
+        }
+        client.write(eventBody)
+      } catch {
+        this.messagePushClients.delete(client)
+        try { client.end() } catch {}
+      }
+    }
+  }
+
+  async autoStart(): Promise<void> {
+    const enabled = this.configService.get('httpApiEnabled')
+    if (enabled) {
+      const port = Number(this.configService.get('httpApiPort')) || 5031
+      const host = String(this.configService.get('httpApiHost') || '127.0.0.1').trim() || '127.0.0.1'
+      try {
+        await this.start(port, host)
+        console.log(`[HttpService] Auto-started on port ${port}`)
+      } catch (err) {
+        console.error('[HttpService] Auto-start failed:', err)
+      }
+    }
+  }
+
+    /**
+     * 解析 POST 请求的 JSON Body
+     */
+    private async parseBody(req: http.IncomingMessage): Promise<Record<string, any>> {
+        if (req.method !== 'POST') return {}
+        return new Promise((resolve) => {
+            let body = ''
+            req.on('data', chunk => { body += chunk.toString() })
+            req.on('end', () => {
+                try {
+                    resolve(JSON.parse(body))
+                } catch {
+                    resolve({})
+                }
+            })
+            req.on('error', () => resolve({}))
+        })
+    }
+
+    /**
+     * 鉴权拦截器
+     */
+    private verifyToken(req: http.IncomingMessage, url: URL, body: Record<string, any>): boolean {
+        const expectedToken = String(this.configService.get('httpApiToken') || '').trim()
+        if (!expectedToken) return true
+
+        const authHeader = req.headers.authorization
+        if (authHeader && authHeader.toLowerCase().startsWith('bearer ')) {
+            const token = authHeader.substring(7).trim()
+            if (token === expectedToken) return true
+        }
+
+        const queryToken = url.searchParams.get('access_token')
+        if (queryToken && queryToken.trim() === expectedToken) return true
+
+        const bodyToken = body['access_token']
+        return !!(bodyToken && String(bodyToken).trim() === expectedToken);
+
+
+    }
+
+    /**
+     * 处理 HTTP 请求 (重构后)
+     */
+    private async handleRequest(req: http.IncomingMessage, res: http.ServerResponse): Promise<void> {
+        res.setHeader('Access-Control-Allow-Origin', '*')
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS')
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization')
+
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204)
+            res.end()
+            return
+        }
+
+        const url = new URL(req.url || '/', `http://${this.host}:${this.port}`)
+        const pathname = url.pathname
+
+        try {
+            const bodyParams = await this.parseBody(req)
+
+            for (const [key, value] of Object.entries(bodyParams)) {
+                if (!url.searchParams.has(key)) {
+                    url.searchParams.set(key, String(value))
+                }
+            }
+
+            if (pathname !== '/health' && pathname !== '/api/v1/health') {
+                if (!this.verifyToken(req, url, bodyParams)) {
+                    this.sendError(res, 401, 'Unauthorized: Invalid or missing access_token')
+                    return
+                }
+            }
+
+            if (pathname === '/health' || pathname === '/api/v1/health') {
+                this.sendJson(res, { status: 'ok' })
+            } else if (pathname === '/api/v1/push/messages') {
+                this.handleMessagePushStream(req, res)
+            } else if (pathname === '/api/v1/messages') {
+                await this.handleMessages(url, res)
+            } else if (pathname === '/api/v1/sessions') {
+                await this.handleSessions(url, res)
+            } else if (pathname === '/api/v1/contacts') {
+                await this.handleContacts(url, res)
+            } else if (pathname === '/api/v1/group-members') {
+                await this.handleGroupMembers(url, res)
+            } else if (pathname === '/api/v1/sns/timeline') {
+                if (req.method !== 'GET') return this.sendMethodNotAllowed(res, 'GET')
+                await this.handleSnsTimeline(url, res)
+            } else if (pathname === '/api/v1/sns/usernames') {
+                if (req.method !== 'GET') return this.sendMethodNotAllowed(res, 'GET')
+                await this.handleSnsUsernames(res)
+            } else if (pathname === '/api/v1/sns/export/stats') {
+                if (req.method !== 'GET') return this.sendMethodNotAllowed(res, 'GET')
+                await this.handleSnsExportStats(url, res)
+            } else if (pathname === '/api/v1/sns/media/proxy') {
+                if (req.method !== 'GET') return this.sendMethodNotAllowed(res, 'GET')
+                await this.handleSnsMediaProxy(url, res)
+            } else if (pathname === '/api/v1/sns/export') {
+                if (req.method !== 'POST') return this.sendMethodNotAllowed(res, 'POST')
+                await this.handleSnsExport(url, res)
+            } else if (pathname === '/api/v1/sns/block-delete/status') {
+                if (req.method !== 'GET') return this.sendMethodNotAllowed(res, 'GET')
+                await this.handleSnsBlockDeleteStatus(res)
+            } else if (pathname === '/api/v1/sns/block-delete/install') {
+                if (req.method !== 'POST') return this.sendMethodNotAllowed(res, 'POST')
+                await this.handleSnsBlockDeleteInstall(res)
+            } else if (pathname === '/api/v1/sns/block-delete/uninstall') {
+                if (req.method !== 'POST') return this.sendMethodNotAllowed(res, 'POST')
+                await this.handleSnsBlockDeleteUninstall(res)
+            } else if (pathname.startsWith('/api/v1/sns/post/')) {
+                if (req.method !== 'DELETE') return this.sendMethodNotAllowed(res, 'DELETE')
+                await this.handleSnsDeletePost(pathname, res)
+            } else if (pathname.startsWith('/api/v1/media/')) {
+                this.handleMediaRequest(pathname, res)
+            } else {
+                this.sendError(res, 404, 'Not Found')
+            }
+        } catch (error) {
+            console.error('[HttpService] Request error:', error)
+            this.sendError(res, 500, String(error))
+        }
+    }
+  private startMessagePushHeartbeat(): void {
+    if (this.messagePushHeartbeatTimer) return
+    this.messagePushHeartbeatTimer = setInterval(() => {
+      for (const client of Array.from(this.messagePushClients)) {
+        try {
+          if (client.writableEnded || client.destroyed) {
+            this.messagePushClients.delete(client)
+            continue
+          }
+          client.write(': ping\n\n')
+        } catch {
+          this.messagePushClients.delete(client)
+          try { client.end() } catch {}
+        }
+      }
+    }, 25000)
+  }
+
+  private handleMessagePushStream(req: http.IncomingMessage, res: http.ServerResponse): void {
+    if (this.configService.get('messagePushEnabled') !== true) {
+      this.sendError(res, 403, 'Message push is disabled')
       return
     }
 
-    const url = new URL(req.url || '/', `http://127.0.0.1:${this.port}`)
-    const pathname = url.pathname
+    res.writeHead(200, {
+      'Content-Type': 'text/event-stream; charset=utf-8',
+      'Cache-Control': 'no-cache, no-transform',
+      Connection: 'keep-alive',
+      'X-Accel-Buffering': 'no'
+    })
+    res.flushHeaders?.()
+    res.write(`event: ready\ndata: ${JSON.stringify({ success: true, stream: this.getMessagePushStreamUrl() })}\n\n`)
 
-    try {
-      // 路由处理
-      if (pathname === '/health' || pathname === '/api/v1/health') {
-        this.sendJson(res, { status: 'ok' })
-      } else if (pathname === '/api/v1/messages') {
-        await this.handleMessages(url, res)
-      } else if (pathname === '/api/v1/sessions') {
-        await this.handleSessions(url, res)
-      } else if (pathname === '/api/v1/contacts') {
-        await this.handleContacts(url, res)
-      } else if (pathname.startsWith('/api/v1/media/')) {
-        this.handleMediaRequest(pathname, res)
-      } else {
-        this.sendError(res, 404, 'Not Found')
-      }
-    } catch (error) {
-      console.error('[HttpService] Request error:', error)
-      this.sendError(res, 500, String(error))
+    this.messagePushClients.add(res)
+
+    const cleanup = () => {
+      this.messagePushClients.delete(res)
     }
+
+    req.on('close', cleanup)
+    res.on('close', cleanup)
+    res.on('error', cleanup)
   }
 
   private handleMediaRequest(pathname: string, res: http.ServerResponse): void {
@@ -406,6 +587,15 @@ class HttpService {
     return defaultValue
   }
 
+  private parseStringListParam(value: string | null): string[] | undefined {
+    if (!value) return undefined
+    const values = value
+      .split(',')
+      .map((item) => item.trim())
+      .filter(Boolean)
+    return values.length > 0 ? Array.from(new Set(values)) : undefined
+  }
+
   private parseMediaOptions(url: URL): ApiMediaOptions {
     const mediaEnabled = this.parseBooleanParam(url, ['media', 'meiti'], false)
     if (!mediaEnabled) {
@@ -589,6 +779,361 @@ class HttpService {
     }
   }
 
+  /**
+   * 处理群成员查询
+   * GET /api/v1/group-members?chatroomId=xxx@chatroom&includeMessageCounts=1&forceRefresh=0
+   */
+  private async handleGroupMembers(url: URL, res: http.ServerResponse): Promise<void> {
+    const chatroomId = (url.searchParams.get('chatroomId') || url.searchParams.get('talker') || '').trim()
+    const includeMessageCounts = this.parseBooleanParam(url, ['includeMessageCounts', 'withCounts'], false)
+    const forceRefresh = this.parseBooleanParam(url, ['forceRefresh'], false)
+
+    if (!chatroomId) {
+      this.sendError(res, 400, 'Missing chatroomId')
+      return
+    }
+
+    try {
+      const result = await groupAnalyticsService.getGroupMembersPanelData(chatroomId, {
+        forceRefresh,
+        includeMessageCounts
+      })
+      if (!result.success || !result.data) {
+        this.sendError(res, 500, result.error || 'Failed to get group members')
+        return
+      }
+
+      this.sendJson(res, {
+        success: true,
+        chatroomId,
+        count: result.data.length,
+        fromCache: result.fromCache,
+        updatedAt: result.updatedAt,
+        members: result.data.map((member) => ({
+          wxid: member.username,
+          displayName: member.displayName,
+          nickname: member.nickname || '',
+          remark: member.remark || '',
+          alias: member.alias || '',
+          groupNickname: member.groupNickname || '',
+          avatarUrl: member.avatarUrl,
+          isOwner: Boolean(member.isOwner),
+          isFriend: Boolean(member.isFriend),
+          messageCount: Number.isFinite(member.messageCount) ? member.messageCount : 0
+        }))
+      })
+    } catch (error) {
+      this.sendError(res, 500, String(error))
+    }
+  }
+
+  private async handleSnsTimeline(url: URL, res: http.ServerResponse): Promise<void> {
+    const limit = this.parseIntParam(url.searchParams.get('limit'), 20, 1, 200)
+    const offset = this.parseIntParam(url.searchParams.get('offset'), 0, 0, Number.MAX_SAFE_INTEGER)
+    const usernames = this.parseStringListParam(url.searchParams.get('usernames'))
+    const keyword = (url.searchParams.get('keyword') || '').trim() || undefined
+    const resolveMedia = this.parseBooleanParam(url, ['media', 'resolveMedia', 'meiti'], true)
+    const inlineMedia = resolveMedia && this.parseBooleanParam(url, ['inline'], false)
+    const replaceMedia = resolveMedia && this.parseBooleanParam(url, ['replace'], true)
+    const startTimeRaw = this.parseTimeParam(url.searchParams.get('start'))
+    const endTimeRaw = this.parseTimeParam(url.searchParams.get('end'), true)
+    const startTime = startTimeRaw > 0 ? startTimeRaw : undefined
+    const endTime = endTimeRaw > 0 ? endTimeRaw : undefined
+
+    const result = await snsService.getTimeline(limit, offset, usernames, keyword, startTime, endTime)
+    if (!result.success) {
+      this.sendError(res, 500, result.error || 'Failed to get sns timeline')
+      return
+    }
+
+    let timeline = result.timeline || []
+    if (resolveMedia && timeline.length > 0) {
+      timeline = await this.enrichSnsTimelineMedia(timeline, inlineMedia, replaceMedia)
+    }
+
+    this.sendJson(res, {
+      success: true,
+      count: timeline.length,
+      timeline
+    })
+  }
+
+  private async handleSnsUsernames(res: http.ServerResponse): Promise<void> {
+    const result = await snsService.getSnsUsernames()
+    if (!result.success) {
+      this.sendError(res, 500, result.error || 'Failed to get sns usernames')
+      return
+    }
+    this.sendJson(res, {
+      success: true,
+      usernames: result.usernames || []
+    })
+  }
+
+  private async handleSnsExportStats(url: URL, res: http.ServerResponse): Promise<void> {
+    const fast = this.parseBooleanParam(url, ['fast'], false)
+    const result = fast
+      ? await snsService.getExportStatsFast()
+      : await snsService.getExportStats()
+    if (!result.success) {
+      this.sendError(res, 500, result.error || 'Failed to get sns export stats')
+      return
+    }
+    this.sendJson(res, result)
+  }
+
+  private async handleSnsMediaProxy(url: URL, res: http.ServerResponse): Promise<void> {
+    const mediaUrl = (url.searchParams.get('url') || '').trim()
+    if (!mediaUrl) {
+      this.sendError(res, 400, 'Missing required parameter: url')
+      return
+    }
+
+    const key = this.toSnsMediaKey(url.searchParams.get('key'))
+    const result = await snsService.downloadImage(mediaUrl, key)
+    if (!result.success) {
+      this.sendError(res, 502, result.error || 'Failed to proxy sns media')
+      return
+    }
+
+    if (result.data) {
+      res.setHeader('Content-Type', result.contentType || 'application/octet-stream')
+      res.setHeader('Content-Length', result.data.length)
+      res.writeHead(200)
+      res.end(result.data)
+      return
+    }
+
+    if (result.cachePath && fs.existsSync(result.cachePath)) {
+      try {
+        const stat = fs.statSync(result.cachePath)
+        res.setHeader('Content-Type', result.contentType || 'application/octet-stream')
+        res.setHeader('Content-Length', stat.size)
+        res.writeHead(200)
+
+        const stream = fs.createReadStream(result.cachePath)
+        stream.on('error', () => {
+          if (!res.headersSent) {
+            this.sendError(res, 500, 'Failed to read proxied sns media')
+          } else {
+            try { res.destroy() } catch {}
+          }
+        })
+        stream.pipe(res)
+        return
+      } catch (error) {
+        console.error('[HttpService] Failed to stream sns media cache:', error)
+      }
+    }
+
+    this.sendError(res, 502, result.error || 'Failed to proxy sns media')
+  }
+
+  private async handleSnsExport(url: URL, res: http.ServerResponse): Promise<void> {
+    const outputDir = String(url.searchParams.get('outputDir') || '').trim()
+    if (!outputDir) {
+      this.sendError(res, 400, 'Missing required field: outputDir')
+      return
+    }
+
+    const rawFormat = String(url.searchParams.get('format') || 'json').trim().toLowerCase()
+    const format = rawFormat === 'arkme-json' ? 'arkmejson' : rawFormat
+    if (!['json', 'html', 'arkmejson'].includes(format)) {
+      this.sendError(res, 400, 'Invalid format, supported: json/html/arkmejson')
+      return
+    }
+
+    const usernames = this.parseStringListParam(url.searchParams.get('usernames'))
+    const keyword = String(url.searchParams.get('keyword') || '').trim() || undefined
+    const startTimeRaw = this.parseTimeParam(url.searchParams.get('start'))
+    const endTimeRaw = this.parseTimeParam(url.searchParams.get('end'), true)
+
+    const options: {
+      outputDir: string
+      format: 'json' | 'html' | 'arkmejson'
+      usernames?: string[]
+      keyword?: string
+      exportMedia?: boolean
+      exportImages?: boolean
+      exportLivePhotos?: boolean
+      exportVideos?: boolean
+      startTime?: number
+      endTime?: number
+    } = {
+      outputDir,
+      format: format as 'json' | 'html' | 'arkmejson',
+      usernames,
+      keyword,
+      exportMedia: this.parseBooleanParam(url, ['exportMedia'], false)
+    }
+
+    if (url.searchParams.has('exportImages')) options.exportImages = this.parseBooleanParam(url, ['exportImages'], false)
+    if (url.searchParams.has('exportLivePhotos')) options.exportLivePhotos = this.parseBooleanParam(url, ['exportLivePhotos'], false)
+    if (url.searchParams.has('exportVideos')) options.exportVideos = this.parseBooleanParam(url, ['exportVideos'], false)
+    if (startTimeRaw > 0) options.startTime = startTimeRaw
+    if (endTimeRaw > 0) options.endTime = endTimeRaw
+
+    const result = await snsService.exportTimeline(options)
+    if (!result.success) {
+      this.sendError(res, 500, result.error || 'Failed to export sns timeline')
+      return
+    }
+    this.sendJson(res, result)
+  }
+
+  private async handleSnsBlockDeleteStatus(res: http.ServerResponse): Promise<void> {
+    const result = await snsService.checkSnsBlockDeleteTrigger()
+    if (!result.success) {
+      this.sendError(res, 500, result.error || 'Failed to check sns block-delete status')
+      return
+    }
+    this.sendJson(res, result)
+  }
+
+  private async handleSnsBlockDeleteInstall(res: http.ServerResponse): Promise<void> {
+    const result = await snsService.installSnsBlockDeleteTrigger()
+    if (!result.success) {
+      this.sendError(res, 500, result.error || 'Failed to install sns block-delete trigger')
+      return
+    }
+    this.sendJson(res, result)
+  }
+
+  private async handleSnsBlockDeleteUninstall(res: http.ServerResponse): Promise<void> {
+    const result = await snsService.uninstallSnsBlockDeleteTrigger()
+    if (!result.success) {
+      this.sendError(res, 500, result.error || 'Failed to uninstall sns block-delete trigger')
+      return
+    }
+    this.sendJson(res, result)
+  }
+
+  private async handleSnsDeletePost(pathname: string, res: http.ServerResponse): Promise<void> {
+    const postId = decodeURIComponent(pathname.replace('/api/v1/sns/post/', '')).trim()
+    if (!postId) {
+      this.sendError(res, 400, 'Missing required path parameter: postId')
+      return
+    }
+
+    const result = await snsService.deleteSnsPost(postId)
+    if (!result.success) {
+      this.sendError(res, 500, result.error || 'Failed to delete sns post')
+      return
+    }
+    this.sendJson(res, result)
+  }
+
+  private toSnsMediaKey(value: unknown): string | number | undefined {
+    if (value == null) return undefined
+    if (typeof value === 'number' && Number.isFinite(value)) return value
+    const text = String(value).trim()
+    if (!text) return undefined
+    if (/^-?\d+$/.test(text)) return Number(text)
+    return text
+  }
+
+  private buildSnsMediaProxyUrl(rawUrl: string, key?: string | number): string | undefined {
+    const target = String(rawUrl || '').trim()
+    if (!target) return undefined
+    const params = new URLSearchParams({ url: target })
+    if (key !== undefined) params.set('key', String(key))
+    return `http://${this.host}:${this.port}/api/v1/sns/media/proxy?${params.toString()}`
+  }
+
+  private async resolveSnsMediaUrl(
+    rawUrl: string,
+    key: string | number | undefined,
+    inline: boolean
+  ): Promise<{ resolvedUrl?: string; proxyUrl?: string }> {
+    const proxyUrl = this.buildSnsMediaProxyUrl(rawUrl, key)
+    if (!proxyUrl) return {}
+    if (!inline) return { resolvedUrl: proxyUrl, proxyUrl }
+
+    try {
+      const resolved = await snsService.proxyImage(rawUrl, key)
+      if (resolved.success && resolved.dataUrl) {
+        return { resolvedUrl: resolved.dataUrl, proxyUrl }
+      }
+    } catch (error) {
+      console.warn('[HttpService] resolveSnsMediaUrl inline failed:', error)
+    }
+
+    return { resolvedUrl: proxyUrl, proxyUrl }
+  }
+
+  private async enrichSnsTimelineMedia(posts: any[], inline: boolean, replace: boolean): Promise<any[]> {
+    return Promise.all(
+      (posts || []).map(async (post) => {
+        const mediaList = Array.isArray(post?.media) ? post.media : []
+        if (mediaList.length === 0) return post
+
+        const nextMedia = await Promise.all(
+          mediaList.map(async (media: any) => {
+            const rawUrl = typeof media?.url === 'string' ? media.url : ''
+            const rawThumb = typeof media?.thumb === 'string' ? media.thumb : ''
+            const mediaKey = this.toSnsMediaKey(media?.key)
+
+            const [urlResolved, thumbResolved] = await Promise.all([
+              this.resolveSnsMediaUrl(rawUrl, mediaKey, inline),
+              this.resolveSnsMediaUrl(rawThumb, mediaKey, inline)
+            ])
+
+            const nextItem: any = {
+              ...media,
+              rawUrl,
+              rawThumb,
+              resolvedUrl: urlResolved.resolvedUrl,
+              resolvedThumbUrl: thumbResolved.resolvedUrl,
+              proxyUrl: urlResolved.proxyUrl,
+              proxyThumbUrl: thumbResolved.proxyUrl
+            }
+
+            if (replace) {
+              nextItem.url = urlResolved.resolvedUrl || rawUrl
+              nextItem.thumb = thumbResolved.resolvedUrl || rawThumb
+            }
+
+            if (media?.livePhoto && typeof media.livePhoto === 'object') {
+              const livePhoto = media.livePhoto
+              const rawLiveUrl = typeof livePhoto.url === 'string' ? livePhoto.url : ''
+              const rawLiveThumb = typeof livePhoto.thumb === 'string' ? livePhoto.thumb : ''
+              const liveKey = this.toSnsMediaKey(livePhoto.key ?? mediaKey)
+
+              const [liveUrlResolved, liveThumbResolved] = await Promise.all([
+                this.resolveSnsMediaUrl(rawLiveUrl, liveKey, inline),
+                this.resolveSnsMediaUrl(rawLiveThumb, liveKey, inline)
+              ])
+
+              const nextLive: any = {
+                ...livePhoto,
+                rawUrl: rawLiveUrl,
+                rawThumb: rawLiveThumb,
+                resolvedUrl: liveUrlResolved.resolvedUrl,
+                resolvedThumbUrl: liveThumbResolved.resolvedUrl,
+                proxyUrl: liveUrlResolved.proxyUrl,
+                proxyThumbUrl: liveThumbResolved.proxyUrl
+              }
+
+              if (replace) {
+                nextLive.url = liveUrlResolved.resolvedUrl || rawLiveUrl
+                nextLive.thumb = liveThumbResolved.resolvedUrl || rawLiveThumb
+              }
+
+              nextItem.livePhoto = nextLive
+            }
+
+            return nextItem
+          })
+        )
+
+        return {
+          ...post,
+          media: nextMedia
+        }
+      })
+    )
+  }
+
   private getApiMediaExportPath(): string {
     return path.join(this.configService.getCacheBasePath(), 'api-media')
   }
@@ -763,7 +1308,7 @@ class HttpService {
       parsedContent: msg.parsedContent,
       mediaType: media?.kind,
       mediaFileName: media?.fileName,
-      mediaUrl: media ? `http://127.0.0.1:${this.port}/api/v1/media/${media.relativePath}` : undefined,
+      mediaUrl: media ? `http://${this.host}:${this.port}/api/v1/media/${media.relativePath}` : undefined,
       mediaLocalPath: media?.fullPath
     }
   }
@@ -798,6 +1343,20 @@ class HttpService {
     return 0
   }
 
+  private normalizeAccountId(value: string): string {
+    const trimmed = String(value || '').trim()
+    if (!trimmed) return trimmed
+
+    if (trimmed.toLowerCase().startsWith('wxid_')) {
+      const match = trimmed.match(/^(wxid_[^_]+)/i)
+      if (match) return match[1]
+      return trimmed
+    }
+
+    const suffixMatch = trimmed.match(/^(.+)_([a-zA-Z0-9]{4})$/)
+    return suffixMatch ? suffixMatch[1] : trimmed
+  }
+
   /**
    * 获取显示名称
    */
@@ -814,9 +1373,88 @@ class HttpService {
     return {}
   }
 
+  private async getAvatarUrls(usernames: string[]): Promise<Record<string, string>> {
+    const lookupUsernames = Array.from(new Set(
+      usernames.flatMap((username) => {
+        const normalized = String(username || '').trim()
+        if (!normalized) return []
+        const cleaned = this.normalizeAccountId(normalized)
+        return cleaned && cleaned !== normalized ? [normalized, cleaned] : [normalized]
+      })
+    ))
+
+    if (lookupUsernames.length === 0) return {}
+
+    try {
+      const result = await wcdbService.getAvatarUrls(lookupUsernames)
+      if (result.success && result.map) {
+        const avatarMap: Record<string, string> = {}
+        for (const [username, avatarUrl] of Object.entries(result.map)) {
+          const normalizedUsername = String(username || '').trim()
+          const normalizedAvatarUrl = String(avatarUrl || '').trim()
+          if (!normalizedUsername || !normalizedAvatarUrl) continue
+
+          avatarMap[normalizedUsername] = normalizedAvatarUrl
+          avatarMap[normalizedUsername.toLowerCase()] = normalizedAvatarUrl
+
+          const cleaned = this.normalizeAccountId(normalizedUsername)
+          if (cleaned) {
+            avatarMap[cleaned] = normalizedAvatarUrl
+            avatarMap[cleaned.toLowerCase()] = normalizedAvatarUrl
+          }
+        }
+        return avatarMap
+      }
+    } catch (e) {
+      console.error('[HttpService] Failed to get avatar urls:', e)
+    }
+
+    return {}
+  }
+
+  private resolveAvatarUrl(avatarMap: Record<string, string>, candidates: Array<string | undefined | null>): string | undefined {
+    for (const candidate of candidates) {
+      const normalized = String(candidate || '').trim()
+      if (!normalized) continue
+
+      const cleaned = this.normalizeAccountId(normalized)
+      const avatarUrl = avatarMap[normalized]
+        || avatarMap[normalized.toLowerCase()]
+        || avatarMap[cleaned]
+        || avatarMap[cleaned.toLowerCase()]
+
+      if (avatarUrl) return avatarUrl
+    }
+
+    return undefined
+  }
+
   private lookupGroupNickname(groupNicknamesMap: Map<string, string>, sender: string): string {
-    if (!sender) return ''
-    return groupNicknamesMap.get(sender) || groupNicknamesMap.get(sender.toLowerCase()) || ''
+    const key = String(sender || '').trim().toLowerCase()
+    if (!key) return ''
+    return groupNicknamesMap.get(key) || ''
+  }
+
+  private buildTrustedGroupNicknameMap(nicknames: Record<string, string>): Map<string, string> {
+    const buckets = new Map<string, Set<string>>()
+    for (const [memberIdRaw, nicknameRaw] of Object.entries(nicknames || {})) {
+      const memberId = String(memberIdRaw || '').trim().toLowerCase()
+      const nickname = String(nicknameRaw || '').trim()
+      if (!memberId || !nickname) continue
+      const slot = buckets.get(memberId)
+      if (slot) {
+        slot.add(nickname)
+      } else {
+        buckets.set(memberId, new Set([nickname]))
+      }
+    }
+
+    const trusted = new Map<string, string>()
+    for (const [memberId, nicknameSet] of buckets.entries()) {
+      if (nicknameSet.size !== 1) continue
+      trusted.set(memberId, Array.from(nicknameSet)[0])
+    }
+    return trusted
   }
 
   private resolveChatLabSenderInfo(
@@ -868,6 +1506,7 @@ class HttpService {
   ): Promise<ChatLabData> {
     const isGroup = talkerId.endsWith('@chatroom')
     const myWxid = this.configService.get('myWxid') || ''
+    const normalizedMyWxid = this.normalizeAccountId(myWxid).toLowerCase()
 
     // 收集所有发送者
     const senderSet = new Set<string>()
@@ -886,7 +1525,7 @@ class HttpService {
       try {
         const result = await wcdbService.getGroupNicknames(talkerId)
         if (result.success && result.nicknames) {
-          groupNicknamesMap = new Map(Object.entries(result.nicknames))
+          groupNicknamesMap = this.buildTrustedGroupNicknameMap(result.nicknames)
         }
       } catch (e) {
         console.error('[HttpService] Failed to get group nicknames:', e)
@@ -906,6 +1545,27 @@ class HttpService {
       }
     }
 
+    const [memberAvatarMap, myAvatarResult, sessionAvatarInfo] = await Promise.all([
+      this.getAvatarUrls(Array.from(memberMap.keys()).filter((sender) => !sender.startsWith('unknown_sender_'))),
+      myWxid
+        ? chatService.getMyAvatarUrl()
+        : Promise.resolve<{ success: boolean; avatarUrl?: string }>({ success: true }),
+      isGroup ? chatService.getContactAvatar(talkerId) : Promise.resolve(null)
+    ])
+
+    for (const [sender, member] of memberMap.entries()) {
+      if (sender.startsWith('unknown_sender_')) continue
+
+      const normalizedSender = this.normalizeAccountId(sender).toLowerCase()
+      const isSelfMember = Boolean(normalizedMyWxid && normalizedSender && normalizedSender === normalizedMyWxid)
+      const avatarUrl = (isSelfMember ? myAvatarResult.avatarUrl : undefined)
+        || this.resolveAvatarUrl(memberAvatarMap, isSelfMember ? [sender, myWxid] : [sender])
+
+      if (avatarUrl) {
+        member.avatar = avatarUrl
+      }
+    }
+
     // 转换消息
     const chatLabMessages: ChatLabMessage[] = messages.map(msg => {
       const senderInfo = this.resolveChatLabSenderInfo(msg, talkerId, talkerName, myWxid, isGroup, senderNames, groupNicknamesMap)
@@ -918,7 +1578,7 @@ class HttpService {
         type: this.mapMessageType(msg.localType, msg),
         content: this.getMessageContent(msg),
         platformMessageId: msg.serverId ? String(msg.serverId) : undefined,
-        mediaPath: mediaMap.get(msg.localId) ? `http://127.0.0.1:${this.port}/api/v1/media/${mediaMap.get(msg.localId)!.relativePath}` : undefined
+        mediaPath: mediaMap.get(msg.localId) ? `http://${this.host}:${this.port}/api/v1/media/${mediaMap.get(msg.localId)!.relativePath}` : undefined
       }
     })
 
@@ -933,6 +1593,7 @@ class HttpService {
         platform: 'wechat',
         type: isGroup ? 'group' : 'private',
         groupId: isGroup ? talkerId : undefined,
+        groupAvatar: isGroup ? sessionAvatarInfo?.avatarUrl : undefined,
         ownerId: myWxid || undefined
       },
       members: Array.from(memberMap.values()),
@@ -982,7 +1643,7 @@ class HttpService {
    * 映射 Type 49 子类型
    */
   private mapType49(msg: Message): number {
-    const xmlType = msg.xmlType
+    const xmlType = this.resolveType49Subtype(msg)
 
     switch (xmlType) {
       case '5': // 链接
@@ -1006,10 +1667,97 @@ class HttpService {
     }
   }
 
+  private extractType49Subtype(rawContent: string): string {
+    const content = String(rawContent || '')
+    if (!content) return ''
+
+    const appmsgMatch = /<appmsg[\s\S]*?>([\s\S]*?)<\/appmsg>/i.exec(content)
+    if (appmsgMatch) {
+      const appmsgInner = appmsgMatch[1]
+        .replace(/<refermsg[\s\S]*?<\/refermsg>/gi, '')
+        .replace(/<patMsg[\s\S]*?<\/patMsg>/gi, '')
+      const typeMatch = /<type>([\s\S]*?)<\/type>/i.exec(appmsgInner)
+      if (typeMatch) {
+        return typeMatch[1].replace(/<!\[CDATA\[/g, '').replace(/\]\]>/g, '').trim()
+      }
+    }
+
+    const fallbackMatch = /<type>([\s\S]*?)<\/type>/i.exec(content)
+    if (fallbackMatch) {
+      return fallbackMatch[1].replace(/<!\[CDATA\[/g, '').replace(/\]\]>/g, '').trim()
+    }
+
+    return ''
+  }
+
+  private resolveType49Subtype(msg: Message): string {
+    const xmlType = String(msg.xmlType || '').trim()
+    if (xmlType) return xmlType
+
+    const extractedType = this.extractType49Subtype(msg.rawContent)
+    if (extractedType) return extractedType
+
+    switch (msg.appMsgKind) {
+      case 'official-link':
+      case 'link':
+        return '5'
+      case 'file':
+        return '6'
+      case 'chat-record':
+        return '19'
+      case 'miniapp':
+        return '33'
+      case 'quote':
+        return '57'
+      case 'transfer':
+        return '2000'
+      case 'red-packet':
+        return '2001'
+      case 'music':
+        return '3'
+      default:
+        if (msg.linkUrl) return '5'
+        if (msg.fileName) return '6'
+        return ''
+    }
+  }
+
+  private getType49Content(msg: Message): string {
+    const subtype = this.resolveType49Subtype(msg)
+    const title = msg.linkTitle || msg.fileName || ''
+
+    switch (subtype) {
+      case '5':
+      case '49':
+        return title ? `[链接] ${title}` : '[链接]'
+      case '6':
+        return title ? `[文件] ${title}` : '[文件]'
+      case '19':
+        return title ? `[聊天记录] ${title}` : '[聊天记录]'
+      case '33':
+      case '36':
+        return title ? `[小程序] ${title}` : '[小程序]'
+      case '57':
+        return msg.parsedContent || title || '[引用消息]'
+      case '2000':
+        return title ? `[转账] ${title}` : '[转账]'
+      case '2001':
+        return title ? `[红包] ${title}` : '[红包]'
+      case '3':
+        return title ? `[音乐] ${title}` : '[音乐]'
+      default:
+        return msg.parsedContent || title || '[消息]'
+    }
+  }
+
   /**
    * 获取消息内容
    */
   private getMessageContent(msg: Message): string | null {
+    if (msg.localType === 49) {
+      return this.getType49Content(msg)
+    }
+
     // 优先使用已解析的内容
     if (msg.parsedContent) {
       return msg.parsedContent
@@ -1032,7 +1780,7 @@ class HttpService {
       case 48:
         return '[位置]'
       case 49:
-        return msg.linkTitle || msg.fileName || '[消息]'
+        return this.getType49Content(msg)
       default:
         return msg.rawContent || null
     }
@@ -1047,6 +1795,11 @@ class HttpService {
     res.end(JSON.stringify(data, null, 2))
   }
 
+  private sendMethodNotAllowed(res: http.ServerResponse, allow: string): void {
+    res.setHeader('Allow', allow)
+    this.sendError(res, 405, `Method Not Allowed. Allowed: ${allow}`)
+  }
+
   /**
    * 发送错误响应
    */
@@ -1058,4 +1811,3 @@ class HttpService {
 }
 
 export const httpService = new HttpService()
-

electron/services/imageDecryptService.ts

@@ -55,14 +55,20 @@ type DecryptResult = {
   isThumb?: boolean  // 是否是缩略图（没有高清图时返回缩略图）
 }
 
-type HardlinkState = {
-  imageTable?: string
-  dirTable?: string
+type CachedImagePayload = {
+  sessionId?: string
+  imageMd5?: string
+  imageDatName?: string
+  preferFilePath?: boolean
+}
+
+type DecryptImagePayload = CachedImagePayload & {
+  force?: boolean
+  hardlinkOnly?: boolean
 }
 
 export class ImageDecryptService {
   private configService = new ConfigService()
-  private hardlinkCache = new Map<string, HardlinkState>()
   private resolvedCache = new Map<string, string>()
   private pending = new Map<string, Promise<DecryptResult>>()
   private readonly defaultV1AesKey = 'cfcd208495d565ef'
@@ -106,7 +112,7 @@ export class ImageDecryptService {
     }
   }
 
-  async resolveCachedImage(payload: { sessionId?: string; imageMd5?: string; imageDatName?: string }): Promise<DecryptResult & { hasUpdate?: boolean }> {
+  async resolveCachedImage(payload: CachedImagePayload): Promise<DecryptResult & { hasUpdate?: boolean }> {
     await this.ensureCacheIndexed()
     const cacheKeys = this.getCacheKeys(payload)
     const cacheKey = cacheKeys[0]
@@ -116,7 +122,7 @@ export class ImageDecryptService {
     for (const key of cacheKeys) {
       const cached = this.resolvedCache.get(key)
       if (cached && existsSync(cached) && this.isImageFile(cached)) {
-        const dataUrl = this.fileToDataUrl(cached)
+        const localPath = this.resolveLocalPathForPayload(cached, payload.preferFilePath)
         const isThumb = this.isThumbnailPath(cached)
         const hasUpdate = isThumb ? (this.updateFlags.get(key) ?? false) : false
         if (isThumb) {
@@ -124,8 +130,8 @@ export class ImageDecryptService {
         } else {
           this.updateFlags.delete(key)
         }
-        this.emitCacheResolved(payload, key, dataUrl || this.filePathToUrl(cached))
-        return { success: true, localPath: dataUrl || this.filePathToUrl(cached), hasUpdate }
+        this.emitCacheResolved(payload, key, this.resolveEmitPath(cached, payload.preferFilePath))
+        return { success: true, localPath, hasUpdate }
       }
       if (cached && !this.isImageFile(cached)) {
         this.resolvedCache.delete(key)
@@ -136,7 +142,7 @@ export class ImageDecryptService {
       const existing = this.findCachedOutput(key, false, payload.sessionId)
       if (existing) {
         this.cacheResolvedPaths(key, payload.imageMd5, payload.imageDatName, existing)
-        const dataUrl = this.fileToDataUrl(existing)
+        const localPath = this.resolveLocalPathForPayload(existing, payload.preferFilePath)
         const isThumb = this.isThumbnailPath(existing)
         const hasUpdate = isThumb ? (this.updateFlags.get(key) ?? false) : false
         if (isThumb) {
@@ -144,27 +150,57 @@ export class ImageDecryptService {
         } else {
           this.updateFlags.delete(key)
         }
-        this.emitCacheResolved(payload, key, dataUrl || this.filePathToUrl(existing))
-        return { success: true, localPath: dataUrl || this.filePathToUrl(existing), hasUpdate }
+        this.emitCacheResolved(payload, key, this.resolveEmitPath(existing, payload.preferFilePath))
+        return { success: true, localPath, hasUpdate }
       }
     }
     this.logInfo('未找到缓存', { md5: payload.imageMd5, datName: payload.imageDatName })
     return { success: false, error: '未找到缓存图片' }
   }
 
-  async decryptImage(payload: { sessionId?: string; imageMd5?: string; imageDatName?: string; force?: boolean }): Promise<DecryptResult> {
-    await this.ensureCacheIndexed()
-    const cacheKey = payload.imageMd5 || payload.imageDatName
+  async decryptImage(payload: DecryptImagePayload): Promise<DecryptResult> {
+    if (!payload.hardlinkOnly) {
+      await this.ensureCacheIndexed()
+    }
+    const cacheKeys = this.getCacheKeys(payload)
+    const cacheKey = cacheKeys[0]
     if (!cacheKey) {
       return { success: false, error: '缺少图片标识' }
     }
 
+    if (payload.force) {
+      for (const key of cacheKeys) {
+        const cached = this.resolvedCache.get(key)
+        if (cached && existsSync(cached) && this.isImageFile(cached) && !this.isThumbnailPath(cached)) {
+          this.cacheResolvedPaths(cacheKey, payload.imageMd5, payload.imageDatName, cached)
+          this.clearUpdateFlags(cacheKey, payload.imageMd5, payload.imageDatName)
+          const localPath = this.resolveLocalPathForPayload(cached, payload.preferFilePath)
+          this.emitCacheResolved(payload, cacheKey, this.resolveEmitPath(cached, payload.preferFilePath))
+          return { success: true, localPath }
+        }
+        if (cached && !this.isImageFile(cached)) {
+          this.resolvedCache.delete(key)
+        }
+      }
+
+      if (!payload.hardlinkOnly) {
+        for (const key of cacheKeys) {
+          const existingHd = this.findCachedOutput(key, true, payload.sessionId)
+          if (!existingHd || this.isThumbnailPath(existingHd)) continue
+          this.cacheResolvedPaths(cacheKey, payload.imageMd5, payload.imageDatName, existingHd)
+          this.clearUpdateFlags(cacheKey, payload.imageMd5, payload.imageDatName)
+          const localPath = this.resolveLocalPathForPayload(existingHd, payload.preferFilePath)
+          this.emitCacheResolved(payload, cacheKey, this.resolveEmitPath(existingHd, payload.preferFilePath))
+          return { success: true, localPath }
+        }
+      }
+    }
+
     if (!payload.force) {
       const cached = this.resolvedCache.get(cacheKey)
       if (cached && existsSync(cached) && this.isImageFile(cached)) {
-        const dataUrl = this.fileToDataUrl(cached)
-        const localPath = dataUrl || this.filePathToUrl(cached)
-        this.emitCacheResolved(payload, cacheKey, localPath)
+        const localPath = this.resolveLocalPathForPayload(cached, payload.preferFilePath)
+        this.emitCacheResolved(payload, cacheKey, this.resolveEmitPath(cached, payload.preferFilePath))
         return { success: true, localPath }
       }
       if (cached && !this.isImageFile(cached)) {
@@ -184,11 +220,47 @@ export class ImageDecryptService {
     }
   }
 
+  async preloadImageHardlinkMd5s(md5List: string[]): Promise<void> {
+    const normalizedList = Array.from(
+      new Set((md5List || []).map((item) => String(item || '').trim().toLowerCase()).filter(Boolean))
+    )
+    if (normalizedList.length === 0) return
+
+    const wxid = this.configService.get('myWxid')
+    const dbPath = this.configService.get('dbPath')
+    if (!wxid || !dbPath) return
+
+    const accountDir = this.resolveAccountDir(dbPath, wxid)
+    if (!accountDir) return
+
+    try {
+      const ready = await this.ensureWcdbReady()
+      if (!ready) return
+      const requests = normalizedList.map((md5) => ({ md5, accountDir }))
+      const result = await wcdbService.resolveImageHardlinkBatch(requests)
+      if (!result.success || !Array.isArray(result.rows)) return
+
+      for (const row of result.rows) {
+        const md5 = String(row?.md5 || '').trim().toLowerCase()
+        if (!md5) continue
+        const fullPath = String(row?.data?.full_path || '').trim()
+        if (!fullPath || !existsSync(fullPath)) continue
+        this.cacheDatPath(accountDir, md5, fullPath)
+        const fileName = String(row?.data?.file_name || '').trim().toLowerCase()
+        if (fileName) {
+          this.cacheDatPath(accountDir, fileName, fullPath)
+        }
+      }
+    } catch {
+      // ignore preload failures
+    }
+  }
+
   private async decryptImageInternal(
-    payload: { sessionId?: string; imageMd5?: string; imageDatName?: string; force?: boolean },
+    payload: DecryptImagePayload,
     cacheKey: string
   ): Promise<DecryptResult> {
-    this.logInfo('开始解密图片', { md5: payload.imageMd5, datName: payload.imageDatName, force: payload.force })
+    this.logInfo('开始解密图片', { md5: payload.imageMd5, datName: payload.imageDatName, force: payload.force, hardlinkOnly: payload.hardlinkOnly === true })
     try {
       const wxid = this.configService.get('myWxid')
       const dbPath = this.configService.get('dbPath')
@@ -208,7 +280,11 @@ export class ImageDecryptService {
         payload.imageMd5,
         payload.imageDatName,
         payload.sessionId,
-        { allowThumbnail: !payload.force, skipResolvedCache: Boolean(payload.force) }
+        {
+          allowThumbnail: !payload.force,
+          skipResolvedCache: Boolean(payload.force),
+          hardlinkOnly: payload.hardlinkOnly === true
+        }
       )
 
       // 如果要求高清图但没找到，直接返回提示
@@ -225,26 +301,26 @@ export class ImageDecryptService {
 
       if (!extname(datPath).toLowerCase().includes('dat')) {
         this.cacheResolvedPaths(cacheKey, payload.imageMd5, payload.imageDatName, datPath)
-        const dataUrl = this.fileToDataUrl(datPath)
-        const localPath = dataUrl || this.filePathToUrl(datPath)
+        const localPath = this.resolveLocalPathForPayload(datPath, payload.preferFilePath)
         const isThumb = this.isThumbnailPath(datPath)
-        this.emitCacheResolved(payload, cacheKey, localPath)
+        this.emitCacheResolved(payload, cacheKey, this.resolveEmitPath(datPath, payload.preferFilePath))
         return { success: true, localPath, isThumb }
       }
 
-      // 查找已缓存的解密文件
-      const existing = this.findCachedOutput(cacheKey, payload.force, payload.sessionId)
-      if (existing) {
-        this.logInfo('找到已解密文件', { existing, isHd: this.isHdPath(existing) })
-        const isHd = this.isHdPath(existing)
-        // 如果要求高清但找到的是缩略图，继续解密高清图
-        if (!(payload.force && !isHd)) {
-          this.cacheResolvedPaths(cacheKey, payload.imageMd5, payload.imageDatName, existing)
-          const dataUrl = this.fileToDataUrl(existing)
-          const localPath = dataUrl || this.filePathToUrl(existing)
-          const isThumb = this.isThumbnailPath(existing)
-          this.emitCacheResolved(payload, cacheKey, localPath)
-          return { success: true, localPath, isThumb }
+      // 查找已缓存的解密文件（hardlink-only 模式下跳过全缓存目录扫描）
+      if (!payload.hardlinkOnly) {
+        const existing = this.findCachedOutput(cacheKey, payload.force, payload.sessionId)
+        if (existing) {
+          this.logInfo('找到已解密文件', { existing, isHd: this.isHdPath(existing) })
+          const isHd = this.isHdPath(existing)
+          // 如果要求高清但找到的是缩略图，继续解密高清图
+          if (!(payload.force && !isHd)) {
+            this.cacheResolvedPaths(cacheKey, payload.imageMd5, payload.imageDatName, existing)
+            const localPath = this.resolveLocalPathForPayload(existing, payload.preferFilePath)
+            const isThumb = this.isThumbnailPath(existing)
+            this.emitCacheResolved(payload, cacheKey, this.resolveEmitPath(existing, payload.preferFilePath))
+            return { success: true, localPath, isThumb }
+          }
         }
       }
 
@@ -303,9 +379,11 @@ export class ImageDecryptService {
       if (!isThumb) {
         this.clearUpdateFlags(cacheKey, payload.imageMd5, payload.imageDatName)
       }
-      const dataUrl = this.bufferToDataUrl(decrypted, finalExt)
-      const localPath = dataUrl || this.filePathToUrl(outputPath)
-      this.emitCacheResolved(payload, cacheKey, localPath)
+      const localPath = payload.preferFilePath
+        ? outputPath
+        : (this.bufferToDataUrl(decrypted, finalExt) || this.filePathToUrl(outputPath))
+      const emitPath = this.resolveEmitPath(outputPath, payload.preferFilePath)
+      this.emitCacheResolved(payload, cacheKey, emitPath)
       return { success: true, localPath, isThumb }
     } catch (e) {
       this.logError('解密失败', e, { md5: payload.imageMd5, datName: payload.imageDatName })
@@ -400,15 +478,17 @@ export class ImageDecryptService {
     imageMd5?: string,
     imageDatName?: string,
     sessionId?: string,
-    options?: { allowThumbnail?: boolean; skipResolvedCache?: boolean }
+    options?: { allowThumbnail?: boolean; skipResolvedCache?: boolean; hardlinkOnly?: boolean }
   ): Promise<string | null> {
     const allowThumbnail = options?.allowThumbnail ?? true
     const skipResolvedCache = options?.skipResolvedCache ?? false
+    const hardlinkOnly = options?.hardlinkOnly ?? false
     this.logInfo('[ImageDecrypt] resolveDatPath', {
       imageMd5,
       imageDatName,
       allowThumbnail,
-      skipResolvedCache
+      skipResolvedCache,
+      hardlinkOnly
     })
 
     if (!skipResolvedCache) {
@@ -433,13 +513,17 @@ export class ImageDecryptService {
     }
 
     // 1. 通过 MD5 快速定位 (MsgAttach 目录)
-    if (imageMd5) {
+    if (!hardlinkOnly && allowThumbnail && imageMd5) {
       const res = await this.fastProbabilisticSearch(join(accountDir, 'msg', 'attach'), imageMd5, allowThumbnail)
       if (res) return res
+      if (imageDatName && imageDatName !== imageMd5 && this.looksLikeMd5(imageDatName)) {
+        const datNameRes = await this.fastProbabilisticSearch(join(accountDir, 'msg', 'attach'), imageDatName, allowThumbnail)
+        if (datNameRes) return datNameRes
+      }
     }
 
     // 2. 如果 imageDatName 看起来像 MD5，也尝试快速定位
-    if (!imageMd5 && imageDatName && this.looksLikeMd5(imageDatName)) {
+    if (!hardlinkOnly && allowThumbnail && !imageMd5 && imageDatName && this.looksLikeMd5(imageDatName)) {
       const res = await this.fastProbabilisticSearch(join(accountDir, 'msg', 'attach'), imageDatName, allowThumbnail)
       if (res) return res
     }
@@ -478,14 +562,14 @@ export class ImageDecryptService {
           if (allowThumbnail || !isThumb) {
             this.logInfo('[ImageDecrypt] hardlink hit (datName)', { imageMd5: imageDatName, path: preferredPath })
             this.cacheDatPath(accountDir, imageDatName, preferredPath)
-            if (imageMd5) this.cacheDatPath(accountDir, imageMd5, preferredPath)
+            this.cacheDatPath(accountDir, imageMd5, preferredPath)
             return preferredPath
           }
           // 找到缩略图但要求高清图，尝试同目录查找高清图变体
           const hdPath = this.findHdVariantInSameDir(preferredPath)
           if (hdPath) {
             this.cacheDatPath(accountDir, imageDatName, hdPath)
-            if (imageMd5) this.cacheDatPath(accountDir, imageMd5, hdPath)
+            this.cacheDatPath(accountDir, imageMd5, hdPath)
             return hdPath
           }
           return null
@@ -516,6 +600,11 @@ export class ImageDecryptService {
       this.logInfo('[ImageDecrypt] hardlink miss (datName)', { imageDatName })
     }
 
+    if (hardlinkOnly) {
+      this.logInfo('[ImageDecrypt] resolveDatPath miss (hardlink-only)', { imageMd5, imageDatName })
+      return null
+    }
+
     // 如果要求高清图但 hardlink 没找到，也不要搜索了（搜索太慢）
     if (!allowThumbnail) {
       return null
@@ -650,45 +739,19 @@ export class ImageDecryptService {
 
   private async resolveHardlinkPath(accountDir: string, md5: string, _sessionId?: string): Promise<string | null> {
     try {
-      const hardlinkPath = this.resolveHardlinkDbPath(accountDir)
-      if (!hardlinkPath) {
-        return null
-      }
-
       const ready = await this.ensureWcdbReady()
       if (!ready) {
         this.logInfo('[ImageDecrypt] hardlink db not ready')
         return null
       }
 
-      const state = await this.getHardlinkState(accountDir, hardlinkPath)
-      if (!state.imageTable) {
-        this.logInfo('[ImageDecrypt] hardlink table missing', { hardlinkPath })
-        return null
-      }
+      const resolveResult = await wcdbService.resolveImageHardlink(md5, accountDir)
+      if (!resolveResult.success || !resolveResult.data) return null
+      const fileName = String(resolveResult.data.file_name || '').trim()
+      const fullPath = String(resolveResult.data.full_path || '').trim()
+      if (!fileName) return null
 
-      const escapedMd5 = this.escapeSqlString(md5)
-      const rowResult = await wcdbService.execQuery(
-        'media',
-        hardlinkPath,
-        `SELECT dir1, dir2, file_name FROM ${state.imageTable} WHERE lower(md5) = lower('${escapedMd5}') LIMIT 1`
-      )
-      const row = rowResult.success && rowResult.rows ? rowResult.rows[0] : null
-
-      if (!row) {
-        this.logInfo('[ImageDecrypt] hardlink row miss', { md5, table: state.imageTable })
-        return null
-      }
-
-      const dir1 = this.getRowValue(row, 'dir1')
-      const dir2 = this.getRowValue(row, 'dir2')
-      const fileName = this.getRowValue(row, 'file_name') ?? this.getRowValue(row, 'fileName')
-      if (dir1 === undefined || dir2 === undefined || !fileName) {
-        this.logInfo('[ImageDecrypt] hardlink row incomplete', { row })
-        return null
-      }
-
-      const lowerFileName = fileName.toLowerCase()
+      const lowerFileName = String(fileName).toLowerCase()
       if (lowerFileName.endsWith('.dat')) {
         const baseLower = lowerFileName.slice(0, -4)
         if (!this.isLikelyImageDatBase(baseLower) && !this.looksLikeMd5(baseLower)) {
@@ -697,57 +760,11 @@ export class ImageDecryptService {
         }
       }
 
-      // dir1 和 dir2 是 rowid，需要从 dir2id 表查询对应的目录名
-      let dir1Name: string | null = null
-      let dir2Name: string | null = null
-
-      if (state.dirTable) {
-        try {
-          // 通过 rowid 查询目录名
-          const dir1Result = await wcdbService.execQuery(
-            'media',
-            hardlinkPath,
-            `SELECT username FROM ${state.dirTable} WHERE rowid = ${Number(dir1)} LIMIT 1`
-          )
-          if (dir1Result.success && dir1Result.rows && dir1Result.rows.length > 0) {
-            const value = this.getRowValue(dir1Result.rows[0], 'username')
-            if (value) dir1Name = String(value)
-          }
-
-          const dir2Result = await wcdbService.execQuery(
-            'media',
-            hardlinkPath,
-            `SELECT username FROM ${state.dirTable} WHERE rowid = ${Number(dir2)} LIMIT 1`
-          )
-          if (dir2Result.success && dir2Result.rows && dir2Result.rows.length > 0) {
-            const value = this.getRowValue(dir2Result.rows[0], 'username')
-            if (value) dir2Name = String(value)
-          }
-        } catch {
-          // ignore
-        }
+      if (fullPath && existsSync(fullPath)) {
+        this.logInfo('[ImageDecrypt] hardlink path hit', { fullPath })
+        return fullPath
       }
-
-      if (!dir1Name || !dir2Name) {
-        this.logInfo('[ImageDecrypt] hardlink dir resolve miss', { dir1, dir2, dir1Name, dir2Name })
-        return null
-      }
-
-      // 构建路径: msg/attach/{dir1Name}/{dir2Name}/Img/{fileName}
-      const possiblePaths = [
-        join(accountDir, 'msg', 'attach', dir1Name, dir2Name, 'Img', fileName),
-        join(accountDir, 'msg', 'attach', dir1Name, dir2Name, 'mg', fileName),
-        join(accountDir, 'msg', 'attach', dir1Name, dir2Name, fileName),
-      ]
-
-      for (const fullPath of possiblePaths) {
-        if (existsSync(fullPath)) {
-          this.logInfo('[ImageDecrypt] hardlink path hit', { fullPath })
-          return fullPath
-        }
-      }
-
-      this.logInfo('[ImageDecrypt] hardlink path miss', { possiblePaths })
+      this.logInfo('[ImageDecrypt] hardlink path miss', { fullPath, md5 })
       return null
     } catch {
       // ignore
@@ -755,35 +772,6 @@ export class ImageDecryptService {
     return null
   }
 
-  private async getHardlinkState(accountDir: string, hardlinkPath: string): Promise<HardlinkState> {
-    const cached = this.hardlinkCache.get(hardlinkPath)
-    if (cached) return cached
-
-    const imageResult = await wcdbService.execQuery(
-      'media',
-      hardlinkPath,
-      "SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'image_hardlink_info%' ORDER BY name DESC LIMIT 1"
-    )
-    const dirResult = await wcdbService.execQuery(
-      'media',
-      hardlinkPath,
-      "SELECT name FROM sqlite_master WHERE type='table' AND name LIKE 'dir2id%' LIMIT 1"
-    )
-    const imageTable = imageResult.success && imageResult.rows && imageResult.rows.length > 0
-      ? this.getRowValue(imageResult.rows[0], 'name')
-      : undefined
-    const dirTable = dirResult.success && dirResult.rows && dirResult.rows.length > 0
-      ? this.getRowValue(dirResult.rows[0], 'name')
-      : undefined
-    const state: HardlinkState = {
-      imageTable: imageTable ? String(imageTable) : undefined,
-      dirTable: dirTable ? String(dirTable) : undefined
-    }
-    this.logInfo('[ImageDecrypt] hardlink state', { hardlinkPath, imageTable: state.imageTable, dirTable: state.dirTable })
-    this.hardlinkCache.set(hardlinkPath, state)
-    return state
-  }
-
   private async ensureWcdbReady(): Promise<boolean> {
     if (wcdbService.isReady()) return true
     const dbPath = this.configService.get('dbPath')
@@ -889,7 +877,8 @@ export class ImageDecryptService {
 
         const now = new Date()
         const months: string[] = []
-        for (let i = 0; i < 2; i++) {
+        // Imported mobile history can live in older YYYY-MM buckets; keep this bounded but wider than "recent 2 months".
+        for (let i = 0; i < 24; i++) {
           const d = new Date(now.getFullYear(), now.getMonth() - i, 1)
           const mStr = `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}`
           months.push(mStr)
@@ -1567,6 +1556,16 @@ export class ImageDecryptService {
     return `data:${mimeType};base64,${buffer.toString('base64')}`
   }
 
+  private resolveLocalPathForPayload(filePath: string, preferFilePath?: boolean): string {
+    if (preferFilePath) return filePath
+    return this.resolveEmitPath(filePath, false)
+  }
+
+  private resolveEmitPath(filePath: string, preferFilePath?: boolean): string {
+    if (preferFilePath) return this.filePathToUrl(filePath)
+    return this.fileToDataUrl(filePath) || this.filePathToUrl(filePath)
+  }
+
   private fileToDataUrl(filePath: string): string | null {
     try {
       const ext = extname(filePath).toLowerCase()
@@ -1958,7 +1957,6 @@ export class ImageDecryptService {
 
   async clearCache(): Promise<{ success: boolean; error?: string }> {
     this.resolvedCache.clear()
-    this.hardlinkCache.clear()
     this.pending.clear()
     this.updateFlags.clear()
     this.cacheIndexed = false

electron/services/keyService.ts

@@ -606,34 +606,14 @@ export class KeyService {
 
     const logs: string[] = []
 
-    onStatus?.('正在定位微信安装路径...', 0)
-    let wechatPath = await this.findWeChatInstallPath()
-    if (!wechatPath) {
-      const err = '未找到微信安装路径，请确认已安装PC微信'
+    onStatus?.('正在查找微信进程...', 0)
+    const pid = await this.findWeChatPid()
+    if (!pid) {
+      const err = '未找到微信进程，请先启动微信'
       onStatus?.(err, 2)
       return { success: false, error: err }
     }
 
-    onStatus?.('正在关闭微信以进行获取...', 0)
-    const closed = await this.killWeChatProcesses()
-    if (!closed) {
-      const err = '无法自动关闭微信，请手动退出后重试'
-      onStatus?.(err, 2)
-      return { success: false, error: err }
-    }
-
-    onStatus?.('正在启动微信...', 0)
-    const sub = spawn(wechatPath, {
-      detached: true,
-      stdio: 'ignore',
-      cwd: dirname(wechatPath)
-    })
-    sub.unref()
-
-    onStatus?.('等待微信界面就绪...', 0)
-    const pid = await this.waitForWeChatWindow()
-    if (!pid) return { success: false, error: '启动微信失败或等待界面就绪超时' }
-
     onStatus?.(`检测到微信窗口 (PID: ${pid})，正在获取...`, 0)
     onStatus?.('正在检测微信界面组件...', 0)
     await this.waitForWeChatWindowComponents(pid, 15000)

electron/services/keyServiceLinux.ts

@@ -0,0 +1,364 @@
+import { app } from 'electron'
+import { join } from 'path'
+import { existsSync, readdirSync, statSync, readFileSync } from 'fs'
+import { execFile, exec, spawn } from 'child_process'
+import { promisify } from 'util'
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+
+const execFileAsync = promisify(execFile)
+const execAsync = promisify(exec)
+
+type DbKeyResult = { success: boolean; key?: string; error?: string; logs?: string[] }
+type ImageKeyResult = { success: boolean; xorKey?: number; aesKey?: string; error?: string }
+
+export class KeyServiceLinux {
+  private sudo: any
+
+  constructor() {
+    try {
+      this.sudo = require('sudo-prompt');
+    } catch (e) {
+      console.error('Failed to load sudo-prompt', e);
+    }
+  }
+
+  private getHelperPath(): string {
+    const isPackaged = app.isPackaged
+    const candidates: string[] = []
+    if (process.env.WX_KEY_HELPER_PATH) candidates.push(process.env.WX_KEY_HELPER_PATH)
+    if (isPackaged) {
+      candidates.push(join(process.resourcesPath, 'resources', 'xkey_helper_linux'))
+      candidates.push(join(process.resourcesPath, 'xkey_helper_linux'))
+    } else {
+      candidates.push(join(app.getAppPath(), 'resources', 'xkey_helper_linux'))
+      candidates.push(join(app.getAppPath(), '..', 'Xkey', 'build', 'xkey_helper_linux'))
+    }
+    for (const p of candidates) {
+      if (existsSync(p)) return p
+    }
+    throw new Error('找不到 xkey_helper_linux，请检查路径')
+  }
+
+  public async autoGetDbKey(
+      timeoutMs = 60_000,
+      onStatus?: (message: string, level: number) => void
+  ): Promise<DbKeyResult> {
+    try {
+      // 1. 构造一个包含常用系统命令路径的环境变量，防止打包后找不到命令
+      const envWithPath = {
+        ...process.env,
+        PATH: `${process.env.PATH || ''}:/bin:/usr/bin:/sbin:/usr/sbin:/usr/local/bin`
+      };
+
+      onStatus?.('正在尝试结束当前微信进程...', 0)
+      console.log('[Debug] 开始执行进程清理逻辑...');
+
+      try {
+        const { stdout, stderr } = await execAsync('killall -9 wechat wechat-bin xwechat', { env: envWithPath });
+        console.log(`[Debug] killall 成功退出. stdout: ${stdout}, stderr: ${stderr}`);
+      } catch (err: any) {
+        // 命令如果没找到进程通常会返回 code 1，这也是正常的，但我们需要记录下来
+        console.log(`[Debug] killall 报错或未找到进程: ${err.message}`);
+
+        // Fallback: 尝试使用 pkill 兜底
+        try {
+          console.log('[Debug] 尝试使用备用命令 pkill...');
+          await execAsync('pkill -9 -x "wechat|wechat-bin|xwechat"', { env: envWithPath });
+          console.log('[Debug] pkill 执行完成');
+        } catch (e: any) {
+          console.log(`[Debug] pkill 报错或未找到进程: ${e.message}`);
+        }
+      }
+
+      // 稍微等待进程完全退出
+      await new Promise(r => setTimeout(r, 1000))
+
+      onStatus?.('正在尝试拉起微信...', 0)
+
+      const cleanEnv = { ...process.env };
+      delete cleanEnv.ELECTRON_RUN_AS_NODE;
+      delete cleanEnv.ELECTRON_NO_ATTACH_CONSOLE;
+      delete cleanEnv.APPDIR;
+      delete cleanEnv.APPIMAGE;
+
+      const wechatBins = [
+        'wechat',
+        'wechat-bin',
+        'xwechat',
+        '/opt/wechat/wechat',
+        '/usr/bin/wechat',
+        '/opt/apps/com.tencent.wechat/files/wechat'
+      ]
+
+      for (const binName of wechatBins) {
+        try {
+          const child = spawn(binName, [], {
+            detached: true,
+            stdio: 'ignore',
+            env: cleanEnv
+          });
+
+          child.on('error', (err) => {
+            console.log(`[Debug] 拉起 ${binName} 失败:`, err.message);
+          });
+
+          child.unref();
+          console.log(`[Debug] 尝试拉起 ${binName} 完毕`);
+        } catch (e: any) {
+          console.log(`[Debug] 尝试拉起 ${binName} 发生异常:`, e.message);
+        }
+      }
+
+      onStatus?.('等待微信进程出现...', 0)
+      let pid = 0
+      for (let i = 0; i < 15; i++) { // 最多等 15 秒
+        await new Promise(r => setTimeout(r, 1000))
+
+        try {
+          const { stdout } = await execAsync('pidof wechat wechat-bin xwechat', { env: envWithPath });
+          const pids = stdout.trim().split(/\s+/).filter(p => p);
+          if (pids.length > 0) {
+            pid = parseInt(pids[0], 10);
+            console.log(`[Debug] 第 ${i + 1} 秒，通过 pidof 成功获取 PID: ${pid}`);
+            break;
+          }
+        } catch (err: any) {
+          console.log(`[Debug] 第 ${i + 1} 秒，pidof 失败: ${err.message.split('\n')[0]}`);
+
+          // Fallback: 使用 pgrep 兜底
+          try {
+            const { stdout: pgrepOut } = await execAsync('pgrep -x "wechat|wechat-bin|xwechat"', { env: envWithPath });
+            const pids = pgrepOut.trim().split(/\s+/).filter(p => p);
+            if (pids.length > 0) {
+              pid = parseInt(pids[0], 10);
+              console.log(`[Debug] 第 ${i + 1} 秒，通过 pgrep 成功获取 PID: ${pid}`);
+              break;
+            }
+          } catch (e: any) {
+            console.log(`[Debug] 第 ${i + 1} 秒，pgrep 也失败: ${e.message.split('\n')[0]}`);
+          }
+        }
+      }
+
+      if (!pid) {
+        const err = '未能自动启动微信，或获取PID失败，请查看控制台日志或手动启动并登录。'
+        onStatus?.(err, 2)
+        return { success: false, error: err }
+      }
+
+      onStatus?.(`捕获到微信 PID: ${pid}，准备获取密钥...`, 0)
+
+      await new Promise(r => setTimeout(r, 2000))
+
+      return await this.getDbKey(pid, onStatus)
+    } catch (err: any) {
+      console.error('[Debug] 自动获取流程彻底崩溃:', err);
+      const errMsg = '自动获取微信 PID 失败: ' + err.message
+      onStatus?.(errMsg, 2)
+      return { success: false, error: errMsg }
+    }
+  }
+
+  public async getDbKey(pid: number, onStatus?: (message: string, level: number) => void): Promise<DbKeyResult> {
+    try {
+      const helperPath = this.getHelperPath()
+
+      onStatus?.('正在扫描数据库基址...', 0)
+      const { stdout: scanOut } = await execFileAsync(helperPath, ['db_scan', pid.toString()])
+      const scanRes = JSON.parse(scanOut.trim())
+
+      if (!scanRes.success) {
+        const err = scanRes.result || '扫描失败，请确保微信已完全登录'
+        onStatus?.(err, 2)
+        return { success: false, error: err }
+      }
+
+      const targetAddr = scanRes.target_addr
+      onStatus?.('基址扫描成功，正在请求管理员权限进行内存 Hook...', 0)
+
+      return await new Promise((resolve) => {
+        const options = { name: 'WeFlow' }
+        const command = `"${helperPath}" db_hook ${pid} ${targetAddr}`
+
+        this.sudo.exec(command, options, (error, stdout) => {
+          execAsync(`kill -CONT ${pid}`).catch(() => {})
+          if (error) {
+            onStatus?.('授权失败或被取消', 2)
+            resolve({ success: false, error: `授权失败或被取消: ${error.message}` })
+            return
+          }
+          try {
+            const hookRes = JSON.parse((stdout as string).trim())
+            if (hookRes.success) {
+              onStatus?.('密钥获取成功', 1)
+              resolve({ success: true, key: hookRes.key })
+            } else {
+              onStatus?.(hookRes.result, 2)
+              resolve({ success: false, error: hookRes.result })
+            }
+          } catch (e) {
+            onStatus?.('解析 Hook 结果失败', 2)
+            resolve({ success: false, error: '解析 Hook 结果失败' })
+          }
+        })
+      })
+    } catch (err: any) {
+      onStatus?.(err.message, 2)
+      return { success: false, error: err.message }
+    }
+  }
+
+  public async autoGetImageKey(
+      accountPath?: string,
+      onProgress?: (msg: string) => void,
+      wxid?: string
+  ): Promise<ImageKeyResult> {
+    try {
+      onProgress?.('正在初始化缓存扫描...');
+      const helperPath = this.getHelperPath()
+      const { stdout } = await execFileAsync(helperPath, ['image_local'])
+      const res = JSON.parse(stdout.trim())
+      if (!res.success) return { success: false, error: res.result }
+
+      const accounts = res.data.accounts || []
+      let account = accounts.find((a: any) => a.wxid === wxid)
+      if (!account && accounts.length > 0) account = accounts[0]
+
+      if (account && account.keys && account.keys.length > 0) {
+        onProgress?.(`已找到匹配的图片密钥 (wxid: ${account.wxid})`);
+        const keyObj = account.keys[0]
+        return { success: true, xorKey: keyObj.xorKey, aesKey: keyObj.aesKey }
+      }
+      return { success: false, error: '未在缓存中找到匹配的图片密钥' }
+    } catch (err: any) {
+      return { success: false, error: err.message }
+    }
+  }
+
+  public async autoGetImageKeyByMemoryScan(
+      accountPath: string,
+      onProgress?: (msg: string) => void
+  ): Promise<ImageKeyResult> {
+    try {
+      onProgress?.('正在查找模板文件...')
+      let result = await this._findTemplateData(accountPath, 32)
+      let { ciphertext, xorKey } = result
+
+      if (ciphertext && xorKey === null) {
+        onProgress?.('未找到有效密钥，尝试扫描更多文件...')
+        result = await this._findTemplateData(accountPath, 100)
+        xorKey = result.xorKey
+      }
+
+      if (!ciphertext) return { success: false, error: '未找到 V2 模板文件，请先在微信中查看几张图片' }
+      if (xorKey === null) return { success: false, error: '未能从模板文件中计算出有效的 XOR 密钥' }
+
+      onProgress?.(`XOR 密钥: 0x${xorKey.toString(16).padStart(2, '0')}，正在查找微信进程...`)
+
+      // 2. 找微信 PID
+      const { stdout } = await execAsync('pidof wechat wechat-bin xwechat').catch(() => ({ stdout: '' }))
+      const pids = stdout.trim().split(/\s+/).filter(p => p)
+      if (pids.length === 0) return { success: false, error: '微信未运行，无法扫描内存' }
+      const pid = parseInt(pids[0], 10)
+
+      onProgress?.(`已找到微信进程 PID=${pid}，正在提权扫描进程内存...`);
+
+      // 3. 将 Buffer 转换为 hex 传递给 helper
+      const ciphertextHex = ciphertext.toString('hex')
+      const helperPath = this.getHelperPath()
+
+      try {
+        console.log(`[Debug] 准备执行 Helper: ${helperPath} image_mem ${pid} ${ciphertextHex}`);
+
+        const { stdout: memOut, stderr } = await execFileAsync(helperPath, ['image_mem', pid.toString(), ciphertextHex])
+
+        console.log(`[Debug] Helper stdout: ${memOut}`);
+        if (stderr) {
+          console.warn(`[Debug] Helper stderr: ${stderr}`);
+        }
+
+        if (!memOut || memOut.trim() === '') {
+          return { success: false, error: 'Helper 返回为空，请检查是否有足够的权限(如需sudo)读取进程内存。' }
+        }
+
+        const res = JSON.parse(memOut.trim())
+
+        if (res.success) {
+          onProgress?.('内存扫描成功');
+          return { success: true, xorKey, aesKey: res.key }
+        }
+        return { success: false, error: res.result || '未知错误' }
+
+      } catch (err: any) {
+        console.error('[Debug] 执行或解析 Helper 时发生崩溃:', err);
+        return {
+          success: false,
+          error: `内存扫描失败: ${err.message}\nstdout: ${err.stdout || '无'}\nstderr: ${err.stderr || '无'}`
+        }
+      }
+    } catch (err: any) {
+      return { success: false, error: `内存扫描失败: ${err.message}` }
+    }
+  }
+
+  private async _findTemplateData(userDir: string, limit: number = 32): Promise<{ ciphertext: Buffer | null; xorKey: number | null }> {
+    const V2_MAGIC = Buffer.from([0x07, 0x08, 0x56, 0x32, 0x08, 0x07])
+
+    // 递归收集 *_t.dat 文件
+    const collect = (dir: string, results: string[], maxFiles: number) => {
+      if (results.length >= maxFiles) return
+      try {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+          if (results.length >= maxFiles) break
+          const full = join(dir, entry.name)
+          if (entry.isDirectory()) collect(full, results, maxFiles)
+          else if (entry.isFile() && entry.name.endsWith('_t.dat')) results.push(full)
+        }
+      } catch { /* 忽略无权限目录 */ }
+    }
+
+    const files: string[] = []
+    collect(userDir, files, limit)
+
+    // 按修改时间降序
+    files.sort((a, b) => {
+      try { return statSync(b).mtimeMs - statSync(a).mtimeMs } catch { return 0 }
+    })
+
+    let ciphertext: Buffer | null = null
+    const tailCounts: Record<string, number> = {}
+
+    for (const f of files.slice(0, 32)) {
+      try {
+        const data = readFileSync(f)
+        if (data.length < 8) continue
+
+        // 统计末尾两字节用于 XOR 密钥
+        if (data.subarray(0, 6).equals(V2_MAGIC) && data.length >= 2) {
+          const key = `${data[data.length - 2]}_${data[data.length - 1]}`
+          tailCounts[key] = (tailCounts[key] ?? 0) + 1
+        }
+
+        // 提取密文（取第一个有效的）
+        if (!ciphertext && data.subarray(0, 6).equals(V2_MAGIC) && data.length >= 0x1F) {
+          ciphertext = data.subarray(0xF, 0x1F)
+        }
+      } catch { /* 忽略 */ }
+    }
+
+    // 计算 XOR 密钥
+    let xorKey: number | null = null
+    let maxCount = 0
+    for (const [key, count] of Object.entries(tailCounts)) {
+      if (count > maxCount) {
+        maxCount = count
+        const [x, y] = key.split('_').map(Number)
+        const k = x ^ 0xFF
+        if (k === (y ^ 0xD9)) xorKey = k
+      }
+    }
+
+    return { ciphertext, xorKey }
+  }
+}

electron/services/keyServiceMac.ts

@@ -116,11 +116,30 @@ export class KeyServiceMac {
     }
   }
 
+  private async checkSipStatus(): Promise<{ enabled: boolean; error?: string }> {
+    try {
+      const { stdout } = await execFileAsync('/usr/bin/csrutil', ['status'])
+      const enabled = stdout.toLowerCase().includes('enabled')
+      return { enabled }
+    } catch (e: any) {
+      return { enabled: false, error: e.message }
+    }
+  }
+
   async autoGetDbKey(
     timeoutMs = 60_000,
     onStatus?: (message: string, level: number) => void
   ): Promise<DbKeyResult> {
     try {
+      // 检测 SIP 状态
+      const sipStatus = await this.checkSipStatus()
+      if (sipStatus.enabled) {
+        return {
+          success: false,
+          error: 'SIP (系统完整性保护) 已开启，无法获取密钥。请关闭 SIP 后重试。\n\n关闭方法：\n1. Intel 芯片：重启 Mac 并按住 Command + R 进入恢复模式\n2. Apple 芯片（M 系列）：关机后长按开机（指纹）键，选择“设置（选项）”进入恢复模式\n3. 打开终端，输入: csrutil disable\n4. 重启电脑'
+        }
+      }
+
       onStatus?.('正在获取数据库密钥...', 0)
       onStatus?.('正在请求管理员授权并执行 helper...', 0)
       let parsed: { success: boolean; key?: string; code?: string; detail?: string; raw: string }
@@ -243,6 +262,7 @@ export class KeyServiceMac {
   ): Promise<string> {
     const helperPath = this.getHelperPath()
     const waitMs = Math.max(timeoutMs, 30_000)
+    const timeoutSec = Math.ceil(waitMs / 1000) + 30
     const pid = await this.getWeChatPid()
     onStatus?.(`已找到微信进程 PID=${pid}，正在定位目标函数...`, 0)
     // 最佳努力清理同路径残留 helper（普通权限）
@@ -359,12 +379,22 @@ export class KeyServiceMac {
   ): Promise<string> {
     const helperPath = this.getHelperPath()
     const waitMs = Math.max(timeoutMs, 30_000)
+    const timeoutSec = Math.ceil(waitMs / 1000) + 30
     const pid = await this.getWeChatPid()
     // 用 AppleScript 的 quoted form 组装命令，避免复杂 shell 拼接导致整条失败
+    // 通过 try/on error 回传详细错误，避免只看到 "Command failed"
     const scriptLines = [
       `set helperPath to ${JSON.stringify(helperPath)}`,
       `set cmd to quoted form of helperPath & " ${pid} ${waitMs}"`,
-      'do shell script cmd with administrator privileges'
+      `set timeoutSec to ${timeoutSec}`,
+      'try',
+      'with timeout of timeoutSec seconds',
+      'set outText to do shell script (cmd & " 2>&1") with administrator privileges',
+      'end timeout',
+      'return "WF_OK::" & outText',
+      'on error errMsg number errNum partial result pr',
+      'return "WF_ERR::" & errNum & "::" & errMsg & "::" & (pr as text)',
+      'end try'
     ]
     onStatus?.('已准备就绪，现在登录微信或退出登录后重新登录微信', 0)
 
@@ -380,18 +410,37 @@ export class KeyServiceMac {
     }
 
     const lines = String(stdout).split(/\r?\n/).map(x => x.trim()).filter(Boolean)
-    const last = lines[lines.length - 1]
-    if (!last) throw new Error('elevated helper returned empty output')
+    if (!lines.length) throw new Error('elevated helper returned empty output')
+    const joined = lines.join('\n')
 
-    let payload: any
-    try {
-      payload = JSON.parse(last)
-    } catch {
-      throw new Error('elevated helper returned invalid json: ' + last)
+    if (joined.startsWith('WF_ERR::')) {
+      const parts = joined.split('::')
+      const errNum = parts[1] || 'unknown'
+      const errMsg = parts[2] || 'unknown'
+      const partial = parts.slice(3).join('::')
+      throw new Error(`elevated helper failed: errNum=${errNum}, errMsg=${errMsg}, partial=${partial || '(empty)'}`)
     }
-    if (payload?.success === true && typeof payload?.key === 'string') return payload.key
-    if (typeof payload?.result === 'string') return payload.result
-    throw new Error('elevated helper json missing key/result')
+    const normalizedOutput = joined.startsWith('WF_OK::') ? joined.slice('WF_OK::'.length) : joined
+
+    // 从所有行里提取所有 JSON 对象（同一行可能有多个拼接），找含 key/result 的那个
+    const extractJsonObjects = (s: string): any[] => {
+      const results: any[] = []
+      const re = /\{[^{}]*\}/g
+      let m: RegExpExecArray | null
+      while ((m = re.exec(s)) !== null) {
+        try { results.push(JSON.parse(m[0])) } catch { }
+      }
+      return results
+    }
+    const fullOutput = normalizedOutput
+    const allJson = extractJsonObjects(fullOutput)
+    // 优先找 success=true && key 字段
+    const successPayload = allJson.find(p => p?.success === true && typeof p?.key === 'string')
+    if (successPayload) return successPayload.key
+    // 其次找 result 字段
+    const resultPayload = allJson.find(p => typeof p?.result === 'string')
+    if (resultPayload) return resultPayload.result
+    throw new Error('elevated helper returned invalid json: ' + lines[lines.length - 1])
   }
 
   private mapDbKeyErrorMessage(code?: string, detail?: string): string {
@@ -479,26 +528,39 @@ export class KeyServiceMac {
 
       const wxidCandidates = this.collectWxidCandidates(accountPath, wxid)
       if (wxidCandidates.length === 0) {
-        return { success: false, error: '未找到可用的 wxid 候选，请先选择正确的账号目录' }
+        return { success: false, error: '未找到可用的账号候选，请先选择正确的账号目录' }
       }
 
+      const accountPathCandidates = this.collectAccountPathCandidates(accountPath)
+
       // 使用模板密文做验真，避免 wxid 不匹配导致快速方案算错
-      let verifyCiphertext: Buffer | null = null
-      if (accountPath && existsSync(accountPath)) {
-        const template = await this._findTemplateData(accountPath, 32)
-        verifyCiphertext = template.ciphertext
-      }
-      if (verifyCiphertext) {
+      if (accountPathCandidates.length > 0) {
         onStatus?.(`正在校验候选 wxid（${wxidCandidates.length} 个）...`)
-        for (const candidateWxid of wxidCandidates) {
-          for (const code of codes) {
-            const { xorKey, aesKey } = this.deriveImageKeys(code, candidateWxid)
-            if (!this.verifyDerivedAesKey(aesKey, verifyCiphertext)) continue
-            onStatus?.(`密钥获取成功 (wxid: ${candidateWxid}, code: ${code})`)
-            return { success: true, xorKey, aesKey }
+        for (const candidateAccountPath of accountPathCandidates) {
+          if (!existsSync(candidateAccountPath)) continue
+          const template = await this._findTemplateData(candidateAccountPath, 32)
+          if (!template.ciphertext) continue
+
+          const accountDirWxid = basename(candidateAccountPath)
+          const orderedWxids: string[] = []
+          this.pushAccountIdCandidates(orderedWxids, accountDirWxid)
+          for (const candidate of wxidCandidates) {
+            this.pushAccountIdCandidates(orderedWxids, candidate)
+          }
+
+          for (const candidateWxid of orderedWxids) {
+            for (const code of codes) {
+              const { xorKey, aesKey } = this.deriveImageKeys(code, candidateWxid)
+              if (!this.verifyDerivedAesKey(aesKey, template.ciphertext)) continue
+              onStatus?.(`密钥获取成功 (wxid: ${candidateWxid}, code: ${code})`)
+              return { success: true, xorKey, aesKey }
+            }
           }
         }
-        return { success: false, error: '缓存 code 与当前账号 wxid 未匹配，请确认账号目录后重试，或使用内存扫描' }
+        return {
+          success: false,
+          error: '缓存 code 与当前账号 wxid 未匹配。若数据库密钥获取后微信刚刚崩溃并重启，可能当前选中的账号目录已经不是最新会话；请先重新扫描 wxid，或直接使用内存扫描。'
+        }
       }
 
       // 无法获取模板密文时，回退为历史策略（优先级最高候选 + 第一条 code）
@@ -533,16 +595,21 @@ export class KeyServiceMac {
 
       onProgress?.(`XOR 密钥: 0x${xorKey.toString(16).padStart(2, '0')}，正在查找微信进程...`)
 
-      // 2. 找微信 PID
-      const pid = await this.findWeChatPid()
-      if (!pid) return { success: false, error: '微信进程未运行，请先启动微信' }
-
-      onProgress?.(`已找到微信进程 PID=${pid}，正在扫描内存...`)
-
-      // 3. 持续轮询内存扫描
+      // 2. 持续轮询微信 PID 与内存扫描，兼容微信崩溃后重启 PID 变化
       const deadline = Date.now() + 60_000
       let scanCount = 0
+      let lastPid: number | null = null
       while (Date.now() < deadline) {
+        const pid = await this.findWeChatPid()
+        if (!pid) {
+          onProgress?.('暂未检测到微信主进程，请确认微信已经重新打开...')
+          await new Promise(r => setTimeout(r, 2000))
+          continue
+        }
+        if (lastPid !== pid) {
+          lastPid = pid
+          onProgress?.(`已找到微信进程 PID=${pid}，正在扫描内存...`)
+        }
         scanCount++
         onProgress?.(`第 ${scanCount} 次扫描内存，请在微信中打开图片大图...`)
         const aesKey = await this._scanMemoryForAesKey(pid, ciphertext, onProgress)
@@ -755,7 +822,7 @@ export class KeyServiceMac {
           }
 
           const current = chunk.subarray(0, bytesRead)
-          const data = trailing ? Buffer.concat([trailing, current]) : current
+          const data: Buffer = trailing ? Buffer.concat([trailing, current]) : current
           const key = this._searchAsciiKey(data, ciphertext) || this._searchUtf16Key(data, ciphertext)
           if (key) return key
           // 兜底：兼容旧 C++ 的滑窗 16-byte 扫描（严格规则 miss 时仍可命中）
@@ -784,8 +851,8 @@ export class KeyServiceMac {
       }
       const tag = elevated ? '[image_scan_helper:elevated]' : '[image_scan_helper]'
       let stdout = '', stderr = ''
-      child.stdout.on('data', (chunk: Buffer) => { stdout += chunk.toString() })
-      child.stderr.on('data', (chunk: Buffer) => {
+      child.stdout?.on('data', (chunk: Buffer) => { stdout += chunk.toString() })
+      child.stderr?.on('data', (chunk: Buffer) => {
         stderr += chunk.toString()
         console.log(tag, chunk.toString().trim())
       })
@@ -810,11 +877,8 @@ export class KeyServiceMac {
   }
 
   private async findWeChatPid(): Promise<number | null> {
-    const { execSync } = await import('child_process')
     try {
-      const output = execSync('pgrep -x WeChat', { encoding: 'utf8' })
-      const pid = parseInt(output.trim())
-      return isNaN(pid) ? null : pid
+      return await this.getWeChatPid()
     } catch {
       return null
     }
@@ -831,12 +895,77 @@ export class KeyServiceMac {
     this.machPortDeallocate = null
   }
 
+  private normalizeAccountId(value: string): string {
+    const trimmed = String(value || '').trim()
+    if (!trimmed) return ''
+
+    if (trimmed.toLowerCase().startsWith('wxid_')) {
+      const match = trimmed.match(/^(wxid_[^_]+)/i)
+      return match?.[1] || trimmed
+    }
+
+    const suffixMatch = trimmed.match(/^(.+)_([a-zA-Z0-9]{4})$/)
+    return suffixMatch ? suffixMatch[1] : trimmed
+  }
+
+  private isIgnoredAccountName(value: string): boolean {
+    const lowered = String(value || '').trim().toLowerCase()
+    if (!lowered) return true
+    return lowered === 'xwechat_files' ||
+      lowered === 'all_users' ||
+      lowered === 'backup' ||
+      lowered === 'wmpf' ||
+      lowered === 'app_data'
+  }
+
+  private isReasonableAccountId(value: string): boolean {
+    const trimmed = String(value || '').trim()
+    if (!trimmed) return false
+    if (trimmed.includes('/') || trimmed.includes('\\')) return false
+    return !this.isIgnoredAccountName(trimmed)
+  }
+
+  private isAccountDirPath(entryPath: string): boolean {
+    return existsSync(join(entryPath, 'db_storage')) ||
+      existsSync(join(entryPath, 'msg')) ||
+      existsSync(join(entryPath, 'FileStorage', 'Image')) ||
+      existsSync(join(entryPath, 'FileStorage', 'Image2'))
+  }
+
+  private resolveXwechatRootFromPath(accountPath?: string): string | null {
+    const normalized = String(accountPath || '').replace(/\\/g, '/').replace(/\/+$/, '')
+    if (!normalized) return null
+
+    // 旧路径：xwechat_files
+    const marker = '/xwechat_files'
+    const markerIdx = normalized.indexOf(marker)
+    if (markerIdx >= 0) return normalized.slice(0, markerIdx + marker.length)
+
+    // 新路径（微信 4.0.5+）：Application Support/com.tencent.xinWeChat/2.0b4.0.9
+    const newMarkerMatch = normalized.match(/^(.*\/com\.tencent\.xinWeChat\/(?:\d+\.\d+b\d+\.\d+|\d+\.\d+\.\d+))(\/|$)/)
+    if (newMarkerMatch) return newMarkerMatch[1]
+
+    return null
+  }
+
+  private pushAccountIdCandidates(candidates: string[], value?: string): void {
+    const pushUnique = (item: string) => {
+      const trimmed = String(item || '').trim()
+      if (!trimmed || candidates.includes(trimmed)) return
+      candidates.push(trimmed)
+    }
+
+    const raw = String(value || '').trim()
+    if (!this.isReasonableAccountId(raw)) return
+    pushUnique(raw)
+    const normalized = this.normalizeAccountId(raw)
+    if (normalized && normalized !== raw && this.isReasonableAccountId(normalized)) {
+      pushUnique(normalized)
+    }
+  }
+
   private cleanWxid(wxid: string): string {
-    const first = wxid.indexOf('_')
-    if (first === -1) return wxid
-    const second = wxid.indexOf('_', first + 1)
-    if (second === -1) return wxid
-    return wxid.substring(0, second)
+    return this.normalizeAccountId(wxid)
   }
 
   private deriveImageKeys(code: number, wxid: string): { xorKey: number; aesKey: string } {
@@ -849,32 +978,59 @@ export class KeyServiceMac {
 
   private collectWxidCandidates(accountPath?: string, wxidParam?: string): string[] {
     const candidates: string[] = []
-    const pushUnique = (value: string) => {
-      const v = String(value || '').trim()
-      if (!v || candidates.includes(v)) return
-      candidates.push(v)
-    }
 
     // 1) 显式传参优先
-    if (wxidParam && wxidParam.startsWith('wxid_')) pushUnique(wxidParam)
+    this.pushAccountIdCandidates(candidates, wxidParam)
 
     if (accountPath) {
       const normalized = accountPath.replace(/\\/g, '/').replace(/\/+$/, '')
       const dirName = basename(normalized)
-      // 2) 当前目录名为 wxid_*
-      if (dirName.startsWith('wxid_')) pushUnique(dirName)
+      // 2) 当前目录名本身就是账号目录
+      this.pushAccountIdCandidates(candidates, dirName)
 
-      // 3) 从 xwechat_files 根目录枚举全部 wxid_* 目录
-      const marker = '/xwechat_files'
-      const markerIdx = normalized.indexOf(marker)
-      if (markerIdx >= 0) {
-        const root = normalized.slice(0, markerIdx + marker.length)
+      // 3) 从 xwechat_files 根目录枚举全部账号目录
+      const root = this.resolveXwechatRootFromPath(accountPath)
+      if (root) {
         if (existsSync(root)) {
           try {
             for (const entry of readdirSync(root, { withFileTypes: true })) {
               if (!entry.isDirectory()) continue
-              if (!entry.name.startsWith('wxid_')) continue
-              pushUnique(entry.name)
+              const entryPath = join(root, entry.name)
+              if (!this.isAccountDirPath(entryPath)) continue
+              this.pushAccountIdCandidates(candidates, entry.name)
+            }
+          } catch {
+            // ignore
+          }
+        }
+      }
+    }
+
+    if (candidates.length === 0) candidates.push('unknown')
+    return candidates
+  }
+
+  private collectAccountPathCandidates(accountPath?: string): string[] {
+    const candidates: string[] = []
+    const pushUnique = (value?: string) => {
+      const v = String(value || '').trim()
+      if (!v || candidates.includes(v)) return
+      candidates.push(v)
+    }
+
+    if (accountPath) pushUnique(accountPath)
+
+    if (accountPath) {
+      const root = this.resolveXwechatRootFromPath(accountPath)
+      if (root) {
+        if (existsSync(root)) {
+          try {
+            for (const entry of readdirSync(root, { withFileTypes: true })) {
+              if (!entry.isDirectory()) continue
+              const entryPath = join(root, entry.name)
+              if (!this.isAccountDirPath(entryPath)) continue
+              if (!this.isReasonableAccountId(entry.name)) continue
+              pushUnique(entryPath)
             }
           } catch {
             // ignore
@@ -883,7 +1039,6 @@ export class KeyServiceMac {
       }
     }
 
-    pushUnique('unknown')
     return candidates
   }
 
@@ -948,6 +1103,16 @@ export class KeyServiceMac {
         candidates.add(`${base}/app_data/net/kvcomm`)
       }
 
+      // 微信 4.0.5+ 新路径推导：版本目录同级的 net/kvcomm
+      const newMarkerMatch = normalized.match(/^(.*\/com\.tencent\.xinWeChat\/(?:\d+\.\d+b\d+\.\d+|\d+\.\d+\.\d+))/)
+      if (newMarkerMatch) {
+        const versionBase = newMarkerMatch[1]
+        candidates.add(`${versionBase}/net/kvcomm`)
+        // 上级目录也尝试
+        const parentBase = versionBase.replace(/\/[^\/]+$/, '')
+        candidates.add(`${parentBase}/net/kvcomm`)
+      }
+
       let cursor = accountPath
       for (let i = 0; i < 6; i++) {
         candidates.add(join(cursor, 'net', 'kvcomm'))

electron/services/messagePushService.ts

@@ -0,0 +1,379 @@
+import { ConfigService } from './config'
+import { chatService, type ChatSession, type Message } from './chatService'
+import { wcdbService } from './wcdbService'
+import { httpService } from './httpService'
+
+interface SessionBaseline {
+  lastTimestamp: number
+  unreadCount: number
+}
+
+interface MessagePushPayload {
+  event: 'message.new'
+  sessionId: string
+  messageKey: string
+  avatarUrl?: string
+  sourceName: string
+  groupName?: string
+  content: string | null
+}
+
+const PUSH_CONFIG_KEYS = new Set([
+  'messagePushEnabled',
+  'dbPath',
+  'decryptKey',
+  'myWxid'
+])
+
+class MessagePushService {
+  private readonly configService: ConfigService
+  private readonly sessionBaseline = new Map<string, SessionBaseline>()
+  private readonly recentMessageKeys = new Map<string, number>()
+  private readonly groupNicknameCache = new Map<string, { nicknames: Record<string, string>; updatedAt: number }>()
+  private readonly debounceMs = 350
+  private readonly recentMessageTtlMs = 10 * 60 * 1000
+  private readonly groupNicknameCacheTtlMs = 5 * 60 * 1000
+  private debounceTimer: ReturnType<typeof setTimeout> | null = null
+  private processing = false
+  private rerunRequested = false
+  private started = false
+  private baselineReady = false
+
+  constructor() {
+    this.configService = ConfigService.getInstance()
+  }
+
+  start(): void {
+    if (this.started) return
+    this.started = true
+    void this.refreshConfiguration('startup')
+  }
+
+  handleDbMonitorChange(type: string, json: string): void {
+    if (!this.started) return
+    if (!this.isPushEnabled()) return
+
+    let payload: Record<string, unknown> | null = null
+    try {
+      payload = JSON.parse(json)
+    } catch {
+      payload = null
+    }
+
+    const tableName = String(payload?.table || '').trim().toLowerCase()
+    if (tableName && tableName !== 'session') {
+      return
+    }
+
+    this.scheduleSync()
+  }
+
+  async handleConfigChanged(key: string): Promise<void> {
+    if (!PUSH_CONFIG_KEYS.has(String(key || '').trim())) return
+    if (key === 'dbPath' || key === 'decryptKey' || key === 'myWxid') {
+      this.resetRuntimeState()
+      chatService.close()
+    }
+    await this.refreshConfiguration(`config:${key}`)
+  }
+
+  handleConfigCleared(): void {
+    this.resetRuntimeState()
+    chatService.close()
+  }
+
+  private isPushEnabled(): boolean {
+    return this.configService.get('messagePushEnabled') === true
+  }
+
+  private resetRuntimeState(): void {
+    this.sessionBaseline.clear()
+    this.recentMessageKeys.clear()
+    this.groupNicknameCache.clear()
+    this.baselineReady = false
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer)
+      this.debounceTimer = null
+    }
+  }
+
+  private async refreshConfiguration(reason: string): Promise<void> {
+    if (!this.isPushEnabled()) {
+      this.resetRuntimeState()
+      return
+    }
+
+    const connectResult = await chatService.connect()
+    if (!connectResult.success) {
+      console.warn(`[MessagePushService] Bootstrap connect failed (${reason}):`, connectResult.error)
+      return
+    }
+
+    await this.bootstrapBaseline()
+  }
+
+  private async bootstrapBaseline(): Promise<void> {
+    const sessionsResult = await chatService.getSessions()
+    if (!sessionsResult.success || !sessionsResult.sessions) {
+      return
+    }
+    this.setBaseline(sessionsResult.sessions as ChatSession[])
+    this.baselineReady = true
+  }
+
+  private scheduleSync(): void {
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer)
+    }
+
+    this.debounceTimer = setTimeout(() => {
+      this.debounceTimer = null
+      void this.flushPendingChanges()
+    }, this.debounceMs)
+  }
+
+  private async flushPendingChanges(): Promise<void> {
+    if (this.processing) {
+      this.rerunRequested = true
+      return
+    }
+
+    this.processing = true
+    try {
+      if (!this.isPushEnabled()) return
+
+      const connectResult = await chatService.connect()
+      if (!connectResult.success) {
+        console.warn('[MessagePushService] Sync connect failed:', connectResult.error)
+        return
+      }
+
+      const sessionsResult = await chatService.getSessions()
+      if (!sessionsResult.success || !sessionsResult.sessions) {
+        return
+      }
+
+      const sessions = sessionsResult.sessions as ChatSession[]
+      if (!this.baselineReady) {
+        this.setBaseline(sessions)
+        this.baselineReady = true
+        return
+      }
+
+      const previousBaseline = new Map(this.sessionBaseline)
+      this.setBaseline(sessions)
+
+      const candidates = sessions.filter((session) => this.shouldInspectSession(previousBaseline.get(session.username), session))
+      for (const session of candidates) {
+        await this.pushSessionMessages(session, previousBaseline.get(session.username))
+      }
+    } finally {
+      this.processing = false
+      if (this.rerunRequested) {
+        this.rerunRequested = false
+        this.scheduleSync()
+      }
+    }
+  }
+
+  private setBaseline(sessions: ChatSession[]): void {
+    this.sessionBaseline.clear()
+    for (const session of sessions) {
+      this.sessionBaseline.set(session.username, {
+        lastTimestamp: Number(session.lastTimestamp || 0),
+        unreadCount: Number(session.unreadCount || 0)
+      })
+    }
+  }
+
+  private shouldInspectSession(previous: SessionBaseline | undefined, session: ChatSession): boolean {
+    const sessionId = String(session.username || '').trim()
+    if (!sessionId || sessionId.toLowerCase().includes('placeholder_foldgroup')) {
+      return false
+    }
+
+    const summary = String(session.summary || '').trim()
+    if (Number(session.lastMsgType || 0) === 10002 || summary.includes('撤回了一条消息')) {
+      return false
+    }
+
+    const lastTimestamp = Number(session.lastTimestamp || 0)
+    const unreadCount = Number(session.unreadCount || 0)
+
+    if (!previous) {
+      return unreadCount > 0 && lastTimestamp > 0
+    }
+
+    if (lastTimestamp <= previous.lastTimestamp) {
+      return false
+    }
+
+    // unread 未增长时，大概率是自己发送、其他设备已读或状态同步，不作为主动推送
+    return unreadCount > previous.unreadCount
+  }
+
+  private async pushSessionMessages(session: ChatSession, previous: SessionBaseline | undefined): Promise<void> {
+    const since = Math.max(0, Number(previous?.lastTimestamp || 0) - 1)
+    const newMessagesResult = await chatService.getNewMessages(session.username, since, 1000)
+    if (!newMessagesResult.success || !newMessagesResult.messages || newMessagesResult.messages.length === 0) {
+      return
+    }
+
+    for (const message of newMessagesResult.messages) {
+      const messageKey = String(message.messageKey || '').trim()
+      if (!messageKey) continue
+      if (message.isSend === 1) continue
+
+      if (previous && Number(message.createTime || 0) < Number(previous.lastTimestamp || 0)) {
+        continue
+      }
+
+      if (this.isRecentMessage(messageKey)) {
+        continue
+      }
+
+      const payload = await this.buildPayload(session, message)
+      if (!payload) continue
+
+      httpService.broadcastMessagePush(payload)
+      this.rememberMessageKey(messageKey)
+    }
+  }
+
+  private async buildPayload(session: ChatSession, message: Message): Promise<MessagePushPayload | null> {
+    const sessionId = String(session.username || '').trim()
+    const messageKey = String(message.messageKey || '').trim()
+    if (!sessionId || !messageKey) return null
+
+    const isGroup = sessionId.endsWith('@chatroom')
+    const content = this.getMessageDisplayContent(message)
+
+    if (isGroup) {
+      const groupInfo = await chatService.getContactAvatar(sessionId)
+      const groupName = session.displayName || groupInfo?.displayName || sessionId
+      const sourceName = await this.resolveGroupSourceName(sessionId, message, session)
+      return {
+        event: 'message.new',
+        sessionId,
+        messageKey,
+        avatarUrl: session.avatarUrl || groupInfo?.avatarUrl,
+        groupName,
+        sourceName,
+        content
+      }
+    }
+
+    const contactInfo = await chatService.getContactAvatar(sessionId)
+    return {
+      event: 'message.new',
+      sessionId,
+      messageKey,
+      avatarUrl: session.avatarUrl || contactInfo?.avatarUrl,
+      sourceName: session.displayName || contactInfo?.displayName || sessionId,
+      content
+    }
+  }
+
+  private getMessageDisplayContent(message: Message): string | null {
+    switch (Number(message.localType || 0)) {
+      case 1:
+        return message.rawContent || null
+      case 3:
+        return '[图片]'
+      case 34:
+        return '[语音]'
+      case 43:
+        return '[视频]'
+      case 47:
+        return '[表情]'
+      case 42:
+        return message.cardNickname || '[名片]'
+      case 48:
+        return '[位置]'
+      case 49:
+        return message.linkTitle || message.fileName || '[消息]'
+      default:
+        return message.parsedContent || message.rawContent || null
+    }
+  }
+
+  private async resolveGroupSourceName(chatroomId: string, message: Message, session: ChatSession): Promise<string> {
+    const senderUsername = String(message.senderUsername || '').trim()
+    if (!senderUsername) {
+      return session.lastSenderDisplayName || '未知发送者'
+    }
+
+    const groupNicknames = await this.getGroupNicknames(chatroomId)
+    const senderKey = senderUsername.toLowerCase()
+    const nickname = groupNicknames[senderKey]
+
+    if (nickname) {
+      return nickname
+    }
+
+    const contactInfo = await chatService.getContactAvatar(senderUsername)
+    return contactInfo?.displayName || senderUsername
+  }
+
+  private async getGroupNicknames(chatroomId: string): Promise<Record<string, string>> {
+    const cacheKey = String(chatroomId || '').trim()
+    if (!cacheKey) return {}
+
+    const cached = this.groupNicknameCache.get(cacheKey)
+    if (cached && Date.now() - cached.updatedAt < this.groupNicknameCacheTtlMs) {
+      return cached.nicknames
+    }
+
+    const result = await wcdbService.getGroupNicknames(cacheKey)
+    const nicknames = result.success && result.nicknames
+      ? this.sanitizeGroupNicknames(result.nicknames)
+      : {}
+    this.groupNicknameCache.set(cacheKey, { nicknames, updatedAt: Date.now() })
+    return nicknames
+  }
+
+  private sanitizeGroupNicknames(nicknames: Record<string, string>): Record<string, string> {
+    const buckets = new Map<string, Set<string>>()
+    for (const [memberIdRaw, nicknameRaw] of Object.entries(nicknames || {})) {
+      const memberId = String(memberIdRaw || '').trim().toLowerCase()
+      const nickname = String(nicknameRaw || '').trim()
+      if (!memberId || !nickname) continue
+      const slot = buckets.get(memberId)
+      if (slot) {
+        slot.add(nickname)
+      } else {
+        buckets.set(memberId, new Set([nickname]))
+      }
+    }
+
+    const trusted: Record<string, string> = {}
+    for (const [memberId, nicknameSet] of buckets.entries()) {
+      if (nicknameSet.size !== 1) continue
+      trusted[memberId] = Array.from(nicknameSet)[0]
+    }
+    return trusted
+  }
+
+  private isRecentMessage(messageKey: string): boolean {
+    this.pruneRecentMessageKeys()
+    const timestamp = this.recentMessageKeys.get(messageKey)
+    return typeof timestamp === 'number' && Date.now() - timestamp < this.recentMessageTtlMs
+  }
+
+  private rememberMessageKey(messageKey: string): void {
+    this.recentMessageKeys.set(messageKey, Date.now())
+    this.pruneRecentMessageKeys()
+  }
+
+  private pruneRecentMessageKeys(): void {
+    const now = Date.now()
+    for (const [key, timestamp] of this.recentMessageKeys.entries()) {
+      if (now - timestamp > this.recentMessageTtlMs) {
+        this.recentMessageKeys.delete(key)
+      }
+    }
+  }
+
+}
+
+export const messagePushService = new MessagePushService()

electron/services/snsService.ts

@@ -27,6 +27,17 @@ export interface SnsMedia {
     livePhoto?: SnsLivePhoto
 }
 
+export interface SnsLocation {
+    latitude?: number
+    longitude?: number
+    city?: string
+    country?: string
+    poiName?: string
+    poiAddress?: string
+    poiAddressName?: string
+    label?: string
+}
+
 export interface SnsPost {
     id: string
     tid?: string       // 数据库主键（雪花 ID），用于精确删除
@@ -39,6 +50,7 @@ export interface SnsPost {
     media: SnsMedia[]
     likes: string[]
     comments: { id: string; nickname: string; content: string; refCommentId: string; refNickname?: string; emojis?: { url: string; md5: string; width: number; height: number; encryptUrl?: string; aesKey?: string }[] }[]
+    location?: SnsLocation
     rawXml?: string
     linkTitle?: string
     linkUrl?: string
@@ -287,6 +299,17 @@ function parseCommentsFromXml(xml: string): ParsedCommentItem[] {
     return comments
 }
 
+const decodeXmlText = (text: string): string => {
+    if (!text) return ''
+    return text
+        .replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, '$1')
+        .replace(/&amp;/gi, '&')
+        .replace(/&lt;/gi, '<')
+        .replace(/&gt;/gi, '>')
+        .replace(/&quot;/gi, '"')
+        .replace(/&#39;/gi, "'")
+}
+
 class SnsService {
     private configService: ConfigService
     private contactCache: ContactCacheService
@@ -514,6 +537,32 @@ class SnsService {
         return raw.trim()
     }
 
+    private async collectSnsUsernamesFromTimeline(maxRounds: number = 2000): Promise<string[]> {
+        const pageSize = 500
+        const uniqueUsers = new Set<string>()
+        let offset = 0
+
+        for (let round = 0; round < maxRounds; round++) {
+            const result = await wcdbService.getSnsTimeline(pageSize, offset, undefined, undefined, 0, 0)
+            if (!result.success || !Array.isArray(result.timeline)) {
+                throw new Error(result.error || '获取朋友圈发布者失败')
+            }
+
+            const rows = result.timeline
+            if (rows.length === 0) break
+
+            for (const row of rows) {
+                const username = this.pickTimelineUsername(row)
+                if (username) uniqueUsers.add(username)
+            }
+
+            if (rows.length < pageSize) break
+            offset += rows.length
+        }
+
+        return Array.from(uniqueUsers)
+    }
+
     private async getExportStatsFromTimeline(myWxid?: string): Promise<{ totalPosts: number; totalFriends: number; myPosts: number | null }> {
         const pageSize = 500
         const uniqueUsers = new Set<string>()
@@ -647,6 +696,110 @@ class SnsService {
         return { media, videoKey }
     }
 
+    private toOptionalNumber(value: unknown): number | undefined {
+        if (typeof value === 'number' && Number.isFinite(value)) return value
+        if (typeof value !== 'string') return undefined
+        const trimmed = value.trim()
+        if (!trimmed) return undefined
+        const parsed = Number.parseFloat(trimmed)
+        return Number.isFinite(parsed) ? parsed : undefined
+    }
+
+    private normalizeLocation(input: unknown): SnsLocation | undefined {
+        if (!input || typeof input !== 'object') return undefined
+
+        const row = input as Record<string, unknown>
+        const normalizeText = (value: unknown): string | undefined => {
+            if (typeof value !== 'string') return undefined
+            return this.toOptionalString(decodeXmlText(value))
+        }
+
+        const location: SnsLocation = {}
+        const latitude = this.toOptionalNumber(row.latitude ?? row.lat ?? row.x)
+        const longitude = this.toOptionalNumber(row.longitude ?? row.lng ?? row.y)
+        const city = normalizeText(row.city)
+        const country = normalizeText(row.country)
+        const poiName = normalizeText(row.poiName ?? row.poiname)
+        const poiAddress = normalizeText(row.poiAddress ?? row.poiaddress)
+        const poiAddressName = normalizeText(row.poiAddressName ?? row.poiaddressname)
+        const label = normalizeText(row.label)
+
+        if (latitude !== undefined) location.latitude = latitude
+        if (longitude !== undefined) location.longitude = longitude
+        if (city) location.city = city
+        if (country) location.country = country
+        if (poiName) location.poiName = poiName
+        if (poiAddress) location.poiAddress = poiAddress
+        if (poiAddressName) location.poiAddressName = poiAddressName
+        if (label) location.label = label
+
+        return Object.keys(location).length > 0 ? location : undefined
+    }
+
+    private parseLocationFromXml(xml: string): SnsLocation | undefined {
+        if (!xml) return undefined
+
+        try {
+            const locationTagMatch = xml.match(/<location\b([^>]*)>/i)
+            const locationAttrs = locationTagMatch?.[1] || ''
+            const readAttr = (name: string): string | undefined => {
+                if (!locationAttrs) return undefined
+                const match = locationAttrs.match(new RegExp(`${name}\\s*=\\s*["']([\\s\\S]*?)["']`, 'i'))
+                if (!match?.[1]) return undefined
+                return this.toOptionalString(decodeXmlText(match[1]))
+            }
+            const readTag = (name: string): string | undefined => {
+                const match = xml.match(new RegExp(`<${name}>([\\s\\S]*?)<\\/${name}>`, 'i'))
+                if (!match?.[1]) return undefined
+                return this.toOptionalString(decodeXmlText(match[1]))
+            }
+
+            const location: SnsLocation = {}
+            const latitude = this.toOptionalNumber(readAttr('latitude') || readAttr('x') || readTag('latitude') || readTag('x'))
+            const longitude = this.toOptionalNumber(readAttr('longitude') || readAttr('y') || readTag('longitude') || readTag('y'))
+            const city = readAttr('city') || readTag('city')
+            const country = readAttr('country') || readTag('country')
+            const poiName = readAttr('poiName') || readAttr('poiname') || readTag('poiName') || readTag('poiname')
+            const poiAddress = readAttr('poiAddress') || readAttr('poiaddress') || readTag('poiAddress') || readTag('poiaddress')
+            const poiAddressName = readAttr('poiAddressName') || readAttr('poiaddressname') || readTag('poiAddressName') || readTag('poiaddressname')
+            const label = readAttr('label') || readTag('label')
+
+            if (latitude !== undefined) location.latitude = latitude
+            if (longitude !== undefined) location.longitude = longitude
+            if (city) location.city = city
+            if (country) location.country = country
+            if (poiName) location.poiName = poiName
+            if (poiAddress) location.poiAddress = poiAddress
+            if (poiAddressName) location.poiAddressName = poiAddressName
+            if (label) location.label = label
+
+            return Object.keys(location).length > 0 ? location : undefined
+        } catch (e) {
+            console.error('[SnsService] 解析位置 XML 失败:', e)
+            return undefined
+        }
+    }
+
+    private mergeLocation(primary?: SnsLocation, fallback?: SnsLocation): SnsLocation | undefined {
+        if (!primary && !fallback) return undefined
+
+        const merged: SnsLocation = {}
+        const setValue = <K extends keyof SnsLocation>(key: K, value: SnsLocation[K] | undefined) => {
+            if (value !== undefined) merged[key] = value
+        }
+
+        setValue('latitude', primary?.latitude ?? fallback?.latitude)
+        setValue('longitude', primary?.longitude ?? fallback?.longitude)
+        setValue('city', primary?.city ?? fallback?.city)
+        setValue('country', primary?.country ?? fallback?.country)
+        setValue('poiName', primary?.poiName ?? fallback?.poiName)
+        setValue('poiAddress', primary?.poiAddress ?? fallback?.poiAddress)
+        setValue('poiAddressName', primary?.poiAddressName ?? fallback?.poiAddressName)
+        setValue('label', primary?.label ?? fallback?.label)
+
+        return Object.keys(merged).length > 0 ? merged : undefined
+    }
+
     private getSnsCacheDir(): string {
         const cachePath = this.configService.getCacheBasePath()
         const snsCacheDir = join(cachePath, 'sns_cache')
@@ -663,100 +816,39 @@ class SnsService {
     }
 
     async getSnsUsernames(): Promise<{ success: boolean; usernames?: string[]; error?: string }> {
-        const collect = (rows?: any[]): string[] => {
-            if (!Array.isArray(rows)) return []
-            const usernames: string[] = []
-            for (const row of rows) {
-                const raw = row?.user_name ?? row?.userName ?? row?.username ?? Object.values(row || {})[0]
-                const username = typeof raw === 'string' ? raw.trim() : String(raw || '').trim()
-                if (username) usernames.push(username)
+        const result = await wcdbService.getSnsUsernames()
+        if (!result.success) {
+            return { success: false, error: result.error || '获取朋友圈联系人失败' }
+        }
+        const directUsernames = Array.isArray(result.usernames) ? result.usernames : []
+        if (directUsernames.length > 0) {
+            return { success: true, usernames: directUsernames }
+        }
+
+        // 回退：通过 timeline 分页拉取收集用户名，兼容底层接口暂时返回空数组的场景。
+        try {
+            const timelineUsers = await this.collectSnsUsernamesFromTimeline()
+            if (timelineUsers.length > 0) {
+                return { success: true, usernames: timelineUsers }
             }
-            return usernames
+        } catch {
+            // 忽略回退错误，保持与原行为一致返回空数组
         }
 
-        const primary = await wcdbService.execQuery(
-            'sns',
-            null,
-            "SELECT DISTINCT user_name FROM SnsTimeLine WHERE user_name IS NOT NULL AND user_name <> ''"
-        )
-        const fallback = await wcdbService.execQuery(
-            'sns',
-            null,
-            "SELECT DISTINCT userName FROM SnsTimeLine WHERE userName IS NOT NULL AND userName <> ''"
-        )
-
-        const merged = Array.from(new Set([
-            ...collect(primary.rows),
-            ...collect(fallback.rows)
-        ]))
-
-        // 任一查询成功且拿到用户名即视为成功，避免因为列名差异导致误判为空。
-        if (merged.length > 0) {
-            return { success: true, usernames: merged }
-        }
-
-        // 两条查询都成功但无数据，说明确实没有朋友圈发布者。
-        if (primary.success || fallback.success) {
-            return { success: true, usernames: [] }
-        }
-
-        return { success: false, error: primary.error || fallback.error || '获取朋友圈联系人失败' }
+        return { success: true, usernames: directUsernames }
     }
 
     private async getExportStatsFromTableCount(myWxid?: string): Promise<{ totalPosts: number; totalFriends: number; myPosts: number | null }> {
-        let totalPosts = 0
-        let totalFriends = 0
-        let myPosts: number | null = null
-
-        const postCountResult = await wcdbService.execQuery('sns', null, 'SELECT COUNT(1) AS total FROM SnsTimeLine')
-        if (postCountResult.success && postCountResult.rows && postCountResult.rows.length > 0) {
-            totalPosts = this.parseCountValue(postCountResult.rows[0])
-        }
-
-        if (totalPosts > 0) {
-            const friendCountPrimary = await wcdbService.execQuery(
-                'sns',
-                null,
-                "SELECT COUNT(DISTINCT user_name) AS total FROM SnsTimeLine WHERE user_name IS NOT NULL AND user_name <> ''"
-            )
-            if (friendCountPrimary.success && friendCountPrimary.rows && friendCountPrimary.rows.length > 0) {
-                totalFriends = this.parseCountValue(friendCountPrimary.rows[0])
-            } else {
-                const friendCountFallback = await wcdbService.execQuery(
-                    'sns',
-                    null,
-                    "SELECT COUNT(DISTINCT userName) AS total FROM SnsTimeLine WHERE userName IS NOT NULL AND userName <> ''"
-                )
-                if (friendCountFallback.success && friendCountFallback.rows && friendCountFallback.rows.length > 0) {
-                    totalFriends = this.parseCountValue(friendCountFallback.rows[0])
-                }
-            }
-        }
-
         const normalizedMyWxid = this.toOptionalString(myWxid)
-        if (normalizedMyWxid) {
-            const myPostPrimary = await wcdbService.execQuery(
-                'sns',
-                null,
-                "SELECT COUNT(1) AS total FROM SnsTimeLine WHERE user_name = ?",
-                [normalizedMyWxid]
-            )
-            if (myPostPrimary.success && myPostPrimary.rows && myPostPrimary.rows.length > 0) {
-                myPosts = this.parseCountValue(myPostPrimary.rows[0])
-            } else {
-                const myPostFallback = await wcdbService.execQuery(
-                    'sns',
-                    null,
-                    "SELECT COUNT(1) AS total FROM SnsTimeLine WHERE userName = ?",
-                    [normalizedMyWxid]
-                )
-                if (myPostFallback.success && myPostFallback.rows && myPostFallback.rows.length > 0) {
-                    myPosts = this.parseCountValue(myPostFallback.rows[0])
-                }
-            }
+        const result = await wcdbService.getSnsExportStats(normalizedMyWxid || undefined)
+        if (!result.success || !result.data) {
+            return { totalPosts: 0, totalFriends: 0, myPosts: normalizedMyWxid ? 0 : null }
+        }
+        return {
+            totalPosts: Number(result.data.totalPosts || 0),
+            totalFriends: Number(result.data.totalFriends || 0),
+            myPosts: result.data.myPosts === null || result.data.myPosts === undefined ? null : Number(result.data.myPosts || 0)
         }
-
-        return { totalPosts, totalFriends, myPosts }
     }
 
     async getExportStats(options?: {
@@ -1024,7 +1116,12 @@ class SnsService {
         const enrichedTimeline = result.timeline.map((post: any) => {
             const contact = this.contactCache.get(post.username)
             const isVideoPost = post.type === 15
-            const videoKey = extractVideoKey(post.rawXml || '')
+            const rawXml = post.rawXml || ''
+            const videoKey = extractVideoKey(rawXml)
+            const location = this.mergeLocation(
+                this.normalizeLocation((post as { location?: unknown }).location),
+                this.parseLocationFromXml(rawXml)
+            )
 
             const fixedMedia = (post.media || []).map((m: any) => ({
                 url: fixSnsUrl(m.url, m.token, isVideoPost),
@@ -1047,7 +1144,6 @@ class SnsService {
             // 如果 DLL 评论缺少表情包信息，回退到从 rawXml 重新解析
             const dllComments: any[] = post.comments || []
             const hasEmojisInDll = dllComments.some((c: any) => c.emojis && c.emojis.length > 0)
-            const rawXml = post.rawXml || ''
 
             let finalComments: any[]
             if (dllComments.length > 0 && (hasEmojisInDll || !rawXml)) {
@@ -1066,7 +1162,8 @@ class SnsService {
                 avatarUrl: contact?.avatarUrl,
                 nickname: post.nickname || contact?.displayName || post.username,
                 media: fixedMedia,
-                comments: finalComments
+                comments: finalComments,
+                location
             }
         })
 
@@ -1143,7 +1240,7 @@ class SnsService {
         return { success: false, error: result.error }
     }
 
-    async downloadImage(url: string, key?: string | number): Promise<{ success: boolean; data?: Buffer; contentType?: string; error?: string }> {
+    async downloadImage(url: string, key?: string | number): Promise<{ success: boolean; data?: Buffer; contentType?: string; cachePath?: string; error?: string }> {
         return this.fetchAndDecryptImage(url, key)
     }
 
@@ -1422,6 +1519,7 @@ class SnsService {
                         })),
                         likes: p.likes,
                         comments: p.comments,
+                        location: p.location,
                         linkTitle: (p as any).linkTitle,
                         linkUrl: (p as any).linkUrl
                     }))
@@ -1473,6 +1571,7 @@ class SnsService {
                         })),
                         likes: post.likes,
                         comments: post.comments,
+                        location: post.location,
                         likesDetail,
                         commentsDetail,
                         linkTitle: (post as any).linkTitle,
@@ -1555,6 +1654,27 @@ class SnsService {
             const ch = name.charAt(0)
             return escapeHtml(ch || '?')
         }
+        const normalizeLocationText = (value?: string): string => (
+            decodeXmlText(String(value || '')).replace(/\s+/g, ' ').trim()
+        )
+        const resolveLocationText = (location?: SnsLocation): string => {
+            if (!location) return ''
+            const primaryCandidates = [
+                normalizeLocationText(location.poiName),
+                normalizeLocationText(location.poiAddressName),
+                normalizeLocationText(location.label),
+                normalizeLocationText(location.poiAddress)
+            ].filter(Boolean)
+            const primary = primaryCandidates[0] || ''
+            const region = [
+                normalizeLocationText(location.country),
+                normalizeLocationText(location.city)
+            ].filter(Boolean).join(' ')
+            if (primary && region && !primary.includes(region)) {
+                return `${primary} · ${region}`
+            }
+            return primary || region
+        }
 
         let filterInfo = ''
         if (filters.keyword) filterInfo += `关键词: "${escapeHtml(filters.keyword)}" `
@@ -1578,6 +1698,10 @@ class SnsService {
             const linkHtml = post.linkTitle && post.linkUrl
                 ? `<a class="lk" href="${escapeHtml(post.linkUrl)}" target="_blank"><span class="lk-t">${escapeHtml(post.linkTitle)}</span><span class="lk-a">›</span></a>`
                 : ''
+            const locationText = resolveLocationText(post.location)
+            const locationHtml = locationText
+                ? `<div class="loc"><span class="loc-i">📍</span><span class="loc-t">${escapeHtml(locationText)}</span></div>`
+                : ''
 
             const likesHtml = post.likes.length > 0
                 ? `<div class="interactions"><div class="likes">♥ ${post.likes.map(l => `<span>${escapeHtml(l)}</span>`).join('、')}</div></div>`
@@ -1600,6 +1724,7 @@ ${avatarHtml}
 <div class="body">
 <div class="hd"><span class="nick">${escapeHtml(post.nickname)}</span><span class="tm">${formatTime(post.createTime)}</span></div>
 ${post.contentDesc ? `<div class="txt">${escapeHtml(post.contentDesc)}</div>` : ''}
+${locationHtml}
 ${mediaHtml ? `<div class="mg ${gridClass}">${mediaHtml}</div>` : ''}
 ${linkHtml}
 ${likesHtml}
@@ -1635,6 +1760,9 @@ body{font-family:-apple-system,BlinkMacSystemFont,"Segoe UI","PingFang SC","Hira
 .nick{font-size:15px;font-weight:700;color:var(--accent);margin-bottom:2px}
 .tm{font-size:12px;color:var(--t3)}
 .txt{font-size:15px;line-height:1.6;white-space:pre-wrap;word-break:break-word;margin-bottom:12px}
+.loc{display:flex;align-items:flex-start;gap:6px;font-size:13px;color:var(--t2);margin:-4px 0 12px}
+.loc-i{line-height:1.3}
+.loc-t{line-height:1.45;word-break:break-word}
 
 /* 媒体网格 */
 .mg{display:grid;gap:6px;margin-bottom:12px;max-width:320px}

electron/services/videoService.ts

@@ -5,316 +5,553 @@ import { ConfigService } from './config'
 import { wcdbService } from './wcdbService'
 
 export interface VideoInfo {
-    videoUrl?: string       // 视频文件路径（用于 readFile）
-    coverUrl?: string       // 封面 data URL
-    thumbUrl?: string       // 缩略图 data URL
-    exists: boolean
+  videoUrl?: string       // 视频文件路径（用于 readFile）
+  coverUrl?: string       // 封面 data URL
+  thumbUrl?: string       // 缩略图 data URL
+  exists: boolean
+}
+
+interface TimedCacheEntry<T> {
+  value: T
+  expiresAt: number
+}
+
+interface VideoIndexEntry {
+  videoPath?: string
+  coverPath?: string
+  thumbPath?: string
 }
 
 class VideoService {
-    private configService: ConfigService
+  private configService: ConfigService
+  private hardlinkResolveCache = new Map<string, TimedCacheEntry<string | null>>()
+  private videoInfoCache = new Map<string, TimedCacheEntry<VideoInfo>>()
+  private videoDirIndexCache = new Map<string, TimedCacheEntry<Map<string, VideoIndexEntry>>>()
+  private pendingVideoInfo = new Map<string, Promise<VideoInfo>>()
+  private readonly hardlinkCacheTtlMs = 10 * 60 * 1000
+  private readonly videoInfoCacheTtlMs = 2 * 60 * 1000
+  private readonly videoIndexCacheTtlMs = 90 * 1000
+  private readonly maxCacheEntries = 2000
+  private readonly maxIndexEntries = 6
 
-    constructor() {
-        this.configService = new ConfigService()
+  constructor() {
+    this.configService = new ConfigService()
+  }
+
+  private log(message: string, meta?: Record<string, unknown>): void {
+    try {
+      const timestamp = new Date().toISOString()
+      const metaStr = meta ? ` ${JSON.stringify(meta)}` : ''
+      const logDir = join(app.getPath('userData'), 'logs')
+      if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true })
+      appendFileSync(join(logDir, 'wcdb.log'), `[${timestamp}] [VideoService] ${message}${metaStr}\n`, 'utf8')
+    } catch { }
+  }
+
+  private readTimedCache<T>(cache: Map<string, TimedCacheEntry<T>>, key: string): T | undefined {
+    const hit = cache.get(key)
+    if (!hit) return undefined
+    if (hit.expiresAt <= Date.now()) {
+      cache.delete(key)
+      return undefined
+    }
+    return hit.value
+  }
+
+  private writeTimedCache<T>(
+    cache: Map<string, TimedCacheEntry<T>>,
+    key: string,
+    value: T,
+    ttlMs: number,
+    maxEntries: number
+  ): void {
+    cache.set(key, { value, expiresAt: Date.now() + ttlMs })
+    if (cache.size <= maxEntries) return
+
+    const now = Date.now()
+    for (const [cacheKey, entry] of cache) {
+      if (entry.expiresAt <= now) {
+        cache.delete(cacheKey)
+      }
     }
 
-    private log(message: string, meta?: Record<string, unknown>): void {
-        try {
-            const timestamp = new Date().toISOString()
-            const metaStr = meta ? ` ${JSON.stringify(meta)}` : ''
-            const logDir = join(app.getPath('userData'), 'logs')
-            if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true })
-            appendFileSync(join(logDir, 'wcdb.log'), `[${timestamp}] [VideoService] ${message}${metaStr}\n`, 'utf8')
-        } catch {}
+    while (cache.size > maxEntries) {
+      const oldestKey = cache.keys().next().value as string | undefined
+      if (!oldestKey) break
+      cache.delete(oldestKey)
+    }
+  }
+
+  /**
+   * 获取数据库根目录
+   */
+  private getDbPath(): string {
+    return this.configService.get('dbPath') || ''
+  }
+
+  /**
+   * 获取当前用户的wxid
+   */
+  private getMyWxid(): string {
+    return this.configService.get('myWxid') || ''
+  }
+
+  /**
+   * 清理 wxid 目录名（去掉后缀）
+   */
+  private cleanWxid(wxid: string): string {
+    const trimmed = wxid.trim()
+    if (!trimmed) return trimmed
+
+    if (trimmed.toLowerCase().startsWith('wxid_')) {
+      const match = trimmed.match(/^(wxid_[^_]+)/i)
+      if (match) return match[1]
+      return trimmed
     }
 
-    /**
-     * 获取数据库根目录
-     */
-    private getDbPath(): string {
-        return this.configService.get('dbPath') || ''
+    const suffixMatch = trimmed.match(/^(.+)_([a-zA-Z0-9]{4})$/)
+    if (suffixMatch) return suffixMatch[1]
+
+    return trimmed
+  }
+
+  private getScopeKey(dbPath: string, wxid: string): string {
+    return `${dbPath}::${this.cleanWxid(wxid)}`.toLowerCase()
+  }
+
+  private resolveVideoBaseDir(dbPath: string, wxid: string): string {
+    const cleanedWxid = this.cleanWxid(wxid)
+    const dbPathLower = dbPath.toLowerCase()
+    const wxidLower = wxid.toLowerCase()
+    const cleanedWxidLower = cleanedWxid.toLowerCase()
+    const dbPathContainsWxid = dbPathLower.includes(wxidLower) || dbPathLower.includes(cleanedWxidLower)
+    if (dbPathContainsWxid) {
+      return join(dbPath, 'msg', 'video')
+    }
+    return join(dbPath, wxid, 'msg', 'video')
+  }
+
+  private getHardlinkDbPaths(dbPath: string, wxid: string, cleanedWxid: string): string[] {
+    const dbPathLower = dbPath.toLowerCase()
+    const wxidLower = wxid.toLowerCase()
+    const cleanedWxidLower = cleanedWxid.toLowerCase()
+    const dbPathContainsWxid = dbPathLower.includes(wxidLower) || dbPathLower.includes(cleanedWxidLower)
+
+    if (dbPathContainsWxid) {
+      return [join(dbPath, 'db_storage', 'hardlink', 'hardlink.db')]
     }
 
-    /**
-     * 获取当前用户的wxid
-     */
-    private getMyWxid(): string {
-        return this.configService.get('myWxid') || ''
+    return [
+      join(dbPath, wxid, 'db_storage', 'hardlink', 'hardlink.db'),
+      join(dbPath, cleanedWxid, 'db_storage', 'hardlink', 'hardlink.db')
+    ]
+  }
+
+  /**
+   * 从 video_hardlink_info_v4 表查询视频文件名
+   * 使用 wcdb 专属接口查询加密的 hardlink.db
+   */
+  private async resolveVideoHardlinks(
+    md5List: string[],
+    dbPath: string,
+    wxid: string,
+    cleanedWxid: string
+  ): Promise<Map<string, string>> {
+    const scopeKey = this.getScopeKey(dbPath, wxid)
+    const normalizedList = Array.from(
+      new Set((md5List || []).map((item) => String(item || '').trim().toLowerCase()).filter(Boolean))
+    )
+    const resolvedMap = new Map<string, string>()
+    const unresolvedSet = new Set(normalizedList)
+
+    for (const md5 of normalizedList) {
+      const cacheKey = `${scopeKey}|${md5}`
+      const cached = this.readTimedCache(this.hardlinkResolveCache, cacheKey)
+      if (cached === undefined) continue
+      if (cached) resolvedMap.set(md5, cached)
+      unresolvedSet.delete(md5)
     }
 
-    /**
-     * 获取缓存目录（解密后的数据库存放位置）
-     */
-    private getCachePath(): string {
-        return this.configService.getCacheBasePath()
-    }
+    if (unresolvedSet.size === 0) return resolvedMap
 
-    /**
-     * 清理 wxid 目录名（去掉后缀）
-     */
-    private cleanWxid(wxid: string): string {
-        const trimmed = wxid.trim()
-        if (!trimmed) return trimmed
-
-        if (trimmed.toLowerCase().startsWith('wxid_')) {
-            const match = trimmed.match(/^(wxid_[^_]+)/i)
-            if (match) return match[1]
-            return trimmed
-        }
-
-        const suffixMatch = trimmed.match(/^(.+)_([a-zA-Z0-9]{4})$/)
-        if (suffixMatch) return suffixMatch[1]
-
-        return trimmed
-    }
-
-    /**
-     * 从 video_hardlink_info_v4 表查询视频文件名
-     * 使用 wcdbService.execQuery 查询加密的 hardlink.db
-     */
-    private async queryVideoFileName(md5: string): Promise<string | undefined> {
-        const dbPath = this.getDbPath()
-        const wxid = this.getMyWxid()
-        const cleanedWxid = this.cleanWxid(wxid)
-
-        this.log('queryVideoFileName 开始', { md5, wxid, cleanedWxid, dbPath })
-
-        if (!wxid) {
-            this.log('queryVideoFileName: wxid 为空')
-            return undefined
-        }
-
-        // 使用 wcdbService.execQuery 查询加密的 hardlink.db
-        if (dbPath) {
-            const dbPathLower = dbPath.toLowerCase()
-            const wxidLower = wxid.toLowerCase()
-            const cleanedWxidLower = cleanedWxid.toLowerCase()
-            const dbPathContainsWxid = dbPathLower.includes(wxidLower) || dbPathLower.includes(cleanedWxidLower)
-
-            const encryptedDbPaths: string[] = []
-            if (dbPathContainsWxid) {
-                encryptedDbPaths.push(join(dbPath, 'db_storage', 'hardlink', 'hardlink.db'))
-            } else {
-                encryptedDbPaths.push(join(dbPath, wxid, 'db_storage', 'hardlink', 'hardlink.db'))
-                encryptedDbPaths.push(join(dbPath, cleanedWxid, 'db_storage', 'hardlink', 'hardlink.db'))
-            }
-
-            for (const p of encryptedDbPaths) {
-                if (existsSync(p)) {
-                    try {
-                        this.log('尝试加密 hardlink.db', { path: p })
-                        const escapedMd5 = md5.replace(/'/g, "''")
-                        const sql = `SELECT file_name FROM video_hardlink_info_v4 WHERE md5 = '${escapedMd5}' LIMIT 1`
-                        const result = await wcdbService.execQuery('media', p, sql)
-
-                        if (result.success && result.rows && result.rows.length > 0) {
-                            const row = result.rows[0]
-                            if (row?.file_name) {
-                                const realMd5 = String(row.file_name).replace(/\.[^.]+$/, '')
-                                this.log('加密 hardlink.db 命中', { file_name: row.file_name, realMd5 })
-                                return realMd5
-                            }
-                        }
-                        this.log('加密 hardlink.db 未命中', { path: p, result: JSON.stringify(result).slice(0, 200) })
-                    } catch (e) {
-                        this.log('加密 hardlink.db 查询失败', { path: p, error: String(e) })
-                    }
-                } else {
-                    this.log('加密 hardlink.db 不存在', { path: p })
-                }
-            }
-        }
-        this.log('queryVideoFileName: 所有方法均未找到', { md5 })
-        return undefined
-    }
-
-    /**
-     * 将文件转换为 data URL
-     */
-    private fileToDataUrl(filePath: string, mimeType: string): string | undefined {
-        try {
-            if (!existsSync(filePath)) return undefined
-            const buffer = readFileSync(filePath)
-            return `data:${mimeType};base64,${buffer.toString('base64')}`
-        } catch {
-            return undefined
-        }
-    }
-
-    /**
-     * 根据视频MD5获取视频文件信息
-     * 视频存放在: {数据库根目录}/{用户wxid}/msg/video/{年月}/
-     * 文件命名: {md5}.mp4, {md5}.jpg, {md5}_thumb.jpg
-     */
-    async getVideoInfo(videoMd5: string): Promise<VideoInfo> {
-        const dbPath = this.getDbPath()
-        const wxid = this.getMyWxid()
-
-        this.log('getVideoInfo 开始', { videoMd5, dbPath, wxid })
-
-        if (!dbPath || !wxid || !videoMd5) {
-            this.log('getVideoInfo: 参数缺失', { dbPath: !!dbPath, wxid: !!wxid, videoMd5: !!videoMd5 })
-            return { exists: false }
-        }
-
-        // 先尝试从数据库查询真正的视频文件名
-        const realVideoMd5 = await this.queryVideoFileName(videoMd5) || videoMd5
-        this.log('realVideoMd5', { input: videoMd5, resolved: realVideoMd5, changed: realVideoMd5 !== videoMd5 })
-
-        // 检查 dbPath 是否已经包含 wxid，避免重复拼接
-        const dbPathLower = dbPath.toLowerCase()
-        const wxidLower = wxid.toLowerCase()
-        const cleanedWxid = this.cleanWxid(wxid)
-
-        let videoBaseDir: string
-        if (dbPathLower.includes(wxidLower) || dbPathLower.includes(cleanedWxid.toLowerCase())) {
-            videoBaseDir = join(dbPath, 'msg', 'video')
+    const encryptedDbPaths = this.getHardlinkDbPaths(dbPath, wxid, cleanedWxid)
+    for (const p of encryptedDbPaths) {
+      if (!existsSync(p) || unresolvedSet.size === 0) continue
+      const unresolved = Array.from(unresolvedSet)
+      const requests = unresolved.map((md5) => ({ md5, dbPath: p }))
+      try {
+        const batchResult = await wcdbService.resolveVideoHardlinkMd5Batch(requests)
+        if (batchResult.success && Array.isArray(batchResult.rows)) {
+          for (const row of batchResult.rows) {
+            const index = Number.isFinite(Number(row?.index)) ? Math.floor(Number(row?.index)) : -1
+            const inputMd5 = index >= 0 && index < requests.length
+              ? requests[index].md5
+              : String(row?.md5 || '').trim().toLowerCase()
+            if (!inputMd5) continue
+            const resolvedMd5 = row?.success && row?.data?.resolved_md5
+              ? String(row.data.resolved_md5).trim().toLowerCase()
+              : ''
+            if (!resolvedMd5) continue
+            const cacheKey = `${scopeKey}|${inputMd5}`
+            this.writeTimedCache(this.hardlinkResolveCache, cacheKey, resolvedMd5, this.hardlinkCacheTtlMs, this.maxCacheEntries)
+            resolvedMap.set(inputMd5, resolvedMd5)
+            unresolvedSet.delete(inputMd5)
+          }
         } else {
-            videoBaseDir = join(dbPath, wxid, 'msg', 'video')
+          // 兼容不支持批量接口的版本，回退单条请求。
+          for (const req of requests) {
+            try {
+              const single = await wcdbService.resolveVideoHardlinkMd5(req.md5, req.dbPath)
+              const resolvedMd5 = single.success && single.data?.resolved_md5
+                ? String(single.data.resolved_md5).trim().toLowerCase()
+                : ''
+              if (!resolvedMd5) continue
+              const cacheKey = `${scopeKey}|${req.md5}`
+              this.writeTimedCache(this.hardlinkResolveCache, cacheKey, resolvedMd5, this.hardlinkCacheTtlMs, this.maxCacheEntries)
+              resolvedMap.set(req.md5, resolvedMd5)
+              unresolvedSet.delete(req.md5)
+            } catch { }
+          }
         }
-
-        this.log('videoBaseDir', { videoBaseDir, exists: existsSync(videoBaseDir) })
-
-        if (!existsSync(videoBaseDir)) {
-            this.log('getVideoInfo: videoBaseDir 不存在')
-            return { exists: false }
-        }
-
-        // 遍历年月目录查找视频文件
-        try {
-            const allDirs = readdirSync(videoBaseDir)
-            const yearMonthDirs = allDirs
-                .filter(dir => {
-                    const dirPath = join(videoBaseDir, dir)
-                    return statSync(dirPath).isDirectory()
-                })
-                .sort((a, b) => b.localeCompare(a))
-
-            this.log('扫描目录', { dirs: yearMonthDirs })
-
-            for (const yearMonth of yearMonthDirs) {
-                const dirPath = join(videoBaseDir, yearMonth)
-                const videoPath = join(dirPath, `${realVideoMd5}.mp4`)
-
-                if (existsSync(videoPath)) {
-                    // 封面/缩略图使用不带 _raw 后缀的基础名（自己发的视频文件名带 _raw，但封面不带）
-                    const baseMd5 = realVideoMd5.replace(/_raw$/, '')
-                    const coverPath = join(dirPath, `${baseMd5}.jpg`)
-                    const thumbPath = join(dirPath, `${baseMd5}_thumb.jpg`)
-
-                    // 列出同目录下与该 md5 相关的所有文件，帮助排查封面命名
-                    const allFiles = readdirSync(dirPath)
-                    const relatedFiles = allFiles.filter(f => f.toLowerCase().startsWith(realVideoMd5.slice(0, 8).toLowerCase()))
-                    this.log('找到视频，相关文件列表', {
-                        videoPath,
-                        coverExists: existsSync(coverPath),
-                        thumbExists: existsSync(thumbPath),
-                        relatedFiles,
-                        coverPath,
-                        thumbPath
-                    })
-
-                    return {
-                        videoUrl: videoPath,
-                        coverUrl: this.fileToDataUrl(coverPath, 'image/jpeg'),
-                        thumbUrl: this.fileToDataUrl(thumbPath, 'image/jpeg'),
-                        exists: true
-                    }
-                }
-            }
-
-            // 没找到，列出所有目录里的 mp4 文件帮助排查（最多每目录 10 个）
-            this.log('未找到视频，开始全目录扫描', {
-                lookingForOriginal: `${videoMd5}.mp4`,
-                lookingForResolved: `${realVideoMd5}.mp4`,
-                hardlinkResolved: realVideoMd5 !== videoMd5
-            })
-            for (const yearMonth of yearMonthDirs) {
-                const dirPath = join(videoBaseDir, yearMonth)
-                try {
-                    const allFiles = readdirSync(dirPath)
-                    const mp4Files = allFiles.filter(f => f.endsWith('.mp4')).slice(0, 10)
-                    // 检查原始 md5 是否部分匹配（前8位）
-                    const partialMatch = mp4Files.filter(f => f.toLowerCase().startsWith(videoMd5.slice(0, 8).toLowerCase()))
-                    this.log(`目录 ${yearMonth} 扫描结果`, {
-                        totalFiles: allFiles.length,
-                        mp4Count: allFiles.filter(f => f.endsWith('.mp4')).length,
-                        sampleMp4: mp4Files,
-                        partialMatchByOriginalMd5: partialMatch
-                    })
-                } catch (e) {
-                    this.log(`目录 ${yearMonth} 读取失败`, { error: String(e) })
-                }
-            }
-        } catch (e) {
-            this.log('getVideoInfo 遍历出错', { error: String(e) })
-        }
-
-        this.log('getVideoInfo: 未找到视频', { videoMd5, realVideoMd5 })
-        return { exists: false }
+      } catch (e) {
+        this.log('resolveVideoHardlinks 批量查询失败', { path: p, error: String(e) })
+      }
     }
 
-    /**
-     * 根据消息内容解析视频MD5
-     */
-    parseVideoMd5(content: string): string | undefined {
-        if (!content) return undefined
+    for (const md5 of unresolvedSet) {
+      const cacheKey = `${scopeKey}|${md5}`
+      this.writeTimedCache(this.hardlinkResolveCache, cacheKey, null, this.hardlinkCacheTtlMs, this.maxCacheEntries)
+    }
 
-        // 打印原始 XML 前 800 字符，帮助排查自己发的视频结构
-        this.log('parseVideoMd5 原始内容', { preview: content.slice(0, 800) })
+    return resolvedMap
+  }
 
+  private async queryVideoFileName(md5: string): Promise<string | undefined> {
+    const normalizedMd5 = String(md5 || '').trim().toLowerCase()
+    const dbPath = this.getDbPath()
+    const wxid = this.getMyWxid()
+    const cleanedWxid = this.cleanWxid(wxid)
+
+    this.log('queryVideoFileName 开始', { md5: normalizedMd5, wxid, cleanedWxid, dbPath })
+
+    if (!normalizedMd5 || !wxid || !dbPath) {
+      this.log('queryVideoFileName: 参数缺失', { hasMd5: !!normalizedMd5, hasWxid: !!wxid, hasDbPath: !!dbPath })
+      return undefined
+    }
+
+    const resolvedMap = await this.resolveVideoHardlinks([normalizedMd5], dbPath, wxid, cleanedWxid)
+    const resolved = resolvedMap.get(normalizedMd5)
+    if (resolved) {
+      this.log('queryVideoFileName 命中', { input: normalizedMd5, resolved })
+      return resolved
+    }
+    return undefined
+  }
+
+  async preloadVideoHardlinkMd5s(md5List: string[]): Promise<void> {
+    const dbPath = this.getDbPath()
+    const wxid = this.getMyWxid()
+    const cleanedWxid = this.cleanWxid(wxid)
+    if (!dbPath || !wxid) return
+    await this.resolveVideoHardlinks(md5List, dbPath, wxid, cleanedWxid)
+  }
+
+  /**
+   * 将文件转换为 data URL
+   */
+  private fileToDataUrl(filePath: string | undefined, mimeType: string): string | undefined {
+    try {
+      if (!filePath || !existsSync(filePath)) return undefined
+      const buffer = readFileSync(filePath)
+      return `data:${mimeType};base64,${buffer.toString('base64')}`
+    } catch {
+      return undefined
+    }
+  }
+
+  private getOrBuildVideoIndex(videoBaseDir: string): Map<string, VideoIndexEntry> {
+    const cached = this.readTimedCache(this.videoDirIndexCache, videoBaseDir)
+    if (cached) return cached
+
+    const index = new Map<string, VideoIndexEntry>()
+    const ensureEntry = (key: string): VideoIndexEntry => {
+      let entry = index.get(key)
+      if (!entry) {
+        entry = {}
+        index.set(key, entry)
+      }
+      return entry
+    }
+
+    try {
+      const yearMonthDirs = readdirSync(videoBaseDir)
+        .filter((dir) => {
+          const dirPath = join(videoBaseDir, dir)
+          try {
+            return statSync(dirPath).isDirectory()
+          } catch {
+            return false
+          }
+        })
+        .sort((a, b) => b.localeCompare(a))
+
+      for (const yearMonth of yearMonthDirs) {
+        const dirPath = join(videoBaseDir, yearMonth)
+        let files: string[] = []
         try {
-            // 收集所有 md5 相关属性，方便对比
-            const allMd5Attrs: string[] = []
-            const md5Regex = /(?:md5|rawmd5|newmd5|originsourcemd5)\s*=\s*['"]([a-fA-F0-9]*)['"]/gi
-            let match
-            while ((match = md5Regex.exec(content)) !== null) {
-                allMd5Attrs.push(match[0])
-            }
-            this.log('parseVideoMd5 所有 md5 属性', { attrs: allMd5Attrs })
-
-            // 方法1：从 <videomsg md5="..."> 提取（收到的视频）
-            const videoMsgMd5Match = /<videomsg[^>]*\smd5\s*=\s*['"]([a-fA-F0-9]+)['"]/i.exec(content)
-            if (videoMsgMd5Match) {
-                this.log('parseVideoMd5 命中 videomsg md5 属性', { md5: videoMsgMd5Match[1] })
-                return videoMsgMd5Match[1].toLowerCase()
-            }
-
-            // 方法2：从 <videomsg rawmd5="..."> 提取（自己发的视频，没有 md5 只有 rawmd5）
-            const rawMd5Match = /<videomsg[^>]*\srawmd5\s*=\s*['"]([a-fA-F0-9]+)['"]/i.exec(content)
-            if (rawMd5Match) {
-                this.log('parseVideoMd5 命中 videomsg rawmd5 属性（自发视频）', { rawmd5: rawMd5Match[1] })
-                return rawMd5Match[1].toLowerCase()
-            }
-
-            // 方法3：任意属性 md5="..."（非 rawmd5/cdnthumbaeskey 等）
-            const attrMatch = /(?<![a-z])md5\s*=\s*['"]([a-fA-F0-9]+)['"]/i.exec(content)
-            if (attrMatch) {
-                this.log('parseVideoMd5 命中通用 md5 属性', { md5: attrMatch[1] })
-                return attrMatch[1].toLowerCase()
-            }
-
-            // 方法4：<md5>...</md5> 标签
-            const md5TagMatch = /<md5>([a-fA-F0-9]+)<\/md5>/i.exec(content)
-            if (md5TagMatch) {
-                this.log('parseVideoMd5 命中 md5 标签', { md5: md5TagMatch[1] })
-                return md5TagMatch[1].toLowerCase()
-            }
-
-            // 方法5：兜底取 rawmd5 属性（任意位置）
-            const rawMd5Fallback = /\srawmd5\s*=\s*['"]([a-fA-F0-9]+)['"]/i.exec(content)
-            if (rawMd5Fallback) {
-                this.log('parseVideoMd5 兜底命中 rawmd5', { rawmd5: rawMd5Fallback[1] })
-                return rawMd5Fallback[1].toLowerCase()
-            }
-
-            this.log('parseVideoMd5 未提取到任何 md5', { contentLength: content.length })
-        } catch (e) {
-            this.log('parseVideoMd5 异常', { error: String(e) })
+          files = readdirSync(dirPath)
+        } catch {
+          continue
         }
 
-        return undefined
+        for (const file of files) {
+          const lower = file.toLowerCase()
+          const fullPath = join(dirPath, file)
+
+          if (lower.endsWith('.mp4')) {
+            const md5 = lower.slice(0, -4)
+            const entry = ensureEntry(md5)
+            if (!entry.videoPath) entry.videoPath = fullPath
+            if (md5.endsWith('_raw')) {
+              const baseMd5 = md5.replace(/_raw$/, '')
+              const baseEntry = ensureEntry(baseMd5)
+              if (!baseEntry.videoPath) baseEntry.videoPath = fullPath
+            }
+            continue
+          }
+
+          if (!lower.endsWith('.jpg')) continue
+          const jpgBase = lower.slice(0, -4)
+          if (jpgBase.endsWith('_thumb')) {
+            const baseMd5 = jpgBase.slice(0, -6)
+            const entry = ensureEntry(baseMd5)
+            if (!entry.thumbPath) entry.thumbPath = fullPath
+          } else {
+            const entry = ensureEntry(jpgBase)
+            if (!entry.coverPath) entry.coverPath = fullPath
+          }
+        }
+      }
+
+      for (const [key, entry] of index) {
+        if (!key.endsWith('_raw')) continue
+        const baseKey = key.replace(/_raw$/, '')
+        const baseEntry = index.get(baseKey)
+        if (!baseEntry) continue
+        if (!entry.coverPath) entry.coverPath = baseEntry.coverPath
+        if (!entry.thumbPath) entry.thumbPath = baseEntry.thumbPath
+      }
+    } catch (e) {
+      this.log('构建视频索引失败', { videoBaseDir, error: String(e) })
     }
+
+    this.writeTimedCache(
+      this.videoDirIndexCache,
+      videoBaseDir,
+      index,
+      this.videoIndexCacheTtlMs,
+      this.maxIndexEntries
+    )
+    return index
+  }
+
+  private getVideoInfoFromIndex(index: Map<string, VideoIndexEntry>, md5: string, includePoster = true): VideoInfo | null {
+    const normalizedMd5 = String(md5 || '').trim().toLowerCase()
+    if (!normalizedMd5) return null
+
+    const candidates = [normalizedMd5]
+    const baseMd5 = normalizedMd5.replace(/_raw$/, '')
+    if (baseMd5 !== normalizedMd5) {
+      candidates.push(baseMd5)
+    } else {
+      candidates.push(`${normalizedMd5}_raw`)
+    }
+
+    for (const key of candidates) {
+      const entry = index.get(key)
+      if (!entry?.videoPath) continue
+      if (!existsSync(entry.videoPath)) continue
+      if (!includePoster) {
+        return {
+          videoUrl: entry.videoPath,
+          exists: true
+        }
+      }
+      return {
+        videoUrl: entry.videoPath,
+        coverUrl: this.fileToDataUrl(entry.coverPath, 'image/jpeg'),
+        thumbUrl: this.fileToDataUrl(entry.thumbPath, 'image/jpeg'),
+        exists: true
+      }
+    }
+
+    return null
+  }
+
+  private fallbackScanVideo(videoBaseDir: string, realVideoMd5: string, includePoster = true): VideoInfo | null {
+    try {
+      const yearMonthDirs = readdirSync(videoBaseDir)
+        .filter((dir) => {
+          const dirPath = join(videoBaseDir, dir)
+          try {
+            return statSync(dirPath).isDirectory()
+          } catch {
+            return false
+          }
+        })
+        .sort((a, b) => b.localeCompare(a))
+
+      for (const yearMonth of yearMonthDirs) {
+        const dirPath = join(videoBaseDir, yearMonth)
+        const videoPath = join(dirPath, `${realVideoMd5}.mp4`)
+        if (!existsSync(videoPath)) continue
+        if (!includePoster) {
+          return {
+            videoUrl: videoPath,
+            exists: true
+          }
+        }
+        const baseMd5 = realVideoMd5.replace(/_raw$/, '')
+        const coverPath = join(dirPath, `${baseMd5}.jpg`)
+        const thumbPath = join(dirPath, `${baseMd5}_thumb.jpg`)
+        return {
+          videoUrl: videoPath,
+          coverUrl: this.fileToDataUrl(coverPath, 'image/jpeg'),
+          thumbUrl: this.fileToDataUrl(thumbPath, 'image/jpeg'),
+          exists: true
+        }
+      }
+    } catch (e) {
+      this.log('fallback 扫描视频目录失败', { error: String(e) })
+    }
+    return null
+  }
+
+  /**
+   * 根据视频MD5获取视频文件信息
+   * 视频存放在: {数据库根目录}/{用户wxid}/msg/video/{年月}/
+   * 文件命名: {md5}.mp4, {md5}.jpg, {md5}_thumb.jpg
+   */
+  async getVideoInfo(videoMd5: string, options?: { includePoster?: boolean }): Promise<VideoInfo> {
+    const normalizedMd5 = String(videoMd5 || '').trim().toLowerCase()
+    const includePoster = options?.includePoster !== false
+    const dbPath = this.getDbPath()
+    const wxid = this.getMyWxid()
+
+    this.log('getVideoInfo 开始', { videoMd5: normalizedMd5, dbPath, wxid })
+
+    if (!dbPath || !wxid || !normalizedMd5) {
+      this.log('getVideoInfo: 参数缺失', { hasDbPath: !!dbPath, hasWxid: !!wxid, hasVideoMd5: !!normalizedMd5 })
+      return { exists: false }
+    }
+
+    const scopeKey = this.getScopeKey(dbPath, wxid)
+    const cacheKey = `${scopeKey}|${normalizedMd5}|poster=${includePoster ? 1 : 0}`
+
+    const cachedInfo = this.readTimedCache(this.videoInfoCache, cacheKey)
+    if (cachedInfo) return cachedInfo
+
+    const pending = this.pendingVideoInfo.get(cacheKey)
+    if (pending) return pending
+
+    const task = (async (): Promise<VideoInfo> => {
+      const realVideoMd5 = await this.queryVideoFileName(normalizedMd5) || normalizedMd5
+      const videoBaseDir = this.resolveVideoBaseDir(dbPath, wxid)
+
+      if (!existsSync(videoBaseDir)) {
+        const miss = { exists: false }
+        this.writeTimedCache(this.videoInfoCache, cacheKey, miss, this.videoInfoCacheTtlMs, this.maxCacheEntries)
+        return miss
+      }
+
+      const index = this.getOrBuildVideoIndex(videoBaseDir)
+      const indexed = this.getVideoInfoFromIndex(index, realVideoMd5, includePoster)
+      if (indexed) {
+        this.writeTimedCache(this.videoInfoCache, cacheKey, indexed, this.videoInfoCacheTtlMs, this.maxCacheEntries)
+        return indexed
+      }
+
+      const fallback = this.fallbackScanVideo(videoBaseDir, realVideoMd5, includePoster)
+      if (fallback) {
+        this.writeTimedCache(this.videoInfoCache, cacheKey, fallback, this.videoInfoCacheTtlMs, this.maxCacheEntries)
+        return fallback
+      }
+
+      const miss = { exists: false }
+      this.writeTimedCache(this.videoInfoCache, cacheKey, miss, this.videoInfoCacheTtlMs, this.maxCacheEntries)
+      this.log('getVideoInfo: 未找到视频', { inputMd5: normalizedMd5, resolvedMd5: realVideoMd5 })
+      return miss
+    })()
+
+    this.pendingVideoInfo.set(cacheKey, task)
+    try {
+      return await task
+    } finally {
+      this.pendingVideoInfo.delete(cacheKey)
+    }
+  }
+
+  /**
+   * 根据消息内容解析视频MD5
+   */
+  parseVideoMd5(content: string): string | undefined {
+    if (!content) return undefined
+
+    // 打印原始 XML 前 800 字符，帮助排查自己发的视频结构
+    this.log('parseVideoMd5 原始内容', { preview: content.slice(0, 800) })
+
+    try {
+      // 收集所有 md5 相关属性，方便对比
+      const allMd5Attrs: string[] = []
+      const md5Regex = /(?:md5|rawmd5|newmd5|originsourcemd5)\s*=\s*['"]([a-fA-F0-9]*)['"]/gi
+      let match
+      while ((match = md5Regex.exec(content)) !== null) {
+        allMd5Attrs.push(match[0])
+      }
+      this.log('parseVideoMd5 所有 md5 属性', { attrs: allMd5Attrs })
+
+      // 方法1：从 <videomsg md5="..."> 提取（收到的视频）
+      const videoMsgMd5Match = /<videomsg[^>]*\smd5\s*=\s*['"]([a-fA-F0-9]+)['"]/i.exec(content)
+      if (videoMsgMd5Match) {
+        this.log('parseVideoMd5 命中 videomsg md5 属性', { md5: videoMsgMd5Match[1] })
+        return videoMsgMd5Match[1].toLowerCase()
+      }
+
+      // 方法2：从 <videomsg rawmd5="..."> 提取（自己发的视频，没有 md5 只有 rawmd5）
+      const rawMd5Match = /<videomsg[^>]*\srawmd5\s*=\s*['"]([a-fA-F0-9]+)['"]/i.exec(content)
+      if (rawMd5Match) {
+        this.log('parseVideoMd5 命中 videomsg rawmd5 属性（自发视频）', { rawmd5: rawMd5Match[1] })
+        return rawMd5Match[1].toLowerCase()
+      }
+
+      // 方法3：任意属性 md5="..."（非 rawmd5/cdnthumbaeskey 等）
+      const attrMatch = /(?<![a-z])md5\s*=\s*['"]([a-fA-F0-9]+)['"]/i.exec(content)
+      if (attrMatch) {
+        this.log('parseVideoMd5 命中通用 md5 属性', { md5: attrMatch[1] })
+        return attrMatch[1].toLowerCase()
+      }
+
+      // 方法4：<md5>...</md5> 标签
+      const md5TagMatch = /<md5>([a-fA-F0-9]+)<\/md5>/i.exec(content)
+      if (md5TagMatch) {
+        this.log('parseVideoMd5 命中 md5 标签', { md5: md5TagMatch[1] })
+        return md5TagMatch[1].toLowerCase()
+      }
+
+      // 方法5：兜底取 rawmd5 属性（任意位置）
+      const rawMd5Fallback = /\srawmd5\s*=\s*['"]([a-fA-F0-9]+)['"]/i.exec(content)
+      if (rawMd5Fallback) {
+        this.log('parseVideoMd5 兜底命中 rawmd5', { rawmd5: rawMd5Fallback[1] })
+        return rawMd5Fallback[1].toLowerCase()
+      }
+
+      this.log('parseVideoMd5 未提取到任何 md5', { contentLength: content.length })
+    } catch (e) {
+      this.log('parseVideoMd5 异常', { error: String(e) })
+    }
+
+    return undefined
+  }
 }
 
 export const videoService = new VideoService()

electron/services/voiceTranscribeService.ts

@@ -75,6 +75,14 @@ export class VoiceTranscribeService {
       if (candidates.length === 0) {
         console.warn(`[VoiceTranscribe] 未找到 ${platformPkg} 目录，可能导致语音引擎加载失败`)
       }
+    } else if (process.platform === 'win32') {
+      // Windows: 把 sherpa-onnx DLL 所在目录加到 PATH，否则 native module 找不到依赖
+      const existing = env['PATH'] || ''
+      const merged = [...candidates, ...existing.split(';').filter(Boolean)]
+      env['PATH'] = Array.from(new Set(merged)).join(';')
+      if (candidates.length === 0) {
+        console.warn(`[VoiceTranscribe] 未找到 ${platformPkg} 目录，可能导致语音引擎加载失败`)
+      }
     }
 
     return env
@@ -273,8 +281,20 @@ export class VoiceTranscribeService {
         })
 
         worker.on('error', (err: Error) => resolve({ success: false, error: String(err) }))
-        worker.on('exit', (code: number) => {
-          if (code !== 0) resolve({ success: false, error: `Worker exited with code ${code}` })
+        worker.on('exit', (code: number | null, signal: string | null) => {
+          if (code === null || signal === 'SIGSEGV') {
+
+            console.error(`[VoiceTranscribe] Worker 异常崩溃，信号: ${signal}。可能是由于底层 C++ 运行库在当前系统上发生段错误。`);
+            resolve({
+              success: false,
+              error: 'SEGFAULT_ERROR'
+            });
+            return;
+          }
+
+          if (code !== 0) {
+            resolve({ success: false, error: `Worker exited with code ${code}` });
+          }
         })
 
       } catch (error) {

electron/services/wcdbService.ts

@@ -164,6 +164,10 @@ export class WcdbService {
     return this.callWorker('open', { dbPath, hexKey, wxid })
   }
 
+  async getLastInitError(): Promise<string | null> {
+    return this.callWorker('getLastInitError')
+  }
+
   /**
    * 关闭数据库连接
    */
@@ -174,10 +178,10 @@ export class WcdbService {
   /**
    * 关闭服务
    */
-  shutdown(): void {
-    this.close()
+  async shutdown(): Promise<void> {
+    try { await this.close() } catch {}
     if (this.worker) {
-      this.worker.terminate()
+      try { await this.worker.terminate() } catch {}
       this.worker = null
     }
   }
@@ -222,6 +226,48 @@ export class WcdbService {
     return this.callWorker('getMessageCounts', { sessionIds })
   }
 
+  async getSessionMessageCounts(sessionIds: string[]): Promise<{ success: boolean; counts?: Record<string, number>; error?: string }> {
+    return this.callWorker('getSessionMessageCounts', { sessionIds })
+  }
+
+  async getSessionMessageTypeStats(
+    sessionId: string,
+    beginTimestamp: number = 0,
+    endTimestamp: number = 0
+  ): Promise<{ success: boolean; data?: any; error?: string }> {
+    return this.callWorker('getSessionMessageTypeStats', { sessionId, beginTimestamp, endTimestamp })
+  }
+
+  async getSessionMessageTypeStatsBatch(
+    sessionIds: string[],
+    options?: {
+      beginTimestamp?: number
+      endTimestamp?: number
+      quickMode?: boolean
+      includeGroupSenderCount?: boolean
+    }
+  ): Promise<{ success: boolean; data?: Record<string, any>; error?: string }> {
+    return this.callWorker('getSessionMessageTypeStatsBatch', { sessionIds, options })
+  }
+
+  async getSessionMessageDateCounts(sessionId: string): Promise<{ success: boolean; counts?: Record<string, number>; error?: string }> {
+    return this.callWorker('getSessionMessageDateCounts', { sessionId })
+  }
+
+  async getSessionMessageDateCountsBatch(sessionIds: string[]): Promise<{ success: boolean; data?: Record<string, Record<string, number>>; error?: string }> {
+    return this.callWorker('getSessionMessageDateCountsBatch', { sessionIds })
+  }
+
+  async getMessagesByType(
+    sessionId: string,
+    localType: number,
+    ascending = false,
+    limit = 0,
+    offset = 0
+  ): Promise<{ success: boolean; rows?: any[]; error?: string }> {
+    return this.callWorker('getMessagesByType', { sessionId, localType, ascending, limit, offset })
+  }
+
   /**
    * 获取联系人昵称
    */
@@ -287,6 +333,14 @@ export class WcdbService {
     return this.callWorker('getMessageMeta', { dbPath, tableName, limit, offset })
   }
 
+  async getMessageTableColumns(dbPath: string, tableName: string): Promise<{ success: boolean; columns?: string[]; error?: string }> {
+    return this.callWorker('getMessageTableColumns', { dbPath, tableName })
+  }
+
+  async getMessageTableTimeRange(dbPath: string, tableName: string): Promise<{ success: boolean; data?: any; error?: string }> {
+    return this.callWorker('getMessageTableTimeRange', { dbPath, tableName })
+  }
+
   /**
    * 获取联系人详情
    */
@@ -301,6 +355,26 @@ export class WcdbService {
     return this.callWorker('getContactStatus', { usernames })
   }
 
+  async getContactTypeCounts(): Promise<{ success: boolean; counts?: { private: number; group: number; official: number; former_friend: number }; error?: string }> {
+    return this.callWorker('getContactTypeCounts')
+  }
+
+  async getContactsCompact(usernames: string[] = []): Promise<{ success: boolean; contacts?: any[]; error?: string }> {
+    return this.callWorker('getContactsCompact', { usernames })
+  }
+
+  async getContactAliasMap(usernames: string[]): Promise<{ success: boolean; map?: Record<string, string>; error?: string }> {
+    return this.callWorker('getContactAliasMap', { usernames })
+  }
+
+  async getContactFriendFlags(usernames: string[]): Promise<{ success: boolean; map?: Record<string, boolean>; error?: string }> {
+    return this.callWorker('getContactFriendFlags', { usernames })
+  }
+
+  async getChatRoomExtBuffer(chatroomId: string): Promise<{ success: boolean; extBuffer?: string; error?: string }> {
+    return this.callWorker('getChatRoomExtBuffer', { chatroomId })
+  }
+
   /**
    * 获取聚合统计数据
    */
@@ -372,7 +446,7 @@ export class WcdbService {
   }
 
   /**
-   * 执行 SQL 查询（支持参数化查询）
+   * 执行 SQL 查询（仅主进程内部使用：fallback/diagnostic/低频兼容）
    */
   async execQuery(kind: string, path: string | null, sql: string, params: any[] = []): Promise<{ success: boolean; rows?: any[]; error?: string }> {
     return this.callWorker('execQuery', { kind, path, sql, params })
@@ -385,6 +459,20 @@ export class WcdbService {
     return this.callWorker('getEmoticonCdnUrl', { dbPath, md5 })
   }
 
+  /**
+   * 获取表情包释义
+   */
+  async getEmoticonCaption(dbPath: string, md5: string): Promise<{ success: boolean; caption?: string; error?: string }> {
+    return this.callWorker('getEmoticonCaption', { dbPath, md5 })
+  }
+
+  /**
+   * 获取表情包释义（严格 DLL 接口）
+   */
+  async getEmoticonCaptionStrict(md5: string): Promise<{ success: boolean; caption?: string; error?: string }> {
+    return this.callWorker('getEmoticonCaptionStrict', { md5 })
+  }
+
   /**
    * 列出消息数据库
    */
@@ -406,6 +494,10 @@ export class WcdbService {
     return this.callWorker('getMessageById', { sessionId, localId })
   }
 
+  async searchMessages(keyword: string, sessionId?: string, limit?: number, offset?: number, beginTimestamp?: number, endTimestamp?: number): Promise<{ success: boolean; messages?: any[]; error?: string }> {
+    return this.callWorker('searchMessages', { keyword, sessionId, limit, offset, beginTimestamp, endTimestamp })
+  }
+
   /**
    * 获取语音数据
    */
@@ -413,6 +505,40 @@ export class WcdbService {
     return this.callWorker('getVoiceData', { sessionId, createTime, candidates, localId, svrId })
   }
 
+  async getVoiceDataBatch(
+    requests: Array<{ session_id: string; create_time: number; local_id?: number; svr_id?: string | number; candidates?: string[] }>
+  ): Promise<{ success: boolean; rows?: Array<{ index: number; hex?: string }>; error?: string }> {
+    return this.callWorker('getVoiceDataBatch', { requests })
+  }
+
+  async getMediaSchemaSummary(dbPath: string): Promise<{ success: boolean; data?: any; error?: string }> {
+    return this.callWorker('getMediaSchemaSummary', { dbPath })
+  }
+
+  async getHeadImageBuffers(usernames: string[]): Promise<{ success: boolean; map?: Record<string, string>; error?: string }> {
+    return this.callWorker('getHeadImageBuffers', { usernames })
+  }
+
+  async resolveImageHardlink(md5: string, accountDir?: string): Promise<{ success: boolean; data?: any; error?: string }> {
+    return this.callWorker('resolveImageHardlink', { md5, accountDir })
+  }
+
+  async resolveImageHardlinkBatch(
+    requests: Array<{ md5: string; accountDir?: string }>
+  ): Promise<{ success: boolean; rows?: Array<{ index: number; md5: string; success: boolean; data?: any; error?: string }>; error?: string }> {
+    return this.callWorker('resolveImageHardlinkBatch', { requests })
+  }
+
+  async resolveVideoHardlinkMd5(md5: string, dbPath?: string): Promise<{ success: boolean; data?: any; error?: string }> {
+    return this.callWorker('resolveVideoHardlinkMd5', { md5, dbPath })
+  }
+
+  async resolveVideoHardlinkMd5Batch(
+    requests: Array<{ md5: string; dbPath?: string }>
+  ): Promise<{ success: boolean; rows?: Array<{ index: number; md5: string; success: boolean; data?: any; error?: string }>; error?: string }> {
+    return this.callWorker('resolveVideoHardlinkMd5Batch', { requests })
+  }
+
   /**
    * 获取朋友圈
    */
@@ -427,6 +553,14 @@ export class WcdbService {
     return this.callWorker('getSnsAnnualStats', { beginTimestamp, endTimestamp })
   }
 
+  async getSnsUsernames(): Promise<{ success: boolean; usernames?: string[]; error?: string }> {
+    return this.callWorker('getSnsUsernames')
+  }
+
+  async getSnsExportStats(myWxid?: string): Promise<{ success: boolean; data?: { totalPosts: number; totalFriends: number; myPosts: number | null }; error?: string }> {
+    return this.callWorker('getSnsExportStats', { myWxid })
+  }
+
   /**
    * 安装朋友圈删除拦截
    */

electron/wcdbWorker.ts

@@ -37,6 +37,9 @@ if (parentPort) {
                 case 'open':
                     result = await core.open(payload.dbPath, payload.hexKey, payload.wxid)
                     break
+                case 'getLastInitError':
+                    result = core.getLastInitError()
+                    break
                 case 'close':
                     core.close()
                     result = { success: true }
@@ -59,6 +62,24 @@ if (parentPort) {
                 case 'getMessageCounts':
                     result = await core.getMessageCounts(payload.sessionIds)
                     break
+                case 'getSessionMessageCounts':
+                    result = await core.getSessionMessageCounts(payload.sessionIds)
+                    break
+                case 'getSessionMessageTypeStats':
+                    result = await core.getSessionMessageTypeStats(payload.sessionId, payload.beginTimestamp, payload.endTimestamp)
+                    break
+                case 'getSessionMessageTypeStatsBatch':
+                    result = await core.getSessionMessageTypeStatsBatch(payload.sessionIds, payload.options)
+                    break
+                case 'getSessionMessageDateCounts':
+                    result = await core.getSessionMessageDateCounts(payload.sessionId)
+                    break
+                case 'getSessionMessageDateCountsBatch':
+                    result = await core.getSessionMessageDateCountsBatch(payload.sessionIds)
+                    break
+                case 'getMessagesByType':
+                    result = await core.getMessagesByType(payload.sessionId, payload.localType, payload.ascending, payload.limit, payload.offset)
+                    break
                 case 'getDisplayNames':
                     result = await core.getDisplayNames(payload.usernames)
                     break
@@ -89,12 +110,33 @@ if (parentPort) {
                 case 'getMessageMeta':
                     result = await core.getMessageMeta(payload.dbPath, payload.tableName, payload.limit, payload.offset)
                     break
+                case 'getMessageTableColumns':
+                    result = await core.getMessageTableColumns(payload.dbPath, payload.tableName)
+                    break
+                case 'getMessageTableTimeRange':
+                    result = await core.getMessageTableTimeRange(payload.dbPath, payload.tableName)
+                    break
                 case 'getContact':
                     result = await core.getContact(payload.username)
                     break
                 case 'getContactStatus':
                     result = await core.getContactStatus(payload.usernames)
                     break
+                case 'getContactTypeCounts':
+                    result = await core.getContactTypeCounts()
+                    break
+                case 'getContactsCompact':
+                    result = await core.getContactsCompact(payload.usernames)
+                    break
+                case 'getContactAliasMap':
+                    result = await core.getContactAliasMap(payload.usernames)
+                    break
+                case 'getContactFriendFlags':
+                    result = await core.getContactFriendFlags(payload.usernames)
+                    break
+                case 'getChatRoomExtBuffer':
+                    result = await core.getChatRoomExtBuffer(payload.chatroomId)
+                    break
                 case 'getAggregateStats':
                     result = await core.getAggregateStats(payload.sessionIds, payload.beginTimestamp, payload.endTimestamp)
                     break
@@ -131,6 +173,12 @@ if (parentPort) {
                 case 'getEmoticonCdnUrl':
                     result = await core.getEmoticonCdnUrl(payload.dbPath, payload.md5)
                     break
+                case 'getEmoticonCaption':
+                    result = await core.getEmoticonCaption(payload.dbPath, payload.md5)
+                    break
+                case 'getEmoticonCaptionStrict':
+                    result = await core.getEmoticonCaptionStrict(payload.md5)
+                    break
                 case 'listMessageDbs':
                     result = await core.listMessageDbs()
                     break
@@ -140,18 +188,48 @@ if (parentPort) {
                 case 'getMessageById':
                     result = await core.getMessageById(payload.sessionId, payload.localId)
                     break
+                case 'searchMessages':
+                    result = await core.searchMessages(payload.keyword, payload.sessionId, payload.limit, payload.offset, payload.beginTimestamp, payload.endTimestamp)
+                    break
                 case 'getVoiceData':
                     result = await core.getVoiceData(payload.sessionId, payload.createTime, payload.candidates, payload.localId, payload.svrId)
                     if (!result.success) {
                         console.error('[wcdbWorker] getVoiceData failed:', result.error)
                     }
                     break
+                case 'getVoiceDataBatch':
+                    result = await core.getVoiceDataBatch(payload.requests)
+                    break
+                case 'getMediaSchemaSummary':
+                    result = await core.getMediaSchemaSummary(payload.dbPath)
+                    break
+                case 'getHeadImageBuffers':
+                    result = await core.getHeadImageBuffers(payload.usernames)
+                    break
+                case 'resolveImageHardlink':
+                    result = await core.resolveImageHardlink(payload.md5, payload.accountDir)
+                    break
+                case 'resolveImageHardlinkBatch':
+                    result = await core.resolveImageHardlinkBatch(payload.requests)
+                    break
+                case 'resolveVideoHardlinkMd5':
+                    result = await core.resolveVideoHardlinkMd5(payload.md5, payload.dbPath)
+                    break
+                case 'resolveVideoHardlinkMd5Batch':
+                    result = await core.resolveVideoHardlinkMd5Batch(payload.requests)
+                    break
                 case 'getSnsTimeline':
                     result = await core.getSnsTimeline(payload.limit, payload.offset, payload.usernames, payload.keyword, payload.startTime, payload.endTime)
                     break
                 case 'getSnsAnnualStats':
                     result = await core.getSnsAnnualStats(payload.beginTimestamp, payload.endTimestamp)
                     break
+                case 'getSnsUsernames':
+                    result = await core.getSnsUsernames()
+                    break
+                case 'getSnsExportStats':
+                    result = await core.getSnsExportStats(payload.myWxid)
+                    break
                 case 'installSnsBlockDeleteTrigger':
                     result = await core.installSnsBlockDeleteTrigger()
                     break

electron/windows/notificationWindow.ts

@@ -132,7 +132,7 @@ async function showAndSend(win: BrowserWindow, data: any) {
 
     // 更新位置
     const { width: screenWidth, height: screenHeight } = screen.getPrimaryDisplay().workAreaSize
-    const winWidth = 344
+    const winWidth = position === 'top-center' ? 280 : 344
     const winHeight = 114
     const padding = 20
 
@@ -140,6 +140,10 @@ async function showAndSend(win: BrowserWindow, data: any) {
     let y = 0
 
     switch (position) {
+        case 'top-center':
+            x = (screenWidth - winWidth) / 2
+            y = padding
+            break
         case 'top-right':
             x = screenWidth - winWidth - padding
             y = padding
@@ -166,7 +170,7 @@ async function showAndSend(win: BrowserWindow, data: any) {
     win.showInactive() // 显示但不聚焦
     win.setAlwaysOnTop(true, 'screen-saver') // 最高层级
 
-    win.webContents.send('notification:show', data)
+    win.webContents.send('notification:show', { ...data, position })
 
     // 自动关闭计时器通常由渲染进程管理
     // 渲染进程发送 'notification:close' 来隐藏窗口

package.json

@@ -1,9 +1,12 @@
 {
   "name": "weflow",
-  "version": "2.1.0",
+  "version": "4.3.0",
   "description": "WeFlow",
   "main": "dist-electron/main.js",
-  "author": "cc",
+  "author": {
+    "name": "cc",
+    "email": "yccccccy@proton.me"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/hicccc77/WeFlow"
@@ -20,9 +23,9 @@
     "electron:build": "npm run build"
   },
   "dependencies": {
-    "echarts": "^5.5.1",
+    "echarts": "^6.0.0",
     "echarts-for-react": "^3.0.2",
-    "electron-store": "^10.0.0",
+    "electron-store": "^11.0.2",
     "electron-updater": "^6.3.9",
     "exceljs": "^4.4.0",
     "ffmpeg-static": "^5.3.0",
@@ -30,16 +33,17 @@
     "html2canvas": "^1.4.1",
     "jieba-wasm": "^2.2.0",
     "jszip": "^3.10.1",
-    "koffi": "^2.9.0",
-    "lucide-react": "^0.562.0",
+    "koffi": "^2.15.4",
+    "lucide-react": "^1.7.0",
     "react": "^19.2.3",
     "react-dom": "^19.2.3",
     "react-markdown": "^10.1.0",
-    "react-router-dom": "^7.1.1",
+    "react-router-dom": "^7.14.0",
     "react-virtuoso": "^4.18.1",
     "remark-gfm": "^4.0.1",
     "sherpa-onnx-node": "^1.10.38",
     "silk-wasm": "^3.7.1",
+    "sudo-prompt": "^9.2.1",
     "wechat-emojis": "^1.0.2",
     "zustand": "^5.0.2"
   },
@@ -48,15 +52,27 @@
     "@types/react": "^19.1.0",
     "@types/react-dom": "^19.1.0",
     "@vitejs/plugin-react": "^4.3.4",
-    "electron": "^39.2.7",
-    "electron-builder": "^25.1.8",
-    "sass": "^1.83.0",
+    "electron": "^41.1.1",
+    "electron-builder": "^26.8.1",
+    "sass": "^1.98.0",
     "sharp": "^0.34.5",
-    "typescript": "^5.6.3",
-    "vite": "^6.0.5",
+    "typescript": "^6.0.2",
+    "vite": "^7.0.0",
     "vite-plugin-electron": "^0.28.8",
     "vite-plugin-electron-renderer": "^0.14.6"
   },
+  "pnpm": {
+    "overrides": {
+      "tar": ">=6.2.1",
+      "minimatch": ">=3.1.2",
+      "rollup": ">=4.0.0",
+      "immutable": ">=4.0.0",
+      "lodash": ">=4.17.21",
+      "brace-expansion": ">=1.1.11",
+      "picomatch": ">=2.3.1",
+      "ajv": ">=8.18.0"
+    }
+  },
   "build": {
     "appId": "com.WeFlow.app",
     "publish": {
@@ -86,7 +102,41 @@
       "target": [
         "nsis"
       ],
-      "icon": "public/icon.ico"
+      "icon": "public/icon.ico",
+      "extraFiles": [
+        {
+          "from": "resources/msvcp140.dll",
+          "to": "."
+        },
+        {
+          "from": "resources/msvcp140_1.dll",
+          "to": "."
+        },
+        {
+          "from": "resources/vcruntime140.dll",
+          "to": "."
+        },
+        {
+          "from": "resources/vcruntime140_1.dll",
+          "to": "."
+        }
+      ]
+    },
+    "linux": {
+      "icon": "public/icon.png",
+      "target": [
+        "appimage",
+        "tar.gz"
+      ],
+      "category": "Utility",
+      "executableName": "weflow",
+      "synopsis": "WeFlow for Linux",
+      "extraFiles": [
+        {
+          "from": "resources/linux/install.sh",
+          "to": "install.sh"
+        }
+      ]
     },
     "nsis": {
       "oneClick": false,
@@ -118,6 +168,10 @@
         "from": "public/icon.ico",
         "to": "icon.ico"
       },
+      {
+        "from": "public/icon.png",
+        "to": "icon.png"
+      },
       {
         "from": "electron/assets/wasm/",
         "to": "assets/wasm/"
@@ -134,24 +188,11 @@
       "node_modules/sherpa-onnx-*/**/*",
       "node_modules/ffmpeg-static/**/*"
     ],
-    "extraFiles": [
-      {
-        "from": "resources/msvcp140.dll",
-        "to": "."
-      },
-      {
-        "from": "resources/msvcp140_1.dll",
-        "to": "."
-      },
-      {
-        "from": "resources/vcruntime140.dll",
-        "to": "."
-      },
-      {
-        "from": "resources/vcruntime140_1.dll",
-        "to": "."
-      }
-    ],
     "icon": "resources/icon.icns"
+  },
+  "overrides": {
+    "picomatch": "^4.0.4",
+    "tar": "^7.5.13",
+    "immutable": "^5.1.5"
   }
-}
+}

resources/linux/install.sh

@@ -0,0 +1,59 @@
+#!/bin/bash
+
+set -e
+
+APP_NAME="weflow"
+APP_EXEC="weflow"
+OPT_DIR="/opt/$APP_NAME"
+BIN_LINK="/usr/bin/$APP_NAME"
+DESKTOP_DIR="/usr/share/applications"
+ICON_DIR="/usr/share/pixmaps"
+
+if [ "$EUID" -ne 0 ]; then
+  echo "❌ 请使用 root 权限运行此脚本 (例如: sudo ./install.sh)"
+  exit 1
+fi
+
+echo "🚀 开始安装 $APP_NAME..."
+
+echo "📦 正在复制文件到 $OPT_DIR..."
+rm -rf "$OPT_DIR"
+mkdir -p "$OPT_DIR"
+cp -r ./* "$OPT_DIR/"
+chmod -R 755 "$OPT_DIR"
+chmod +x "$OPT_DIR/$APP_EXEC"
+
+echo "🔗 正在创建软链接 $BIN_LINK..."
+ln -sf "$OPT_DIR/$APP_EXEC" "$BIN_LINK"
+
+echo "📝 正在创建桌面快捷方式..."
+cat <<EOF >"$DESKTOP_DIR/${APP_NAME}.desktop"
+[Desktop Entry]
+Name=WeFlow
+Exec=$OPT_DIR/$APP_EXEC %U
+Terminal=false
+Type=Application
+Icon=$APP_NAME
+StartupWMClass=WeFlow
+Comment=A local WeChat database decryption and analysis tool
+Categories=Utility;
+EOF
+chmod 644 "$DESKTOP_DIR/${APP_NAME}.desktop"
+
+echo "🖼️ 正在安装图标..."
+if [ -f "$OPT_DIR/resources/icon.png" ]; then
+  cp "$OPT_DIR/resources/icon.png" "$ICON_DIR/${APP_NAME}.png"
+  chmod 644 "$ICON_DIR/${APP_NAME}.png"
+elif [ -f "$OPT_DIR/icon.png" ]; then
+  cp "$OPT_DIR/icon.png" "$ICON_DIR/${APP_NAME}.png"
+  chmod 644 "$ICON_DIR/${APP_NAME}.png"
+else
+  echo "⚠️ 警告: 未找到图标文件，跳过图标安装。"
+fi
+
+if command -v update-desktop-database >/dev/null 2>&1; then
+  echo "🔄 更新桌面数据库..."
+  update-desktop-database "$DESKTOP_DIR"
+fi
+
+echo "✅ 安装完成！你现在可以在应用菜单中找到 WeFlow，或者在终端输入 'weflow' 启动。"

src/App.tsx

@@ -20,6 +20,7 @@ import ExportPage from './pages/ExportPage'
 import VideoWindow from './pages/VideoWindow'
 import ImageWindow from './pages/ImageWindow'
 import SnsPage from './pages/SnsPage'
+import BizPage from './pages/BizPage'
 import ContactsPage from './pages/ContactsPage'
 import ChatHistoryPage from './pages/ChatHistoryPage'
 import NotificationWindow from './pages/NotificationWindow'
@@ -37,6 +38,7 @@ import LockScreen from './components/LockScreen'
 import { GlobalSessionMonitor } from './components/GlobalSessionMonitor'
 import { BatchTranscribeGlobal } from './components/BatchTranscribeGlobal'
 import { BatchImageDecryptGlobal } from './components/BatchImageDecryptGlobal'
+import WindowCloseDialog from './components/WindowCloseDialog'
 
 function RouteStateRedirect({ to }: { to: string }) {
   const location = useLocation()
@@ -74,7 +76,7 @@ function App() {
   const isAgreementWindow = location.pathname === '/agreement-window'
   const isOnboardingWindow = location.pathname === '/onboarding-window'
   const isVideoPlayerWindow = location.pathname === '/video-player-window'
-  const isChatHistoryWindow = location.pathname.startsWith('/chat-history/')
+  const isChatHistoryWindow = location.pathname.startsWith('/chat-history/') || location.pathname.startsWith('/chat-history-inline/')
   const isStandaloneChatWindow = location.pathname === '/chat-window'
   const isNotificationWindow = location.pathname === '/notification-window'
   const isSettingsRoute = location.pathname === '/settings'
@@ -85,6 +87,8 @@ function App() {
   const isExportRoute = routeLocation.pathname === '/export'
   const [themeHydrated, setThemeHydrated] = useState(false)
   const [sidebarCollapsed, setSidebarCollapsed] = useState(false)
+  const [showCloseDialog, setShowCloseDialog] = useState(false)
+  const [canMinimizeToTray, setCanMinimizeToTray] = useState(false)
 
   // 锁定状态
   // const [isLocked, setIsLocked] = useState(false) // Moved to store
@@ -100,6 +104,45 @@ function App() {
 
   // 数据收集同意状态
   const [showAnalyticsConsent, setShowAnalyticsConsent] = useState(false)
+  const [analyticsConsent, setAnalyticsConsent] = useState<boolean | null>(null)
+
+  const [showWaylandWarning, setShowWaylandWarning] = useState(false)
+
+  useEffect(() => {
+    const checkWaylandStatus = async () => {
+      try {
+        // 防止在非客户端环境报错，先检查 API 是否存在
+        if (!window.electronAPI?.app?.checkWayland) return
+
+        // 通过 configService 检查是否已经弹过窗
+        const hasWarned = await window.electronAPI.config.get('waylandWarningShown')
+
+        if (!hasWarned) {
+          const isWayland = await window.electronAPI.app.checkWayland()
+          if (isWayland) {
+            setShowWaylandWarning(true)
+          }
+        }
+      } catch (e) {
+        console.error('检查 Wayland 状态失败:', e)
+      }
+    }
+
+    // 只有在协议同意之后并且已经进入主应用流程才检查
+    if (!isAgreementWindow && !isOnboardingWindow && !agreementLoading) {
+      checkWaylandStatus()
+    }
+  }, [isAgreementWindow, isOnboardingWindow, agreementLoading])
+
+  const handleDismissWaylandWarning = async () => {
+    try {
+      // 记录到本地配置中，下次不再提示
+      await window.electronAPI.config.set('waylandWarningShown', true)
+    } catch (e) {
+      console.error('保存 Wayland 提示状态失败:', e)
+    }
+    setShowWaylandWarning(false)
+  }
 
   useEffect(() => {
     if (location.pathname !== '/settings') {
@@ -107,6 +150,15 @@ function App() {
     }
   }, [location])
 
+  useEffect(() => {
+    const removeCloseConfirmListener = window.electronAPI.window.onCloseConfirmRequested((payload) => {
+      setCanMinimizeToTray(Boolean(payload.canMinimizeToTray))
+      setShowCloseDialog(true)
+    })
+
+    return () => removeCloseConfirmListener()
+  }, [])
+
   useEffect(() => {
     const root = document.documentElement
     const body = document.body
@@ -202,6 +254,7 @@ function App() {
           // 协议已同意，检查数据收集同意状态
           const consent = await configService.getAnalyticsConsent()
           const denyCount = await configService.getAnalyticsDenyCount()
+          setAnalyticsConsent(consent)
           // 如果未设置同意状态且拒绝次数小于2次，显示弹窗
           if (consent === null && denyCount < 2) {
             setShowAnalyticsConsent(true)
@@ -216,18 +269,21 @@ function App() {
     checkAgreement()
   }, [])
 
-  // 初始化数据收集
+  // 初始化数据收集（仅在用户同意后）
   useEffect(() => {
-    cloudControl.initCloudControl()
-  }, [])
+    if (analyticsConsent === true) {
+      cloudControl.initCloudControl()
+    }
+  }, [analyticsConsent])
 
-  // 记录页面访问
+  // 记录页面访问（仅在用户同意后）
   useEffect(() => {
+    if (analyticsConsent !== true) return
     const path = location.pathname
     if (path && path !== '/') {
       cloudControl.recordPage(path)
     }
-  }, [location.pathname])
+  }, [location.pathname, analyticsConsent])
 
   const handleAgree = async () => {
     if (!agreementChecked) return
@@ -246,6 +302,7 @@ function App() {
 
   const handleAnalyticsAllow = async () => {
     await configService.setAnalyticsConsent(true)
+    setAnalyticsConsent(true)
     setShowAnalyticsConsent(false)
   }
 
@@ -262,10 +319,14 @@ function App() {
     const removeUpdateListener = window.electronAPI?.app?.onUpdateAvailable?.((info: any) => {
       // 发现新版本时保存更新信息，锁定状态下不弹窗，解锁后再显示
       if (info) {
-        setUpdateInfo({ ...info, hasUpdate: true })
-        if (!useAppStore.getState().isLocked) {
-          setShowUpdateDialog(true)
-        }
+        window.electronAPI.app.getVersion().then((currentVersion: string) => {
+          const isMandatory = !!(info.minimumVersion && currentVersion &&
+            currentVersion.localeCompare(info.minimumVersion, undefined, { numeric: true, sensitivity: 'base' }) <= 0)
+          setUpdateInfo({ ...info, hasUpdate: true, isMandatory })
+          if (!useAppStore.getState().isLocked) {
+            setShowUpdateDialog(true)
+          }
+        })
       }
     })
     const removeProgressListener = window.electronAPI?.app?.onDownloadProgress?.((progress: any) => {
@@ -315,6 +376,26 @@ function App() {
     setUpdateInfo(null)
   }
 
+  const handleWindowCloseAction = async (
+    action: 'tray' | 'quit' | 'cancel',
+    rememberChoice = false
+  ) => {
+    setShowCloseDialog(false)
+    if (rememberChoice && action !== 'cancel') {
+      try {
+        await configService.setWindowCloseBehavior(action)
+      } catch (error) {
+        console.error('保存关闭偏好失败:', error)
+      }
+    }
+
+    try {
+      await window.electronAPI.window.respondCloseConfirm(action)
+    } catch (error) {
+      console.error('处理关闭确认失败:', error)
+    }
+  }
+
   // 启动时自动检查配置并连接数据库
   useEffect(() => {
     if (isAgreementWindow || isOnboardingWindow) return
@@ -400,6 +481,8 @@ function App() {
     checkLock()
   }, [isAgreementWindow, isOnboardingWindow, isVideoPlayerWindow])
 
+
+
   // 独立协议窗口
   if (isAgreementWindow) {
     return <AgreementPage />
@@ -582,17 +665,52 @@ function App() {
         </div>
       )}
 
+      {showWaylandWarning && (
+          <div className="agreement-overlay">
+            <div className="agreement-modal">
+              <div className="agreement-header">
+                <Shield size={32} />
+                <h2>环境兼容性提示 (Wayland)</h2>
+              </div>
+              <div className="agreement-content">
+                <div className="agreement-text">
+                  <p>检测到您当前正在使用 <strong>Wayland</strong> 显示服务器。</p>
+                  <p>在 Wayland 环境下，出于系统级的安全与设计机制，<strong>应用程序无法直接控制新弹出窗口的位置</strong>。</p>
+                  <p>这可能导致某些独立窗口（如消息通知、图片查看器等）出现位置随机、或不受控制的情况。这是底层机制导致的，对此我们无能为力。</p>
+                  <br />
+                  <p>如果您觉得窗口位置异常严重影响了使用体验，建议尝试：</p>
+                  <p>1. 在系统登录界面，将会话切换回 <strong>X11 (Xorg)</strong> 模式。</p>
+                  <p>2. 修改您的桌面管理器 (WM/DE) 配置，强制指定该应用程序的窗口规则。</p>
+                </div>
+              </div>
+              <div className="agreement-footer">
+                <div className="agreement-actions">
+                  <button className="btn btn-primary" onClick={handleDismissWaylandWarning}>我知道了，不再提示</button>
+                </div>
+              </div>
+            </div>
+          </div>
+      )}
+
       {/* 更新提示对话框 */}
       <UpdateDialog
         open={showUpdateDialog}
         updateInfo={updateInfo}
-        onClose={() => setShowUpdateDialog(false)}
+        onClose={() => { if (!(updateInfo as any)?.isMandatory) setShowUpdateDialog(false) }}
         onUpdate={handleUpdateNow}
         onIgnore={handleIgnoreUpdate}
         isDownloading={isDownloading}
+        isMandatory={!!(updateInfo as any)?.isMandatory}
         progress={downloadProgress}
       />
 
+      <WindowCloseDialog
+        open={showCloseDialog}
+        canMinimizeToTray={canMinimizeToTray}
+        onSelect={(action, rememberChoice) => handleWindowCloseAction(action, rememberChoice)}
+        onCancel={() => handleWindowCloseAction('cancel')}
+      />
+
       <div className="main-layout">
         <Sidebar collapsed={sidebarCollapsed} />
         <main className="content">
@@ -619,8 +737,10 @@ function App() {
 
               <Route path="/export" element={<div className="export-route-anchor" aria-hidden="true" />} />
               <Route path="/sns" element={<SnsPage />} />
+              <Route path="/biz" element={<BizPage />} />
               <Route path="/contacts" element={<ContactsPage />} />
               <Route path="/chat-history/:sessionId/:messageId" element={<ChatHistoryPage />} />
+              <Route path="/chat-history-inline/:payloadId" element={<ChatHistoryPage />} />
             </Routes>
           </RouteGuard>
         </main>

src/components/Avatar.scss

@@ -50,6 +50,21 @@
         border-radius: inherit;
     }
 
+    .avatar-loading {
+        width: 100%;
+        height: 100%;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        color: var(--text-tertiary, #999);
+        background-color: var(--bg-tertiary, #e0e0e0);
+        border-radius: inherit;
+
+        .avatar-loading-icon {
+            animation: avatar-spin 0.9s linear infinite;
+        }
+    }
+
     /* Loading Skeleton */
     .avatar-skeleton {
         position: absolute;
@@ -76,4 +91,14 @@
             background-position: -200% 0;
         }
     }
-}
+
+    @keyframes avatar-spin {
+        0% {
+            transform: rotate(0deg);
+        }
+
+        100% {
+            transform: rotate(360deg);
+        }
+    }
+}

src/components/Avatar.tsx

@@ -1,5 +1,5 @@
 import React, { useState, useEffect, useRef, useMemo } from 'react'
-import { User } from 'lucide-react'
+import { Loader2, User } from 'lucide-react'
 import { avatarLoadQueue } from '../utils/AvatarLoadQueue'
 import './Avatar.scss'
 
@@ -13,6 +13,7 @@ interface AvatarProps {
     shape?: 'circle' | 'square' | 'rounded'
     className?: string
     lazy?: boolean
+    loading?: boolean
     onClick?: () => void
 }
 
@@ -23,12 +24,14 @@ export const Avatar = React.memo(function Avatar({
     shape = 'rounded',
     className = '',
     lazy = true,
+    loading = false,
     onClick
 }: AvatarProps) {
     // 如果 URL 已在缓存中，则直接标记为已加载，不显示骨架屏和淡入动画
     const isCached = useMemo(() => src ? loadedAvatarCache.has(src) : false, [src])
+    const isFailed = useMemo(() => src ? avatarLoadQueue.hasFailed(src) : false, [src])
     const [imageLoaded, setImageLoaded] = useState(isCached)
-    const [imageError, setImageError] = useState(false)
+    const [imageError, setImageError] = useState(isFailed)
     const [shouldLoad, setShouldLoad] = useState(!lazy || isCached)
     const [isInQueue, setIsInQueue] = useState(false)
     const imgRef = useRef<HTMLImageElement>(null)
@@ -42,7 +45,7 @@ export const Avatar = React.memo(function Avatar({
 
     // Intersection Observer for lazy loading
     useEffect(() => {
-        if (!lazy || shouldLoad || isInQueue || !src || !containerRef.current || isCached) return
+        if (!lazy || shouldLoad || isInQueue || !src || !containerRef.current || isCached || imageError || isFailed) return
 
         const observer = new IntersectionObserver(
             (entries) => {
@@ -50,10 +53,11 @@ export const Avatar = React.memo(function Avatar({
                     if (entry.isIntersecting && !isInQueue) {
                         setIsInQueue(true)
                         avatarLoadQueue.enqueue(src).then(() => {
+                            setImageError(false)
                             setShouldLoad(true)
                         }).catch(() => {
-                            // 加载失败不要立刻显示错误，让浏览器渲染去报错
-                            setShouldLoad(true)
+                            setImageError(true)
+                            setShouldLoad(false)
                         }).finally(() => {
                             setIsInQueue(false)
                         })
@@ -67,14 +71,18 @@ export const Avatar = React.memo(function Avatar({
         observer.observe(containerRef.current)
 
         return () => observer.disconnect()
-    }, [src, lazy, shouldLoad, isInQueue, isCached])
+    }, [src, lazy, shouldLoad, isInQueue, isCached, imageError, isFailed])
 
     // Reset state when src changes
     useEffect(() => {
         const cached = src ? loadedAvatarCache.has(src) : false
+        const failed = src ? avatarLoadQueue.hasFailed(src) : false
         setImageLoaded(cached)
-        setImageError(false)
-        if (lazy && !cached) {
+        setImageError(failed)
+        if (failed) {
+            setShouldLoad(false)
+            setIsInQueue(false)
+        } else if (lazy && !cached) {
             setShouldLoad(false)
             setIsInQueue(false)
         } else {
@@ -95,6 +103,7 @@ export const Avatar = React.memo(function Avatar({
     }
 
     const hasValidUrl = !!src && !imageError && shouldLoad
+    const shouldShowLoadingPlaceholder = loading && !hasValidUrl && !imageError
 
     return (
         <div
@@ -112,13 +121,30 @@ export const Avatar = React.memo(function Avatar({
                         alt={name || 'avatar'}
                         className={`avatar-image ${imageLoaded ? 'loaded' : ''} ${isCached ? 'instant' : ''}`}
                         onLoad={() => {
-                            if (src) loadedAvatarCache.add(src)
+                            if (src) {
+                                avatarLoadQueue.clearFailed(src)
+                                loadedAvatarCache.add(src)
+                            }
                             setImageLoaded(true)
+                            setImageError(false)
+                        }}
+                        onError={() => {
+                            if (src) {
+                                avatarLoadQueue.markFailed(src)
+                                loadedAvatarCache.delete(src)
+                            }
+                            setImageLoaded(false)
+                            setImageError(true)
+                            setShouldLoad(false)
                         }}
-                        onError={() => setImageError(true)}
                         loading={lazy ? "lazy" : "eager"}
+                        referrerPolicy="no-referrer"
                     />
                 </>
+            ) : shouldShowLoadingPlaceholder ? (
+                <div className="avatar-loading">
+                    <Loader2 size="50%" className="avatar-loading-icon" />
+                </div>
             ) : (
                 <div className="avatar-placeholder">
                     {name ? <span className="avatar-letter">{getAvatarLetter()}</span> : <User size="50%" />}

src/components/BatchTranscribeGlobal.tsx

@@ -1,6 +1,6 @@
 import React, { useEffect, useState } from 'react'
 import { createPortal } from 'react-dom'
-import { Loader2, X, CheckCircle, XCircle, AlertCircle, Clock } from 'lucide-react'
+import { Loader2, X, CheckCircle, XCircle, AlertCircle, Clock, Mic } from 'lucide-react'
 import { useBatchTranscribeStore } from '../stores/batchTranscribeStore'
 import '../styles/batchTranscribe.scss'
 
@@ -17,6 +17,7 @@ export const BatchTranscribeGlobal: React.FC = () => {
     result,
     sessionName,
     startTime,
+    taskType,
     setShowToast,
     setShowResult
   } = useBatchTranscribeStore()
@@ -64,7 +65,7 @@ export const BatchTranscribeGlobal: React.FC = () => {
           <div className="batch-progress-toast-header">
             <div className="batch-progress-toast-title">
               <Loader2 size={14} className="spin" />
-              <span>批量转写中{sessionName ? `（${sessionName}）` : ''}</span>
+              <span>{taskType === 'decrypt' ? '批量解密语音中' : '批量转写中'}{sessionName ? `（${sessionName}）` : ''}</span>
             </div>
             <button className="batch-progress-toast-close" onClick={() => setShowToast(false)} title="最小化">
               <X size={14} />
@@ -108,8 +109,8 @@ export const BatchTranscribeGlobal: React.FC = () => {
         <div className="batch-modal-overlay" onClick={() => setShowResult(false)}>
           <div className="batch-modal-content batch-result-modal" onClick={(e) => e.stopPropagation()}>
             <div className="batch-modal-header">
-              <CheckCircle size={20} />
-              <h3>转写完成</h3>
+              {taskType === 'decrypt' ? <Mic size={20} /> : <CheckCircle size={20} />}
+              <h3>{taskType === 'decrypt' ? '语音解密完成' : '转写完成'}</h3>
             </div>
             <div className="batch-modal-body">
               <div className="result-summary">
@@ -129,7 +130,7 @@ export const BatchTranscribeGlobal: React.FC = () => {
               {result.fail > 0 && (
                 <div className="result-tip">
                   <AlertCircle size={16} />
-                  <span>部分语音转写失败，可能是语音文件损坏或网络问题</span>
+                  <span>{taskType === 'decrypt' ? '部分语音解密失败，可能是语音未缓存或文件损坏' : '部分语音转写失败，可能是语音文件损坏或网络问题'}</span>
                 </div>
               )}
             </div>

src/components/ConfirmDialog.scss

@@ -0,0 +1,123 @@
+.confirm-dialog-overlay {
+  position: absolute;
+  top: 0;
+  left: 0;
+  right: 0;
+  bottom: 0;
+  background: rgba(0, 0, 0, 0.5);
+  backdrop-filter: blur(4px);
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  z-index: 100;
+  animation: fadeIn 0.2s ease-out;
+
+  .confirm-dialog {
+    width: 480px;
+    background: var(--bg-primary);
+    border-radius: 20px;
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.1);
+    position: relative;
+    animation: slideUp 0.2s ease-out;
+    overflow: hidden;
+
+    .close-btn {
+      position: absolute;
+      top: 16px;
+      right: 16px;
+      background: rgba(0, 0, 0, 0.05);
+      border: none;
+      color: var(--text-secondary);
+      cursor: pointer;
+      width: 32px;
+      height: 32px;
+      border-radius: 50%;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      transition: all 0.2s;
+
+      &:hover {
+        background: rgba(0, 0, 0, 0.1);
+        color: var(--text-primary);
+      }
+    }
+
+    .dialog-title {
+      padding: 40px 40px 16px;
+      font-size: 18px;
+      font-weight: 600;
+      color: var(--text-primary);
+    }
+
+    .dialog-content {
+      padding: 0 40px 24px;
+
+      p {
+        font-size: 15px;
+        color: var(--text-primary);
+        line-height: 1.6;
+        margin: 0 0 16px 0;
+
+        &:last-child {
+          margin-bottom: 0;
+        }
+      }
+    }
+
+    .dialog-actions {
+      padding: 0 40px 40px;
+      display: flex;
+      justify-content: flex-end;
+      gap: 12px;
+
+      button {
+        padding: 12px 24px;
+        border-radius: 12px;
+        font-size: 15px;
+        font-weight: 600;
+        cursor: pointer;
+        transition: all 0.2s;
+        border: none;
+
+        &.btn-cancel {
+          background: var(--bg-tertiary);
+          color: var(--text-secondary);
+
+          &:hover {
+            background: var(--bg-hover);
+          }
+        }
+
+        &.btn-confirm {
+          background: var(--primary);
+          color: var(--on-primary);
+
+          &:hover {
+            background: var(--primary-hover);
+          }
+
+          &:active {
+            transform: scale(0.98);
+          }
+        }
+      }
+    }
+  }
+}
+
+@keyframes fadeIn {
+  from { opacity: 0; }
+  to { opacity: 1; }
+}
+
+@keyframes slideUp {
+  from {
+    transform: translateY(20px);
+    opacity: 0;
+  }
+  to {
+    transform: translateY(0);
+    opacity: 1;
+  }
+}

src/components/ConfirmDialog.tsx

@@ -0,0 +1,32 @@
+import { X } from 'lucide-react'
+import './ConfirmDialog.scss'
+
+interface ConfirmDialogProps {
+  open: boolean
+  title?: string
+  message: string
+  onConfirm: () => void
+  onCancel: () => void
+}
+
+export default function ConfirmDialog({ open, title, message, onConfirm, onCancel }: ConfirmDialogProps) {
+  if (!open) return null
+
+  return (
+    <div className="confirm-dialog-overlay" onClick={onCancel}>
+      <div className="confirm-dialog" onClick={e => e.stopPropagation()}>
+        <button className="close-btn" onClick={onCancel}>
+          <X size={20} />
+        </button>
+        {title && <div className="dialog-title">{title}</div>}
+        <div className="dialog-content">
+          <p style={{ whiteSpace: 'pre-line' }}>{message}</p>
+        </div>
+        <div className="dialog-actions">
+          <button className="btn-cancel" onClick={onCancel}>取消</button>
+          <button className="btn-confirm" onClick={onConfirm}>开始获取</button>
+        </div>
+      </div>
+    </div>
+  )
+}

src/components/Export/ExportDateRangeDialog.scss

@@ -13,13 +13,14 @@
   width: min(480px, calc(100vw - 32px));
   max-height: calc(100vh - 64px);
   overflow-y: auto;
-  border-radius: 12px;
+  border-radius: 16px;
   border: 1px solid var(--border-color);
   background: var(--bg-secondary-solid, var(--bg-primary));
-  padding: 12px;
+  padding: 14px;
   display: flex;
   flex-direction: column;
   gap: 10px;
+  box-shadow: 0 22px 48px rgba(0, 0, 0, 0.16);
 }
 
 .export-date-range-dialog-header {
@@ -83,8 +84,8 @@
 }
 
 .export-date-range-mode-banner {
-  border-radius: 8px;
-  padding: 6px 8px;
+  border-radius: 10px;
+  padding: 7px 10px;
   font-size: 11px;
   line-height: 1.4;
   border: 1px solid var(--border-color);
@@ -98,47 +99,92 @@
   }
 }
 
-.export-date-range-calendar-grid {
+.export-date-range-boundary-row {
   display: grid;
   grid-template-columns: 1fr 1fr;
   gap: 8px;
 }
 
+.export-date-range-boundary-card {
+  border: 1px solid var(--border-color);
+  border-radius: 10px;
+  background: var(--bg-secondary);
+  padding: 8px;
+  display: flex;
+  flex-direction: column;
+  align-items: flex-start;
+  gap: 6px;
+  cursor: pointer;
+  transition: border-color 0.15s ease, background 0.15s ease, box-shadow 0.15s ease;
+
+  &.active {
+    border-color: var(--primary);
+    background: rgba(var(--primary-rgb), 0.08);
+    box-shadow: 0 0 0 1px rgba(var(--primary-rgb), 0.18);
+  }
+
+  .boundary-label {
+    font-size: 11px;
+    color: var(--text-secondary);
+  }
+}
+
+.export-date-range-selection-hint {
+  font-size: 11px;
+  color: var(--text-secondary);
+  padding: 0 2px;
+}
+
 .export-date-range-calendar-panel {
   border: 1px solid var(--border-color);
-  border-radius: 8px;
-  background: var(--bg-secondary);
-  padding: 7px;
+  border-radius: 12px;
+  background: linear-gradient(180deg, rgba(var(--primary-rgb), 0.04), transparent 28%), var(--bg-secondary);
+  padding: 10px;
+
+  &.single {
+    width: 100%;
+  }
 }
 
 .export-date-range-calendar-panel-header {
   display: flex;
   justify-content: space-between;
-  align-items: flex-start;
+  align-items: center;
   gap: 8px;
 }
 
 .export-date-range-calendar-date-label {
   display: flex;
   flex-direction: column;
-  gap: 2px;
+  gap: 3px;
 
   span {
     font-size: 11px;
     color: var(--text-secondary);
   }
+
+  strong {
+    font-size: 13px;
+    color: var(--text-primary);
+  }
 }
 
 .export-date-range-date-input {
   width: 100%;
   min-width: 0;
-  border-radius: 6px;
+  border-radius: 8px;
   border: 1px solid var(--border-color);
   background: var(--bg-primary);
   color: var(--text-primary);
-  height: 24px;
-  padding: 0 7px;
-  font-size: 11px;
+  height: 30px;
+  padding: 0 9px;
+  font-size: 12px;
+
+  &:focus {
+    outline: none;
+    border-color: var(--primary);
+    box-shadow: 0 0 0 1px rgba(var(--primary-rgb), 0.18);
+  }
 
   &.invalid {
     border-color: #e84d4d;
@@ -149,28 +195,36 @@
 .export-date-range-calendar-nav {
   display: inline-flex;
   align-items: center;
-  gap: 4px;
+  gap: 6px;
   font-size: 11px;
   color: var(--text-primary);
 
   button {
-    width: 20px;
-    height: 20px;
-    border-radius: 5px;
+    width: 28px;
+    height: 28px;
+    border-radius: 8px;
     border: 1px solid var(--border-color);
     background: var(--bg-primary);
     color: var(--text-primary);
     cursor: pointer;
     padding: 0;
     line-height: 1;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+
+    &:disabled {
+      cursor: not-allowed;
+      opacity: 0.45;
+    }
   }
 }
 
 .export-date-range-calendar-weekdays {
-  margin-top: 6px;
+  margin-top: 10px;
   display: grid;
   grid-template-columns: repeat(7, 1fr);
-  gap: 2px;
+  gap: 4px;
 
   span {
     text-align: center;
@@ -180,32 +234,61 @@
 }
 
 .export-date-range-calendar-days {
-  margin-top: 4px;
+  margin-top: 6px;
   display: grid;
   grid-template-columns: repeat(7, 1fr);
-  gap: 2px;
+  gap: 4px;
 }
 
 .export-date-range-calendar-day {
   border: 1px solid transparent;
-  border-radius: 6px;
-  min-height: 20px;
+  border-radius: 10px;
+  min-height: 34px;
   background: var(--bg-primary);
   color: var(--text-primary);
-  font-size: 10px;
+  font-size: 12px;
   cursor: pointer;
   padding: 0;
+  transition: border-color 0.15s ease, background 0.15s ease, color 0.15s ease, transform 0.15s ease;
+
+  &:hover {
+    border-color: rgba(var(--primary-rgb), 0.28);
+    transform: translateY(-1px);
+  }
+
+  &:disabled:hover {
+    border-color: transparent;
+    transform: none;
+  }
 
   &.outside {
     color: var(--text-quaternary);
-    opacity: 0.75;
+    opacity: 0.72;
   }
 
-  &.selected {
-    border-color: var(--primary);
-    background: rgba(var(--primary-rgb), 0.14);
+  &.disabled {
+    cursor: not-allowed;
+    opacity: 0.35;
+    transform: none;
+    border-color: transparent;
+  }
+
+  &.in-range {
+    background: rgba(var(--primary-rgb), 0.1);
     color: var(--primary);
+  }
+
+  &.range-start,
+  &.range-end {
+    border-color: var(--primary);
+    background: var(--primary);
+    color: #fff;
     font-weight: 600;
+    opacity: 1;
+  }
+
+  &.active-boundary {
+    box-shadow: 0 0 0 2px rgba(var(--primary-rgb), 0.22);
   }
 }
 
@@ -247,8 +330,8 @@
   }
 }
 
-@media (max-width: 860px) {
-  .export-date-range-calendar-grid {
+@media (max-width: 640px) {
+  .export-date-range-boundary-row {
     grid-template-columns: 1fr;
   }
 }

src/components/Export/ExportDateRangeDialog.tsx

@@ -1,6 +1,6 @@
 import { useCallback, useEffect, useMemo, useState } from 'react'
 import { createPortal } from 'react-dom'
-import { Check, X } from 'lucide-react'
+import { Check, ChevronLeft, ChevronRight, X } from 'lucide-react'
 import {
   EXPORT_DATE_RANGE_PRESETS,
   WEEKDAY_SHORT_LABELS,
@@ -25,29 +25,78 @@ interface ExportDateRangeDialogProps {
   open: boolean
   value: ExportDateRangeSelection
   title?: string
+  minDate?: Date | null
+  maxDate?: Date | null
   onClose: () => void
   onConfirm: (value: ExportDateRangeSelection) => void
 }
 
+type ActiveBoundary = 'start' | 'end'
+
 interface ExportDateRangeDialogDraft extends ExportDateRangeSelection {
-  startPanelMonth: Date
-  endPanelMonth: Date
+  panelMonth: Date
 }
 
-const buildDialogDraft = (value: ExportDateRangeSelection): ExportDateRangeDialogDraft => ({
-  ...cloneExportDateRangeSelection(value),
-  startPanelMonth: toMonthStart(value.dateRange.start),
-  endPanelMonth: toMonthStart(value.dateRange.end)
-})
+const resolveBounds = (minDate?: Date | null, maxDate?: Date | null): { minDate: Date; maxDate: Date } | null => {
+  if (!(minDate instanceof Date) || Number.isNaN(minDate.getTime())) return null
+  if (!(maxDate instanceof Date) || Number.isNaN(maxDate.getTime())) return null
+  const normalizedMin = startOfDay(minDate)
+  const normalizedMax = endOfDay(maxDate)
+  if (normalizedMin.getTime() > normalizedMax.getTime()) return null
+  return {
+    minDate: normalizedMin,
+    maxDate: normalizedMax
+  }
+}
+
+const clampSelectionToBounds = (
+  value: ExportDateRangeSelection,
+  minDate?: Date | null,
+  maxDate?: Date | null
+): ExportDateRangeSelection => {
+  const bounds = resolveBounds(minDate, maxDate)
+  if (!bounds) return cloneExportDateRangeSelection(value)
+
+  const rawStart = value.useAllTime ? bounds.minDate : startOfDay(value.dateRange.start)
+  const rawEnd = value.useAllTime ? bounds.maxDate : endOfDay(value.dateRange.end)
+  const nextStart = new Date(Math.min(Math.max(rawStart.getTime(), bounds.minDate.getTime()), bounds.maxDate.getTime()))
+  const nextEndCandidate = new Date(Math.min(Math.max(rawEnd.getTime(), bounds.minDate.getTime()), bounds.maxDate.getTime()))
+  const nextEnd = nextEndCandidate.getTime() < nextStart.getTime() ? endOfDay(nextStart) : nextEndCandidate
+  const changed = nextStart.getTime() !== rawStart.getTime() || nextEnd.getTime() !== rawEnd.getTime()
+
+  return {
+    preset: value.useAllTime ? value.preset : (changed ? 'custom' : value.preset),
+    useAllTime: value.useAllTime,
+    dateRange: {
+      start: nextStart,
+      end: nextEnd
+    }
+  }
+}
+
+const buildDialogDraft = (
+  value: ExportDateRangeSelection,
+  minDate?: Date | null,
+  maxDate?: Date | null
+): ExportDateRangeDialogDraft => {
+  const nextValue = clampSelectionToBounds(value, minDate, maxDate)
+  return {
+    ...nextValue,
+    panelMonth: toMonthStart(nextValue.dateRange.start)
+  }
+}
 
 export function ExportDateRangeDialog({
   open,
   value,
   title = '时间范围设置',
+  minDate,
+  maxDate,
   onClose,
   onConfirm
 }: ExportDateRangeDialogProps) {
-  const [draft, setDraft] = useState<ExportDateRangeDialogDraft>(() => buildDialogDraft(value))
+  const [draft, setDraft] = useState<ExportDateRangeDialogDraft>(() => buildDialogDraft(value, minDate, maxDate))
+  const [activeBoundary, setActiveBoundary] = useState<ActiveBoundary>('start')
   const [dateInput, setDateInput] = useState({
     start: formatDateInputValue(value.dateRange.start),
     end: formatDateInputValue(value.dateRange.end)
@@ -56,14 +105,15 @@ export function ExportDateRangeDialog({
 
   useEffect(() => {
     if (!open) return
-    const nextDraft = buildDialogDraft(value)
+    const nextDraft = buildDialogDraft(value, minDate, maxDate)
     setDraft(nextDraft)
+    setActiveBoundary('start')
     setDateInput({
       start: formatDateInputValue(nextDraft.dateRange.start),
       end: formatDateInputValue(nextDraft.dateRange.end)
     })
     setDateInputError({ start: false, end: false })
-  }, [open, value])
+  }, [maxDate, minDate, open, value])
 
   useEffect(() => {
     if (!open) return
@@ -74,33 +124,24 @@ export function ExportDateRangeDialog({
     setDateInputError({ start: false, end: false })
   }, [draft.dateRange.end.getTime(), draft.dateRange.start.getTime(), open])
 
-  const applyPreset = useCallback((preset: Exclude<ExportDateRangePreset, 'custom'>) => {
-    if (preset === 'all') {
-      const previewRange = createDefaultDateRange()
-      setDraft(prev => ({
-        ...prev,
-        preset,
-        useAllTime: true,
-        dateRange: previewRange,
-        startPanelMonth: toMonthStart(previewRange.start),
-        endPanelMonth: toMonthStart(previewRange.end)
-      }))
-      return
-    }
-
-    const range = createDateRangeByPreset(preset)
-    setDraft(prev => ({
-      ...prev,
-      preset,
-      useAllTime: false,
-      dateRange: range,
-      startPanelMonth: toMonthStart(range.start),
-      endPanelMonth: toMonthStart(range.end)
-    }))
-  }, [])
-
-  const updateDraftStart = useCallback((targetDate: Date) => {
+  const bounds = useMemo(() => resolveBounds(minDate, maxDate), [maxDate, minDate])
+  const clampStartDate = useCallback((targetDate: Date) => {
     const start = startOfDay(targetDate)
+    if (!bounds) return start
+    if (start.getTime() < bounds.minDate.getTime()) return bounds.minDate
+    if (start.getTime() > bounds.maxDate.getTime()) return startOfDay(bounds.maxDate)
+    return start
+  }, [bounds])
+  const clampEndDate = useCallback((targetDate: Date) => {
+    const end = endOfDay(targetDate)
+    if (!bounds) return end
+    if (end.getTime() < bounds.minDate.getTime()) return endOfDay(bounds.minDate)
+    if (end.getTime() > bounds.maxDate.getTime()) return bounds.maxDate
+    return end
+  }, [bounds])
+
+  const setRangeStart = useCallback((targetDate: Date) => {
+    const start = clampStartDate(targetDate)
     setDraft(prev => {
       const nextEnd = prev.dateRange.end < start ? endOfDay(start) : prev.dateRange.end
       return {
@@ -111,16 +152,15 @@ export function ExportDateRangeDialog({
           start,
           end: nextEnd
         },
-        startPanelMonth: toMonthStart(start),
-        endPanelMonth: toMonthStart(nextEnd)
+        panelMonth: toMonthStart(start)
       }
     })
-  }, [])
+  }, [clampStartDate])
 
-  const updateDraftEnd = useCallback((targetDate: Date) => {
-    const end = endOfDay(targetDate)
+  const setRangeEnd = useCallback((targetDate: Date) => {
+    const end = clampEndDate(targetDate)
     setDraft(prev => {
-      const nextStart = prev.useAllTime ? startOfDay(targetDate) : prev.dateRange.start
+      const nextStart = prev.useAllTime ? clampStartDate(targetDate) : prev.dateRange.start
       const nextEnd = end < nextStart ? endOfDay(nextStart) : end
       return {
         ...prev,
@@ -130,11 +170,41 @@ export function ExportDateRangeDialog({
           start: nextStart,
           end: nextEnd
         },
-        startPanelMonth: toMonthStart(nextStart),
-        endPanelMonth: toMonthStart(nextEnd)
+        panelMonth: toMonthStart(targetDate)
       }
     })
-  }, [])
+  }, [clampEndDate, clampStartDate])
+
+  const applyPreset = useCallback((preset: Exclude<ExportDateRangePreset, 'custom'>) => {
+    if (preset === 'all') {
+      const previewRange = bounds
+        ? { start: bounds.minDate, end: bounds.maxDate }
+        : createDefaultDateRange()
+      setDraft(prev => ({
+        ...prev,
+        preset,
+        useAllTime: true,
+        dateRange: previewRange,
+        panelMonth: toMonthStart(previewRange.start)
+      }))
+      setActiveBoundary('start')
+      return
+    }
+
+    const range = clampSelectionToBounds({
+      preset,
+      useAllTime: false,
+      dateRange: createDateRangeByPreset(preset)
+    }, minDate, maxDate).dateRange
+    setDraft(prev => ({
+      ...prev,
+      preset,
+      useAllTime: false,
+      dateRange: range,
+      panelMonth: toMonthStart(range.start)
+    }))
+    setActiveBoundary('start')
+  }, [bounds, maxDate, minDate])
 
   const commitStartFromInput = useCallback(() => {
     const parsed = parseDateInputValue(dateInput.start)
@@ -143,8 +213,8 @@ export function ExportDateRangeDialog({
       return
     }
     setDateInputError(prev => ({ ...prev, start: false }))
-    updateDraftStart(parsed)
-  }, [dateInput.start, updateDraftStart])
+    setRangeStart(parsed)
+  }, [dateInput.start, setRangeStart])
 
   const commitEndFromInput = useCallback(() => {
     const parsed = parseDateInputValue(dateInput.end)
@@ -153,29 +223,81 @@ export function ExportDateRangeDialog({
       return
     }
     setDateInputError(prev => ({ ...prev, end: false }))
-    updateDraftEnd(parsed)
-  }, [dateInput.end, updateDraftEnd])
+    setRangeEnd(parsed)
+  }, [dateInput.end, setRangeEnd])
 
-  const shiftPanelMonth = useCallback((panel: 'start' | 'end', delta: number) => {
-    setDraft(prev => (
-      panel === 'start'
-        ? { ...prev, startPanelMonth: addMonths(prev.startPanelMonth, delta) }
-        : { ...prev, endPanelMonth: addMonths(prev.endPanelMonth, delta) }
-    ))
+  const shiftPanelMonth = useCallback((delta: number) => {
+    setDraft(prev => ({
+      ...prev,
+      panelMonth: addMonths(prev.panelMonth, delta)
+    }))
   }, [])
 
+  const handleCalendarSelect = useCallback((targetDate: Date) => {
+    if (activeBoundary === 'start') {
+      setRangeStart(targetDate)
+      setActiveBoundary('end')
+      return
+    }
+
+    setDraft(prev => {
+      const start = prev.useAllTime ? startOfDay(targetDate) : prev.dateRange.start
+      const pickedStart = startOfDay(targetDate)
+      const nextStart = pickedStart <= start ? pickedStart : start
+      const nextEnd = pickedStart <= start ? endOfDay(start) : endOfDay(targetDate)
+      return {
+        ...prev,
+        preset: 'custom',
+        useAllTime: false,
+        dateRange: {
+          start: nextStart,
+          end: nextEnd
+        },
+        panelMonth: toMonthStart(targetDate)
+      }
+    })
+    setActiveBoundary('start')
+  }, [activeBoundary, setRangeEnd, setRangeStart])
+
   const isRangeModeActive = !draft.useAllTime
   const modeText = isRangeModeActive
     ? '当前导出模式：按时间范围导出'
-    : '当前导出模式：全部时间导出（选择下方日期将切换为按时间范围导出）'
+    : '当前导出模式：全部时间导出，选择下方日期会切换为自定义时间范围'
 
   const isPresetActive = useCallback((preset: ExportDateRangePreset): boolean => {
     if (preset === 'all') return draft.useAllTime
     return !draft.useAllTime && draft.preset === preset
   }, [draft])
 
-  const startPanelCells = useMemo(() => buildCalendarCells(draft.startPanelMonth), [draft.startPanelMonth])
-  const endPanelCells = useMemo(() => buildCalendarCells(draft.endPanelMonth), [draft.endPanelMonth])
+  const calendarCells = useMemo(() => buildCalendarCells(draft.panelMonth), [draft.panelMonth])
+  const minPanelMonth = bounds ? toMonthStart(bounds.minDate) : null
+  const maxPanelMonth = bounds ? toMonthStart(bounds.maxDate) : null
+  const canShiftPrev = !minPanelMonth || draft.panelMonth.getTime() > minPanelMonth.getTime()
+  const canShiftNext = !maxPanelMonth || draft.panelMonth.getTime() < maxPanelMonth.getTime()
+
+  const isStartSelected = useCallback((date: Date) => (
+    !draft.useAllTime && isSameDay(date, draft.dateRange.start)
+  ), [draft])
+
+  const isEndSelected = useCallback((date: Date) => (
+    !draft.useAllTime && isSameDay(date, draft.dateRange.end)
+  ), [draft])
+
+  const isDateInRange = useCallback((date: Date) => (
+    !draft.useAllTime &&
+    startOfDay(date).getTime() >= startOfDay(draft.dateRange.start).getTime() &&
+    startOfDay(date).getTime() <= startOfDay(draft.dateRange.end).getTime()
+  ), [draft])
+
+  const isDateSelectable = useCallback((date: Date) => {
+    if (!bounds) return true
+    const target = startOfDay(date).getTime()
+    return target >= startOfDay(bounds.minDate).getTime() && target <= startOfDay(bounds.maxDate).getTime()
+  }, [bounds])
+
+  const hintText = draft.useAllTime
+    ? '选择开始或结束日期后，会自动切换为自定义时间范围'
+    : (activeBoundary === 'start' ? '下一次点击将设置开始日期' : '下一次点击将设置结束日期')
 
   if (!open) return null
 
@@ -215,112 +337,115 @@ export function ExportDateRangeDialog({
           {modeText}
         </div>
 
-        <div className="export-date-range-calendar-grid">
-          <section className="export-date-range-calendar-panel">
-            <div className="export-date-range-calendar-panel-header">
-              <div className="export-date-range-calendar-date-label">
-                <span>起始日期</span>
-                <input
-                  type="text"
-                  className={`export-date-range-date-input ${dateInputError.start ? 'invalid' : ''}`}
-                  value={dateInput.start}
-                  placeholder="YYYY-MM-DD"
-                  onChange={(event) => {
-                    const nextValue = event.target.value
-                    setDateInput(prev => ({ ...prev, start: nextValue }))
-                    if (dateInputError.start) {
-                      setDateInputError(prev => ({ ...prev, start: false }))
-                    }
-                  }}
-                  onKeyDown={(event) => {
-                    if (event.key !== 'Enter') return
-                    event.preventDefault()
-                    commitStartFromInput()
-                  }}
-                  onBlur={commitStartFromInput}
-                />
-              </div>
-              <div className="export-date-range-calendar-nav">
-                <button type="button" onClick={() => shiftPanelMonth('start', -1)} aria-label="上个月">‹</button>
-                <span>{formatCalendarMonthTitle(draft.startPanelMonth)}</span>
-                <button type="button" onClick={() => shiftPanelMonth('start', 1)} aria-label="下个月">›</button>
-              </div>
-            </div>
-            <div className="export-date-range-calendar-weekdays">
-              {WEEKDAY_SHORT_LABELS.map(label => (
-                <span key={`start-weekday-${label}`}>{label}</span>
-              ))}
-            </div>
-            <div className="export-date-range-calendar-days">
-              {startPanelCells.map((cell) => {
-                const selected = !draft.useAllTime && isSameDay(cell.date, draft.dateRange.start)
-                return (
-                  <button
-                    key={`start-${cell.date.getTime()}`}
-                    type="button"
-                    className={`export-date-range-calendar-day ${cell.inCurrentMonth ? '' : 'outside'} ${selected ? 'selected' : ''}`}
-                    onClick={() => updateDraftStart(cell.date)}
-                  >
-                    {cell.date.getDate()}
-                  </button>
-                )
-              })}
-            </div>
-          </section>
-
-          <section className="export-date-range-calendar-panel">
-            <div className="export-date-range-calendar-panel-header">
-              <div className="export-date-range-calendar-date-label">
-                <span>截止日期</span>
-                <input
-                  type="text"
-                  className={`export-date-range-date-input ${dateInputError.end ? 'invalid' : ''}`}
-                  value={dateInput.end}
-                  placeholder="YYYY-MM-DD"
-                  onChange={(event) => {
-                    const nextValue = event.target.value
-                    setDateInput(prev => ({ ...prev, end: nextValue }))
-                    if (dateInputError.end) {
-                      setDateInputError(prev => ({ ...prev, end: false }))
-                    }
-                  }}
-                  onKeyDown={(event) => {
-                    if (event.key !== 'Enter') return
-                    event.preventDefault()
-                    commitEndFromInput()
-                  }}
-                  onBlur={commitEndFromInput}
-                />
-              </div>
-              <div className="export-date-range-calendar-nav">
-                <button type="button" onClick={() => shiftPanelMonth('end', -1)} aria-label="上个月">‹</button>
-                <span>{formatCalendarMonthTitle(draft.endPanelMonth)}</span>
-                <button type="button" onClick={() => shiftPanelMonth('end', 1)} aria-label="下个月">›</button>
-              </div>
-            </div>
-            <div className="export-date-range-calendar-weekdays">
-              {WEEKDAY_SHORT_LABELS.map(label => (
-                <span key={`end-weekday-${label}`}>{label}</span>
-              ))}
-            </div>
-            <div className="export-date-range-calendar-days">
-              {endPanelCells.map((cell) => {
-                const selected = !draft.useAllTime && isSameDay(cell.date, draft.dateRange.end)
-                return (
-                  <button
-                    key={`end-${cell.date.getTime()}`}
-                    type="button"
-                    className={`export-date-range-calendar-day ${cell.inCurrentMonth ? '' : 'outside'} ${selected ? 'selected' : ''}`}
-                    onClick={() => updateDraftEnd(cell.date)}
-                  >
-                    {cell.date.getDate()}
-                  </button>
-                )
-              })}
-            </div>
-          </section>
+        <div className="export-date-range-boundary-row">
+          <div
+            className={`export-date-range-boundary-card ${activeBoundary === 'start' ? 'active' : ''}`}
+            onClick={() => setActiveBoundary('start')}
+          >
+            <span className="boundary-label">开始</span>
+            <input
+              type="text"
+              className={`export-date-range-date-input ${dateInputError.start ? 'invalid' : ''}`}
+              value={dateInput.start}
+              placeholder="YYYY-MM-DD"
+              onChange={(event) => {
+                const nextValue = event.target.value
+                setDateInput(prev => ({ ...prev, start: nextValue }))
+                if (dateInputError.start) {
+                  setDateInputError(prev => ({ ...prev, start: false }))
+                }
+              }}
+              onFocus={() => setActiveBoundary('start')}
+              onClick={(event) => event.stopPropagation()}
+              onKeyDown={(event) => {
+                if (event.key !== 'Enter') return
+                event.preventDefault()
+                commitStartFromInput()
+              }}
+              onBlur={commitStartFromInput}
+            />
+          </div>
+          <div
+            className={`export-date-range-boundary-card ${activeBoundary === 'end' ? 'active' : ''}`}
+            onClick={() => setActiveBoundary('end')}
+          >
+            <span className="boundary-label">结束</span>
+            <input
+              type="text"
+              className={`export-date-range-date-input ${dateInputError.end ? 'invalid' : ''}`}
+              value={dateInput.end}
+              placeholder="YYYY-MM-DD"
+              onChange={(event) => {
+                const nextValue = event.target.value
+                setDateInput(prev => ({ ...prev, end: nextValue }))
+                if (dateInputError.end) {
+                  setDateInputError(prev => ({ ...prev, end: false }))
+                }
+              }}
+              onFocus={() => setActiveBoundary('end')}
+              onClick={(event) => event.stopPropagation()}
+              onKeyDown={(event) => {
+                if (event.key !== 'Enter') return
+                event.preventDefault()
+                commitEndFromInput()
+              }}
+              onBlur={commitEndFromInput}
+            />
+          </div>
         </div>
 
+        <div className="export-date-range-selection-hint">{hintText}</div>
+
+        <section className="export-date-range-calendar-panel single">
+          <div className="export-date-range-calendar-panel-header">
+            <div className="export-date-range-calendar-date-label">
+              <span>选择日期范围</span>
+              <strong>{formatCalendarMonthTitle(draft.panelMonth)}</strong>
+            </div>
+            <div className="export-date-range-calendar-nav">
+              <button type="button" onClick={() => shiftPanelMonth(-1)} aria-label="上个月" disabled={!canShiftPrev}>
+                <ChevronLeft size={14} />
+              </button>
+              <button type="button" onClick={() => shiftPanelMonth(1)} aria-label="下个月" disabled={!canShiftNext}>
+                <ChevronRight size={14} />
+              </button>
+            </div>
+          </div>
+          <div className="export-date-range-calendar-weekdays">
+            {WEEKDAY_SHORT_LABELS.map(label => (
+              <span key={`weekday-${label}`}>{label}</span>
+            ))}
+          </div>
+          <div className="export-date-range-calendar-days">
+            {calendarCells.map((cell) => {
+              const startSelected = isStartSelected(cell.date)
+              const endSelected = isEndSelected(cell.date)
+              const inRange = isDateInRange(cell.date)
+              const selectable = isDateSelectable(cell.date)
+              return (
+                <button
+                  key={cell.date.getTime()}
+                  type="button"
+                  disabled={!selectable}
+                  className={[
+                    'export-date-range-calendar-day',
+                    cell.inCurrentMonth ? '' : 'outside',
+                    selectable ? '' : 'disabled',
+                    inRange ? 'in-range' : '',
+                    startSelected ? 'range-start' : '',
+                    endSelected ? 'range-end' : '',
+                    activeBoundary === 'start' && startSelected ? 'active-boundary' : '',
+                    activeBoundary === 'end' && endSelected ? 'active-boundary' : ''
+                  ].filter(Boolean).join(' ')}
+                  onClick={() => handleCalendarSelect(cell.date)}
+                >
+                  {cell.date.getDate()}
+                </button>
+              )
+            })}
+          </div>
+        </section>
+
         <div className="export-date-range-dialog-actions">
           <button type="button" className="export-date-range-dialog-btn secondary" onClick={onClose}>
             取消

src/components/GlobalSessionMonitor.tsx

@@ -1,6 +1,6 @@
 import { useEffect, useRef } from 'react'
 import { useChatStore } from '../stores/chatStore'
-import type { ChatSession } from '../types/models'
+import type { ChatSession, Message } from '../types/models'
 import { useNavigate } from 'react-router-dom'
 
 export function GlobalSessionMonitor() {
@@ -20,9 +20,9 @@ export function GlobalSessionMonitor() {
     }, [sessions])
 
     // 去重辅助函数：获取消息 key
-    const getMessageKey = (msg: any) => {
-        if (msg.localId && msg.localId > 0) return `l:${msg.localId}`
-        return `t:${msg.createTime}:${msg.sortSeq || 0}:${msg.serverId || 0}`
+    const getMessageKey = (msg: Message) => {
+        if (msg.messageKey) return msg.messageKey
+        return `fallback:${msg.serverId || 0}:${msg.createTime}:${msg.sortSeq || 0}:${msg.localId || 0}:${msg.senderUsername || ''}:${msg.localType || 0}`
     }
 
     // 处理数据库变更
@@ -267,7 +267,12 @@ export function GlobalSessionMonitor() {
         try {
             const result = await (window.electronAPI.chat as any).getNewMessages(sessionId, minTime)
             if (result.success && result.messages && result.messages.length > 0) {
-                appendMessages(result.messages, false) // 追加到末尾
+                const latestMessages = useChatStore.getState().messages || []
+                const existingKeys = new Set(latestMessages.map(getMessageKey))
+                const newMessages = result.messages.filter((msg: Message) => !existingKeys.has(getMessageKey(msg)))
+                if (newMessages.length > 0) {
+                    appendMessages(newMessages, false)
+                }
             }
         } catch (e) {
             console.warn('后台活跃会话刷新失败:', e)

src/components/JumpToDateDialog.scss

@@ -75,6 +75,8 @@
             font-size: 15px;
             font-weight: 600;
             color: var(--text-primary);
+            border: none;
+            background: transparent;
 
             &.clickable {
                 cursor: pointer;
@@ -172,6 +174,33 @@
                 }
             }
         }
+
+        .year-grid {
+            display: grid;
+            grid-template-columns: repeat(3, 1fr);
+            gap: 6px;
+
+            .year-btn {
+                padding: 10px 0;
+                border: none;
+                background: transparent;
+                border-radius: 8px;
+                cursor: pointer;
+                font-size: 13px;
+                color: var(--text-secondary);
+                transition: all 0.15s;
+
+                &:hover {
+                    background: var(--bg-hover);
+                    color: var(--text-primary);
+                }
+
+                &.active {
+                    background: var(--primary);
+                    color: #fff;
+                }
+            }
+        }
     }
 }
 
@@ -372,4 +401,4 @@
         opacity: 1;
         transform: translateY(0);
     }
-}
+}

src/components/JumpToDateDialog.tsx

@@ -1,4 +1,4 @@
-import React, { useState, useMemo } from 'react'
+import React, { useState } from 'react'
 import { X, ChevronLeft, ChevronRight, Calendar as CalendarIcon, Loader2 } from 'lucide-react'
 import './JumpToDateDialog.scss'
 
@@ -21,10 +21,15 @@ const JumpToDateDialog: React.FC<JumpToDateDialogProps> = ({
     messageDates,
     loadingDates = false
 }) => {
+    type CalendarViewMode = 'day' | 'month' | 'year'
+    const getYearPageStart = (year: number): number => Math.floor(year / 12) * 12
     const isValidDate = (d: any) => d instanceof Date && !isNaN(d.getTime())
     const [calendarDate, setCalendarDate] = useState(isValidDate(currentDate) ? new Date(currentDate) : new Date())
     const [selectedDate, setSelectedDate] = useState(new Date(currentDate))
-    const [showYearMonthPicker, setShowYearMonthPicker] = useState(false)
+    const [viewMode, setViewMode] = useState<CalendarViewMode>('day')
+    const [yearPageStart, setYearPageStart] = useState<number>(
+        getYearPageStart((isValidDate(currentDate) ? new Date(currentDate) : new Date()).getFullYear())
+    )
 
     if (!isOpen) return null
 
@@ -116,6 +121,57 @@ const JumpToDateDialog: React.FC<JumpToDateDialogProps> = ({
 
     const weekdays = ['日', '一', '二', '三', '四', '五', '六']
     const days = generateCalendar()
+    const monthNames = ['一月', '二月', '三月', '四月', '五月', '六月', '七月', '八月', '九月', '十月', '十一月', '十二月']
+
+    const updateCalendarDate = (nextDate: Date) => {
+        setCalendarDate(nextDate)
+    }
+
+    const openMonthView = () => setViewMode('month')
+    const openYearView = () => {
+        setYearPageStart(getYearPageStart(calendarDate.getFullYear()))
+        setViewMode('year')
+    }
+
+    const handleTitleClick = () => {
+        if (viewMode === 'day') {
+            openMonthView()
+            return
+        }
+        if (viewMode === 'month') {
+            openYearView()
+        }
+    }
+
+    const handlePrev = () => {
+        if (viewMode === 'day') {
+            updateCalendarDate(new Date(calendarDate.getFullYear(), calendarDate.getMonth() - 1, 1))
+            return
+        }
+        if (viewMode === 'month') {
+            updateCalendarDate(new Date(calendarDate.getFullYear() - 1, calendarDate.getMonth(), 1))
+            return
+        }
+        setYearPageStart((prev) => prev - 12)
+    }
+
+    const handleNext = () => {
+        if (viewMode === 'day') {
+            updateCalendarDate(new Date(calendarDate.getFullYear(), calendarDate.getMonth() + 1, 1))
+            return
+        }
+        if (viewMode === 'month') {
+            updateCalendarDate(new Date(calendarDate.getFullYear() + 1, calendarDate.getMonth(), 1))
+            return
+        }
+        setYearPageStart((prev) => prev + 12)
+    }
+
+    const navTitle = viewMode === 'day'
+        ? `${calendarDate.getFullYear()}年${calendarDate.getMonth() + 1}月`
+        : viewMode === 'month'
+            ? `${calendarDate.getFullYear()}年`
+            : `${yearPageStart}年 - ${yearPageStart + 11}年`
 
     return (
         <div className="jump-date-overlay" onClick={onClose}>
@@ -134,45 +190,57 @@ const JumpToDateDialog: React.FC<JumpToDateDialogProps> = ({
                     <div className="calendar-nav">
                         <button
                             className="nav-btn"
-                            onClick={() => setCalendarDate(new Date(calendarDate.getFullYear(), calendarDate.getMonth() - 1, 1))}
+                            onClick={handlePrev}
                         >
                             <ChevronLeft size={18} />
                         </button>
-                        <span className="current-month clickable" onClick={() => setShowYearMonthPicker(!showYearMonthPicker)}>
-                            {calendarDate.getFullYear()}年{calendarDate.getMonth() + 1}月
-                        </span>
+                        <button
+                            className={`current-month ${viewMode === 'year' ? '' : 'clickable'}`.trim()}
+                            onClick={handleTitleClick}
+                            type="button"
+                        >
+                            {navTitle}
+                        </button>
                         <button
                             className="nav-btn"
-                            onClick={() => setCalendarDate(new Date(calendarDate.getFullYear(), calendarDate.getMonth() + 1, 1))}
+                            onClick={handleNext}
                         >
                             <ChevronRight size={18} />
                         </button>
                     </div>
 
-                    {showYearMonthPicker ? (
+                    {viewMode === 'month' ? (
                         <div className="year-month-picker">
-                            <div className="year-selector">
-                                <button className="nav-btn" onClick={() => setCalendarDate(new Date(calendarDate.getFullYear() - 1, calendarDate.getMonth(), 1))}>
-                                    <ChevronLeft size={16} />
-                                </button>
-                                <span className="year-label">{calendarDate.getFullYear()}年</span>
-                                <button className="nav-btn" onClick={() => setCalendarDate(new Date(calendarDate.getFullYear() + 1, calendarDate.getMonth(), 1))}>
-                                    <ChevronRight size={16} />
-                                </button>
-                            </div>
                             <div className="month-grid">
-                                {['一月','二月','三月','四月','五月','六月','七月','八月','九月','十月','十一月','十二月'].map((name, i) => (
+                                {monthNames.map((name, i) => (
                                     <button
                                         key={i}
                                         className={`month-btn ${i === calendarDate.getMonth() ? 'active' : ''}`}
                                         onClick={() => {
-                                            setCalendarDate(new Date(calendarDate.getFullYear(), i, 1))
-                                            setShowYearMonthPicker(false)
+                                            updateCalendarDate(new Date(calendarDate.getFullYear(), i, 1))
+                                            setViewMode('day')
                                         }}
                                     >{name}</button>
                                 ))}
                             </div>
                         </div>
+                    ) : viewMode === 'year' ? (
+                        <div className="year-month-picker">
+                            <div className="year-grid">
+                                {Array.from({ length: 12 }, (_, i) => yearPageStart + i).map((year) => (
+                                    <button
+                                        key={year}
+                                        className={`year-btn ${year === calendarDate.getFullYear() ? 'active' : ''}`}
+                                        onClick={() => {
+                                            updateCalendarDate(new Date(year, calendarDate.getMonth(), 1))
+                                            setViewMode('month')
+                                        }}
+                                    >
+                                        {year}年
+                                    </button>
+                                ))}
+                            </div>
+                        </div>
                     ) : (
                     <div className={`calendar-grid ${loadingDates ? 'loading' : ''}`}>
                         {loadingDates && (
@@ -208,18 +276,21 @@ const JumpToDateDialog: React.FC<JumpToDateDialogProps> = ({
                         const d = new Date()
                         setSelectedDate(d)
                         setCalendarDate(new Date(d))
+                        setViewMode('day')
                     }}>今天</button>
                     <button onClick={() => {
                         const d = new Date()
                         d.setDate(d.getDate() - 7)
                         setSelectedDate(d)
                         setCalendarDate(new Date(d))
+                        setViewMode('day')
                     }}>一周前</button>
                     <button onClick={() => {
                         const d = new Date()
                         d.setMonth(d.getMonth() - 1)
                         setSelectedDate(d)
                         setCalendarDate(new Date(d))
+                        setViewMode('day')
                     }}>一月前</button>
                 </div>
 

src/components/JumpToDatePopover.scss

@@ -28,6 +28,20 @@
   font-size: 14px;
   font-weight: 600;
   color: var(--text-primary);
+  border: none;
+  background: transparent;
+  border-radius: 8px;
+  padding: 4px 8px;
+}
+
+.jump-date-popover .current-month.clickable {
+  cursor: pointer;
+  transition: all 0.18s ease;
+}
+
+.jump-date-popover .current-month.clickable:hover {
+  color: var(--primary);
+  background: var(--bg-hover);
 }
 
 .jump-date-popover .nav-btn {
@@ -83,6 +97,37 @@
   gap: 4px;
 }
 
+.jump-date-popover .month-grid,
+.jump-date-popover .year-grid {
+  display: grid;
+  grid-template-columns: repeat(3, 1fr);
+  gap: 6px;
+  min-height: 256px;
+}
+
+.jump-date-popover .month-cell,
+.jump-date-popover .year-cell {
+  border: none;
+  border-radius: 8px;
+  background: transparent;
+  color: var(--text-secondary);
+  cursor: pointer;
+  font-size: 13px;
+  transition: all 0.18s ease;
+}
+
+.jump-date-popover .month-cell:hover,
+.jump-date-popover .year-cell:hover {
+  background: var(--bg-hover);
+  color: var(--text-primary);
+}
+
+.jump-date-popover .month-cell.active,
+.jump-date-popover .year-cell.active {
+  background: var(--primary);
+  color: #fff;
+}
+
 .jump-date-popover .day-cell {
   position: relative;
   border: 1px solid transparent;
@@ -137,18 +182,22 @@
   margin-top: 1px;
   font-size: 13px;
   line-height: 1;
-  color: #16a34a;
+  color: var(--primary, #07c160);
   font-weight: 700;
 }
 
 .jump-date-popover .day-cell.selected .day-count {
-  color: #86efac;
+  color: color-mix(in srgb, #ffffff 78%, var(--primary, #07c160) 22%);
 }
 
 .jump-date-popover .day-count-loading {
   position: static;
   margin-top: 1px;
-  color: #22c55e;
+  color: var(--primary, #07c160);
+}
+
+.jump-date-popover .day-cell.selected .day-count-loading {
+  color: color-mix(in srgb, #ffffff 78%, var(--primary, #07c160) 22%);
 }
 
 .jump-date-popover .spin {

src/components/JumpToDatePopover.tsx

@@ -31,14 +31,20 @@ const JumpToDatePopover: React.FC<JumpToDatePopoverProps> = ({
   loadingDates = false,
   loadingDateCounts = false
 }) => {
+  type CalendarViewMode = 'day' | 'month' | 'year'
+  const getYearPageStart = (year: number): number => Math.floor(year / 12) * 12
   const [calendarDate, setCalendarDate] = useState<Date>(new Date(currentDate))
   const [selectedDate, setSelectedDate] = useState<Date>(new Date(currentDate))
+  const [viewMode, setViewMode] = useState<CalendarViewMode>('day')
+  const [yearPageStart, setYearPageStart] = useState<number>(getYearPageStart(new Date(currentDate).getFullYear()))
 
   useEffect(() => {
     if (!isOpen) return
     const normalized = new Date(currentDate)
     setCalendarDate(normalized)
     setSelectedDate(normalized)
+    setViewMode('day')
+    setYearPageStart(getYearPageStart(normalized.getFullYear()))
   }, [isOpen, currentDate])
 
   if (!isOpen) return null
@@ -114,25 +120,78 @@ const JumpToDatePopover: React.FC<JumpToDatePopoverProps> = ({
   const weekdays = ['日', '一', '二', '三', '四', '五', '六']
   const days = generateCalendar()
   const mergedClassName = ['jump-date-popover', className || ''].join(' ').trim()
+
   const updateCalendarDate = (nextDate: Date) => {
     setCalendarDate(nextDate)
     onMonthChange?.(nextDate)
   }
 
+  const openMonthView = () => setViewMode('month')
+  const openYearView = () => {
+    setYearPageStart(getYearPageStart(calendarDate.getFullYear()))
+    setViewMode('year')
+  }
+
+  const handleTitleClick = () => {
+    if (viewMode === 'day') {
+      openMonthView()
+      return
+    }
+    if (viewMode === 'month') {
+      openYearView()
+    }
+  }
+
+  const handlePrev = () => {
+    if (viewMode === 'day') {
+      updateCalendarDate(new Date(calendarDate.getFullYear(), calendarDate.getMonth() - 1, 1))
+      return
+    }
+    if (viewMode === 'month') {
+      updateCalendarDate(new Date(calendarDate.getFullYear() - 1, calendarDate.getMonth(), 1))
+      return
+    }
+    setYearPageStart((prev) => prev - 12)
+  }
+
+  const handleNext = () => {
+    if (viewMode === 'day') {
+      updateCalendarDate(new Date(calendarDate.getFullYear(), calendarDate.getMonth() + 1, 1))
+      return
+    }
+    if (viewMode === 'month') {
+      updateCalendarDate(new Date(calendarDate.getFullYear() + 1, calendarDate.getMonth(), 1))
+      return
+    }
+    setYearPageStart((prev) => prev + 12)
+  }
+
+  const navTitle = viewMode === 'day'
+    ? `${calendarDate.getFullYear()}年${calendarDate.getMonth() + 1}月`
+    : viewMode === 'month'
+      ? `${calendarDate.getFullYear()}年`
+      : `${yearPageStart}年 - ${yearPageStart + 11}年`
+
   return (
     <div className={mergedClassName} style={style} role="dialog" aria-label="跳转日期">
       <div className="calendar-nav">
         <button
           className="nav-btn"
-          onClick={() => updateCalendarDate(new Date(calendarDate.getFullYear(), calendarDate.getMonth() - 1, 1))}
+          onClick={handlePrev}
           aria-label="上一月"
         >
           <ChevronLeft size={16} />
         </button>
-        <span className="current-month">{calendarDate.getFullYear()}年{calendarDate.getMonth() + 1}月</span>
+        <button
+          className={`current-month ${viewMode === 'year' ? '' : 'clickable'}`.trim()}
+          onClick={handleTitleClick}
+          type="button"
+        >
+          {navTitle}
+        </button>
         <button
           className="nav-btn"
-          onClick={() => updateCalendarDate(new Date(calendarDate.getFullYear(), calendarDate.getMonth() + 1, 1))}
+          onClick={handleNext}
           aria-label="下一月"
         >
           <ChevronRight size={16} />
@@ -154,36 +213,74 @@ const JumpToDatePopover: React.FC<JumpToDatePopoverProps> = ({
         )}
       </div>
 
-      <div className="calendar-grid">
-        <div className="weekdays">
-          {weekdays.map(day => (
-            <div key={day} className="weekday">{day}</div>
+      {viewMode === 'day' && (
+        <div className="calendar-grid">
+          <div className="weekdays">
+            {weekdays.map(day => (
+              <div key={day} className="weekday">{day}</div>
+            ))}
+          </div>
+          <div className="days">
+            {days.map((day, index) => {
+              if (day === null) return <div key={index} className="day-cell empty" />
+              const dateKey = toDateKey(day)
+              const hasMessageOnDay = hasMessage(day)
+              const count = Number(messageDateCounts?.[dateKey] || 0)
+              const showCount = count > 0
+              const showCountLoading = hasMessageOnDay && loadingDateCounts && !showCount
+              return (
+                <button
+                  key={index}
+                  className={getDayClassName(day)}
+                  onClick={() => handleDateClick(day)}
+                  disabled={hasLoadedMessageDates && !hasMessageOnDay}
+                  type="button"
+                >
+                  <span className="day-number">{day}</span>
+                  {showCount && <span className="day-count">{count}</span>}
+                  {showCountLoading && <Loader2 size={11} className="day-count-loading spin" />}
+                </button>
+              )
+            })}
+          </div>
+        </div>
+      )}
+
+      {viewMode === 'month' && (
+        <div className="month-grid">
+          {['1月', '2月', '3月', '4月', '5月', '6月', '7月', '8月', '9月', '10月', '11月', '12月'].map((name, monthIndex) => (
+            <button
+              key={name}
+              className={`month-cell ${monthIndex === calendarDate.getMonth() ? 'active' : ''}`}
+              onClick={() => {
+                updateCalendarDate(new Date(calendarDate.getFullYear(), monthIndex, 1))
+                setViewMode('day')
+              }}
+              type="button"
+            >
+              {name}
+            </button>
           ))}
         </div>
-        <div className="days">
-          {days.map((day, index) => {
-            if (day === null) return <div key={index} className="day-cell empty" />
-            const dateKey = toDateKey(day)
-            const hasMessageOnDay = hasMessage(day)
-            const count = Number(messageDateCounts?.[dateKey] || 0)
-            const showCount = count > 0
-            const showCountLoading = hasMessageOnDay && loadingDateCounts && !showCount
-            return (
-              <button
-                key={index}
-                className={getDayClassName(day)}
-                onClick={() => handleDateClick(day)}
-                disabled={hasLoadedMessageDates && !hasMessageOnDay}
-                type="button"
-              >
-                <span className="day-number">{day}</span>
-                {showCount && <span className="day-count">{count}</span>}
-                {showCountLoading && <Loader2 size={11} className="day-count-loading spin" />}
-              </button>
-            )
-          })}
+      )}
+
+      {viewMode === 'year' && (
+        <div className="year-grid">
+          {Array.from({ length: 12 }, (_, i) => yearPageStart + i).map((year) => (
+            <button
+              key={year}
+              className={`year-cell ${year === calendarDate.getFullYear() ? 'active' : ''}`}
+              onClick={() => {
+                updateCalendarDate(new Date(year, calendarDate.getMonth(), 1))
+                setViewMode('month')
+              }}
+              type="button"
+            >
+              {year}年
+            </button>
+          ))}
         </div>
-      </div>
+      )}
     </div>
   )
 }

src/components/NotificationToast.scss

@@ -134,6 +134,25 @@
         }
     }
 
+    &.top-center {
+        top: 24px;
+        left: 50%;
+        transform: translate(-50%, -20px) scale(0.95);
+
+        &.visible {
+            transform: translate(-50%, 0) scale(1);
+        }
+
+        // 灵动岛样式
+        border-radius: 40px !important;
+        padding: 12px 16px;
+        box-shadow: 0 12px 48px rgba(0, 0, 0, 0.2);
+
+        &.static {
+            border-radius: 40px !important;
+        }
+    }
+
     &:hover {
         box-shadow: 0 12px 48px rgba(0, 0, 0, 0.16) !important;
     }

src/components/NotificationToast.tsx

@@ -18,7 +18,7 @@ interface NotificationToastProps {
     onClose: () => void
     onClick: (sessionId: string) => void
     duration?: number
-    position?: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left'
+    position?: 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left' | 'top-center'
     isStatic?: boolean
     initialVisible?: boolean
 }

src/components/Sidebar.tsx

@@ -6,6 +6,7 @@ import { useChatStore } from '../stores/chatStore'
 import { useAnalyticsStore } from '../stores/analyticsStore'
 import * as configService from '../services/config'
 import { onExportSessionStatus, requestExportSessionStatus } from '../services/exportBridge'
+import { UserRound } from 'lucide-react'
 
 import './Sidebar.scss'
 
@@ -35,6 +36,7 @@ interface AccountProfilesCache {
 interface WxidOption {
   wxid: string
   modifiedTime: number
+  nickname?: string
   displayName?: string
   avatarUrl?: string
 }
@@ -280,26 +282,28 @@ function Sidebar({ collapsed }: SidebarProps) {
       const accountsCache = readAccountProfilesCache()
       console.log('[切换账号] 账号缓存:', accountsCache)
 
-      const enrichedWxids = wxids.map(option => {
+      const enrichedWxids = wxids.map((option: WxidOption) => {
         const normalizedWxid = normalizeAccountId(option.wxid)
         const cached = accountsCache[option.wxid] || accountsCache[normalizedWxid]
 
+        let displayName = option.nickname || option.wxid
+        let avatarUrl = option.avatarUrl
+
         if (option.wxid === userProfile.wxid || normalizedWxid === userProfile.wxid) {
-          return {
-            ...option,
-            displayName: userProfile.displayName,
-            avatarUrl: userProfile.avatarUrl
-          }
+          displayName = userProfile.displayName || displayName
+          avatarUrl = userProfile.avatarUrl || avatarUrl
         }
-        if (cached) {
-          console.log('[切换账号] 使用缓存:', option.wxid, cached)
-          return {
-            ...option,
-            displayName: cached.displayName,
-            avatarUrl: cached.avatarUrl
-          }
+
+        else if (cached) {
+          displayName = cached.displayName || displayName
+          avatarUrl = cached.avatarUrl || avatarUrl
+        }
+
+        return {
+          ...option,
+          displayName,
+          avatarUrl
         }
-        return { ...option, displayName: option.wxid }
       })
 
       setWxidOptions(enrichedWxids)
@@ -553,11 +557,17 @@ function Sidebar({ collapsed }: SidebarProps) {
                   type="button"
                 >
                   <div className="wxid-avatar">
-                    {option.avatarUrl ? <img src={option.avatarUrl} alt="" /> : <span>{getAvatarLetter(option.displayName || option.wxid)}</span>}
+                    {option.avatarUrl ? (
+                        <img src={option.avatarUrl} alt="" />
+                    ) : (
+                        <div style={{ width: '100%', height: '100%', display: 'flex', alignItems: 'center', justifyContent: 'center', background: 'var(--bg-tertiary)', borderRadius: '6px', color: 'var(--text-tertiary)' }}>
+                          <UserRound size={16} />
+                        </div>
+                    )}
                   </div>
                   <div className="wxid-info">
-                    <div className="wxid-name">{option.displayName || option.wxid}</div>
-                    <div className="wxid-id">{option.wxid}</div>
+                    <div className="wxid-name">{option.displayName}</div>
+                    {option.displayName !== option.wxid && <div className="wxid-id">{option.wxid}</div>}
                   </div>
                   {userProfile.wxid === option.wxid && <span className="current-badge">当前</span>}
                 </button>

src/components/Sns/SnsPostItem.tsx

@@ -1,7 +1,7 @@
 import React, { useState, useMemo, useEffect } from 'react'
 import { createPortal } from 'react-dom'
-import { Heart, ChevronRight, ImageIcon, Code, Trash2 } from 'lucide-react'
-import { SnsPost, SnsLinkCardData } from '../../types/sns'
+import { Heart, ChevronRight, ImageIcon, Code, Trash2, MapPin } from 'lucide-react'
+import { SnsPost, SnsLinkCardData, SnsLocation } from '../../types/sns'
 import { Avatar } from '../Avatar'
 import { SnsMediaGrid } from './SnsMediaGrid'
 import { getEmojiPath } from 'wechat-emojis'
@@ -134,6 +134,30 @@ const buildLinkCardData = (post: SnsPost): SnsLinkCardData | null => {
     }
 }
 
+const buildLocationText = (location?: SnsLocation): string => {
+    if (!location) return ''
+
+    const normalize = (value?: string): string => (
+        decodeHtmlEntities(String(value || '')).replace(/\s+/g, ' ').trim()
+    )
+
+    const primary = [
+        normalize(location.poiName),
+        normalize(location.poiAddressName),
+        normalize(location.label),
+        normalize(location.poiAddress)
+    ].find(Boolean) || ''
+
+    const region = [normalize(location.country), normalize(location.city)]
+        .filter(Boolean)
+        .join(' ')
+
+    if (primary && region && !primary.includes(region)) {
+        return `${primary} · ${region}`
+    }
+    return primary || region
+}
+
 const SnsLinkCard = ({ card }: { card: SnsLinkCardData }) => {
     const [thumbFailed, setThumbFailed] = useState(false)
     const hostname = useMemo(() => {
@@ -254,6 +278,7 @@ export const SnsPostItem: React.FC<SnsPostItemProps> = ({ post, onPreview, onDeb
     const [deleting, setDeleting] = useState(false)
     const [showDeleteConfirm, setShowDeleteConfirm] = useState(false)
     const linkCard = buildLinkCardData(post)
+    const locationText = useMemo(() => buildLocationText(post.location), [post.location])
     const hasVideoMedia = post.type === 15 || post.media.some((item) => isSnsVideoUrl(item.url))
     const showLinkCard = Boolean(linkCard) && post.media.length <= 1 && !hasVideoMedia
     const showMediaGrid = post.media.length > 0 && !showLinkCard
@@ -379,6 +404,13 @@ export const SnsPostItem: React.FC<SnsPostItemProps> = ({ post, onPreview, onDeb
                     <div className="post-text">{renderTextWithEmoji(decodeHtmlEntities(post.contentDesc))}</div>
                 )}
 
+                {locationText && (
+                    <div className="post-location" title={locationText}>
+                        <MapPin size={14} />
+                        <span className="post-location-text">{locationText}</span>
+                    </div>
+                )}
+
                 {showLinkCard && linkCard && (
                     <SnsLinkCard card={linkCard} />
                 )}

src/components/UpdateDialog.scss

@@ -282,4 +282,13 @@
         transform: translateY(0);
         opacity: 1;
     }
-}
+}
+.mandatory-tip {
+    color: #e53e3e;
+    font-size: 13px;
+    text-align: center;
+    margin: 0 0 8px;
+    padding: 6px 12px;
+    background: rgba(229, 62, 62, 0.08);
+    border-radius: 6px;
+}

src/components/UpdateDialog.tsx

@@ -14,6 +14,7 @@ interface UpdateDialogProps {
     onUpdate: () => void
     onIgnore?: () => void
     isDownloading: boolean
+    isMandatory?: boolean
     progress: number | {
         percent: number
         bytesPerSecond?: number
@@ -30,6 +31,7 @@ const UpdateDialog: React.FC<UpdateDialogProps> = ({
     onUpdate,
     onIgnore,
     isDownloading,
+    isMandatory,
     progress
 }) => {
     if (!open || !updateInfo) return null
@@ -69,7 +71,7 @@ const UpdateDialog: React.FC<UpdateDialogProps> = ({
     return (
         <div className="update-dialog-overlay">
             <div className="update-dialog">
-                {!isDownloading && (
+                {!isDownloading && !isMandatory && (
                     <button className="close-btn" onClick={onClose}>
                         <X size={20} />
                     </button>
@@ -119,11 +121,14 @@ const UpdateDialog: React.FC<UpdateDialogProps> = ({
                         </div>
                     ) : (
                         <div className="actions">
-                            {onIgnore && (
+                            {onIgnore && !isMandatory && (
                                 <button className="btn-ignore" onClick={onIgnore}>
                                     忽略本次更新
                                 </button>
                             )}
+                            {isMandatory && (
+                                <p className="mandatory-tip">此版本存在安全风险，必须更新后才能继续使用</p>
+                            )}
                             <button className="btn-update" onClick={onUpdate}>
                                 开启新旅程
                             </button>

src/components/WindowCloseDialog.scss

@@ -0,0 +1,306 @@
+.window-close-dialog-overlay {
+  position: fixed;
+  inset: 0;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 32px;
+  background:
+    radial-gradient(circle at top, rgba(36, 42, 54, 0.18), transparent 48%),
+    rgba(7, 10, 18, 0.56);
+  backdrop-filter: blur(10px);
+  z-index: 3000;
+  animation: windowCloseDialogFadeIn 0.2s ease-out;
+}
+
+.window-close-dialog {
+  width: min(560px, 100%);
+  border: 1px solid color-mix(in srgb, var(--border-color) 78%, transparent);
+  border-radius: 24px;
+  background:
+    linear-gradient(180deg, color-mix(in srgb, var(--bg-primary) 94%, white 6%) 0%, var(--bg-primary) 100%);
+  box-shadow: 0 28px 80px rgba(0, 0, 0, 0.32);
+  overflow: hidden;
+  position: relative;
+  animation: windowCloseDialogSlideUp 0.24s cubic-bezier(0.16, 1, 0.3, 1);
+}
+
+.window-close-dialog-header {
+  padding: 28px 30px 18px;
+  border-bottom: 1px solid color-mix(in srgb, var(--border-color) 72%, transparent);
+
+  .window-close-dialog-kicker {
+    display: inline-flex;
+    align-items: center;
+    padding: 6px 10px;
+    border-radius: 999px;
+    background: color-mix(in srgb, var(--primary) 12%, transparent);
+    color: var(--primary);
+    font-size: 12px;
+    font-weight: 700;
+    letter-spacing: 0.08em;
+    text-transform: uppercase;
+  }
+
+  h2 {
+    margin: 14px 0 8px;
+    font-size: 26px;
+    line-height: 1.1;
+    color: var(--text-primary);
+  }
+
+  p {
+    margin: 0;
+    font-size: 14px;
+    line-height: 1.7;
+    color: var(--text-secondary);
+  }
+}
+
+.window-close-dialog-body {
+  padding: 20px 24px 10px;
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
+}
+
+.window-close-dialog-option {
+  width: 100%;
+  display: flex;
+  align-items: flex-start;
+  gap: 14px;
+  padding: 18px 18px 18px 16px;
+  border: 1px solid color-mix(in srgb, var(--border-color) 72%, transparent);
+  border-radius: 18px;
+  background:
+    linear-gradient(180deg, color-mix(in srgb, var(--bg-secondary) 86%, white 14%) 0%, var(--bg-secondary) 100%);
+  color: inherit;
+  cursor: pointer;
+  text-align: left;
+  transition:
+    transform 0.18s ease,
+    border-color 0.18s ease,
+    box-shadow 0.18s ease,
+    background 0.18s ease;
+
+  &:hover {
+    transform: translateY(-1px);
+    border-color: color-mix(in srgb, var(--primary) 34%, var(--border-color));
+    box-shadow: 0 14px 28px rgba(0, 0, 0, 0.1);
+  }
+
+  &:active {
+    transform: translateY(0);
+  }
+
+  &.is-danger:hover {
+    border-color: rgba(205, 73, 73, 0.42);
+  }
+}
+
+.window-close-dialog-option-icon {
+  width: 42px;
+  height: 42px;
+  flex: 0 0 42px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  border-radius: 14px;
+  background: color-mix(in srgb, var(--primary) 14%, transparent);
+  color: var(--primary);
+}
+
+.window-close-dialog-option.is-danger .window-close-dialog-option-icon {
+  background: rgba(205, 73, 73, 0.12);
+  color: #cd4949;
+}
+
+.window-close-dialog-option-text {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+  min-width: 0;
+
+  strong {
+    font-size: 16px;
+    font-weight: 700;
+    color: var(--text-primary);
+  }
+
+  span {
+    font-size: 13px;
+    line-height: 1.6;
+    color: var(--text-secondary);
+  }
+}
+
+.window-close-dialog-actions {
+  padding: 8px 24px 24px;
+  display: flex;
+  justify-content: flex-end;
+}
+
+.window-close-dialog-remember {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  margin: 4px 24px 0;
+  padding: 12px 14px;
+  border: 1px solid color-mix(in srgb, var(--border-color) 72%, transparent);
+  border-radius: 16px;
+  background: color-mix(in srgb, var(--bg-secondary) 76%, transparent);
+  cursor: pointer;
+  user-select: none;
+
+  input {
+    position: absolute;
+    opacity: 0;
+    pointer-events: none;
+  }
+}
+
+.window-close-dialog-checkbox {
+  width: 18px;
+  height: 18px;
+  flex: 0 0 18px;
+  border: 1.5px solid color-mix(in srgb, var(--border-color) 88%, transparent);
+  border-radius: 6px;
+  background: var(--bg-primary);
+  position: relative;
+  transition:
+    border-color 0.18s ease,
+    background 0.18s ease,
+    box-shadow 0.18s ease;
+
+  &::after {
+    content: '';
+    position: absolute;
+    left: 5px;
+    top: 1px;
+    width: 5px;
+    height: 10px;
+    border: solid white;
+    border-width: 0 2px 2px 0;
+    transform: rotate(45deg) scale(0.7);
+    opacity: 0;
+    transition:
+      opacity 0.18s ease,
+      transform 0.18s ease;
+  }
+}
+
+.window-close-dialog-remember input:checked + .window-close-dialog-checkbox {
+  background: var(--primary);
+  border-color: var(--primary);
+  box-shadow: 0 0 0 3px color-mix(in srgb, var(--primary) 16%, transparent);
+}
+
+.window-close-dialog-remember input:checked + .window-close-dialog-checkbox::after {
+  opacity: 1;
+  transform: rotate(45deg) scale(1);
+}
+
+.window-close-dialog-remember-text {
+  font-size: 13px;
+  line-height: 1.5;
+  color: var(--text-secondary);
+}
+
+.window-close-dialog-cancel {
+  min-width: 112px;
+  padding: 12px 18px;
+  border: 1px solid color-mix(in srgb, var(--border-color) 76%, transparent);
+  border-radius: 999px;
+  background: var(--bg-tertiary);
+  color: var(--text-secondary);
+  cursor: pointer;
+  transition:
+    background 0.18s ease,
+    color 0.18s ease,
+    border-color 0.18s ease;
+
+  &:hover {
+    background: var(--bg-hover);
+    color: var(--text-primary);
+    border-color: color-mix(in srgb, var(--primary) 24%, var(--border-color));
+  }
+}
+
+.window-close-dialog-close {
+  position: absolute;
+  top: 18px;
+  right: 18px;
+  width: 34px;
+  height: 34px;
+  border: none;
+  border-radius: 999px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  background: color-mix(in srgb, var(--bg-secondary) 84%, transparent);
+  color: var(--text-secondary);
+  cursor: pointer;
+  transition:
+    background 0.18s ease,
+    color 0.18s ease,
+    transform 0.18s ease;
+
+  &:hover {
+    background: var(--bg-hover);
+    color: var(--text-primary);
+    transform: rotate(90deg);
+  }
+}
+
+@media (max-width: 640px) {
+  .window-close-dialog-overlay {
+    padding: 16px;
+    align-items: flex-end;
+  }
+
+  .window-close-dialog {
+    border-radius: 24px 24px 18px 18px;
+  }
+
+  .window-close-dialog-header {
+    padding: 24px 22px 16px;
+
+    h2 {
+      font-size: 22px;
+    }
+  }
+
+  .window-close-dialog-body {
+    padding: 18px 18px 10px;
+  }
+
+  .window-close-dialog-actions {
+    padding: 8px 18px 18px;
+  }
+
+  .window-close-dialog-cancel {
+    width: 100%;
+  }
+}
+
+@keyframes windowCloseDialogFadeIn {
+  from {
+    opacity: 0;
+  }
+
+  to {
+    opacity: 1;
+  }
+}
+
+@keyframes windowCloseDialogSlideUp {
+  from {
+    transform: translateY(24px) scale(0.98);
+    opacity: 0;
+  }
+
+  to {
+    transform: translateY(0) scale(1);
+    opacity: 1;
+  }
+}

src/components/WindowCloseDialog.tsx

@@ -0,0 +1,115 @@
+import { Minimize2, Power, X } from 'lucide-react'
+import { useEffect, useState } from 'react'
+import './WindowCloseDialog.scss'
+
+interface WindowCloseDialogProps {
+  open: boolean
+  canMinimizeToTray: boolean
+  onSelect: (action: 'tray' | 'quit', rememberChoice: boolean) => void
+  onCancel: () => void
+}
+
+export default function WindowCloseDialog({
+  open,
+  canMinimizeToTray,
+  onSelect,
+  onCancel
+}: WindowCloseDialogProps) {
+  const [rememberChoice, setRememberChoice] = useState(false)
+
+  useEffect(() => {
+    if (!open) return
+    setRememberChoice(false)
+
+    const handleKeyDown = (event: KeyboardEvent) => {
+      if (event.key === 'Escape') {
+        event.preventDefault()
+        onCancel()
+      }
+    }
+
+    window.addEventListener('keydown', handleKeyDown)
+    return () => window.removeEventListener('keydown', handleKeyDown)
+  }, [open, onCancel])
+
+  if (!open) return null
+
+  return (
+    <div className="window-close-dialog-overlay" onClick={onCancel}>
+      <div
+        className="window-close-dialog"
+        onClick={(event) => event.stopPropagation()}
+        role="dialog"
+        aria-modal="true"
+        aria-labelledby="window-close-dialog-title"
+      >
+        <button
+          type="button"
+          className="window-close-dialog-close"
+          onClick={onCancel}
+          aria-label="关闭提示"
+        >
+          <X size={18} />
+        </button>
+
+        <div className="window-close-dialog-header">
+          <span className="window-close-dialog-kicker">退出行为</span>
+          <h2 id="window-close-dialog-title">关闭 WeFlow</h2>
+          <p>
+            {canMinimizeToTray
+              ? '你可以保留后台进程与本地 API，或者直接完全退出应用。'
+              : '当前系统托盘不可用，本次只能完全退出应用。'}
+          </p>
+        </div>
+
+        <div className="window-close-dialog-body">
+          {canMinimizeToTray && (
+            <button
+              type="button"
+              className="window-close-dialog-option"
+              onClick={() => onSelect('tray', rememberChoice)}
+            >
+              <span className="window-close-dialog-option-icon">
+                <Minimize2 size={18} />
+              </span>
+              <span className="window-close-dialog-option-text">
+                <strong>最小化到系统托盘</strong>
+                <span>继续保留后台进程和本地 API，稍后可从托盘恢复。</span>
+              </span>
+            </button>
+          )}
+
+          <button
+            type="button"
+            className="window-close-dialog-option is-danger"
+            onClick={() => onSelect('quit', rememberChoice)}
+          >
+            <span className="window-close-dialog-option-icon">
+              <Power size={18} />
+            </span>
+            <span className="window-close-dialog-option-text">
+              <strong>完全关闭</strong>
+              <span>结束 WeFlow 进程，并停止当前保留的本地 API。</span>
+            </span>
+          </button>
+        </div>
+
+        <label className="window-close-dialog-remember">
+          <input
+            type="checkbox"
+            checked={rememberChoice}
+            onChange={(event) => setRememberChoice(event.target.checked)}
+          />
+          <span className="window-close-dialog-checkbox" aria-hidden="true" />
+          <span className="window-close-dialog-remember-text">下次不再提示，直接按本次选择处理</span>
+        </label>
+
+        <div className="window-close-dialog-actions">
+          <button type="button" className="window-close-dialog-cancel" onClick={onCancel}>
+            取消
+          </button>
+        </div>
+      </div>
+    </div>
+  )
+}

src/pages/AnnualReportWindow.tsx

@@ -8,44 +8,9 @@ import {
   registerBackgroundTask,
   updateBackgroundTask
 } from '../services/backgroundTaskMonitor'
+import { drawPatternBackground } from '../utils/reportExport'
 import './AnnualReportWindow.scss'
 
-// SVG 背景图案 (用于导出)
-const PATTERN_LIGHT_SVG = `<svg xmlns='http://www.w3.org/2000/svg' width='400' height='400' viewBox='0 0 400 400'><defs><style>.a{fill:none;stroke:#000;stroke-width:1.2;opacity:0.045}.b{fill:none;stroke:#000;stroke-width:1;opacity:0.035}.c{fill:none;stroke:#000;stroke-width:0.8;opacity:0.04}</style></defs><g transform='translate(45,35) rotate(-8)'><circle class='a' cx='0' cy='0' r='16'/><circle class='a' cx='-5' cy='-4' r='2.5'/><circle class='a' cx='5' cy='-4' r='2.5'/><path class='a' d='M-8 4 Q0 12 8 4'/></g><g transform='translate(320,28) rotate(15) scale(0.7)'><path class='b' d='M0 -12 l3 9 9 0 -7 5 3 9 -8 -6 -8 6 3 -9 -7 -5 9 0z'/></g><g transform='translate(180,55) rotate(12)'><path class='a' d='M0 -8 C0 -14 8 -17 12 -10 C16 -17 24 -14 24 -8 C24 4 12 14 12 14 C12 14 0 4 0 -8'/></g><g transform='translate(95,120) rotate(-5) scale(1.1)'><path class='b' d='M0 10 Q-8 10 -8 3 Q-8 -4 0 -4 Q0 -12 10 -12 Q22 -12 22 -2 Q30 -2 30 5 Q30 12 22 12 Z'/></g><g transform='translate(355,95) rotate(8)'><path class='c' d='M0 0 L0 18 M0 0 L18 -4 L18 14'/><ellipse class='c' cx='-4' cy='20' rx='6' ry='4'/><ellipse class='c' cx='14' cy='16' rx='6' ry='4'/></g><g transform='translate(250,110) rotate(-12) scale(0.9)'><rect class='b' x='0' y='0' width='26' height='18' rx='2'/><path class='b' d='M0 2 L13 11 L26 2'/></g><g transform='translate(28,195) rotate(6)'><circle class='a' cx='0' cy='0' r='11'/><path class='a' d='M-5 11 L5 11 M-4 14 L4 14'/><path class='c' d='M-3 -2 L0 -6 L3 -2'/></g><g transform='translate(155,175) rotate(-3) scale(0.85)'><path class='b' d='M0 0 L0 28 Q14 22 28 28 L28 0 Q14 6 0 0'/><path class='b' d='M28 0 L28 28 Q42 22 56 28 L56 0 Q42 6 28 0'/></g><g transform='translate(340,185) rotate(-20) scale(1.2)'><path class='a' d='M0 8 L20 0 L5 6 L8 14 L5 6 L-12 12 Z'/></g><g transform='translate(70,280) rotate(5)'><rect class='b' x='0' y='5' width='30' height='22' rx='4'/><circle class='b' cx='15' cy='16' r='7'/><rect class='b' x='8' y='0' width='14' height='6' rx='2'/></g><g transform='translate(230,250) rotate(-8) scale(1.1)'><rect class='a' x='0' y='6' width='22' height='18' rx='2'/><rect class='a' x='-3' y='0' width='28' height='7' rx='2'/><path class='a' d='M11 0 L11 24 M-3 13 L25 13'/></g><g transform='translate(365,280) rotate(10)'><ellipse class='b' cx='0' cy='0' rx='10' ry='14'/><path class='b' d='M0 14 Q-3 20 0 28 Q2 24 -1 20'/></g><g transform='translate(145,310) rotate(-6)'><path class='c' d='M0 0 L4 28 L24 28 L28 0 Z'/><path class='c' d='M28 6 Q40 6 40 16 Q40 24 28 24'/><path class='c' d='M8 8 Q10 4 12 8'/></g><g transform='translate(310,340) rotate(5) scale(0.9)'><path class='a' d='M0 8 L8 0 L24 0 L32 8 L16 28 Z'/><path class='a' d='M8 0 L12 8 L0 8 M24 0 L20 8 L32 8 M12 8 L16 28 L20 8'/></g><g transform='translate(55,365) rotate(25) scale(1.15)'><path class='a' d='M8 0 Q12 -14 16 0 L14 6 L18 12 L12 9 L6 12 L10 6 Z'/><circle class='c' cx='12' cy='-2' r='2'/></g><g transform='translate(200,375) rotate(-4)'><path class='b' d='M0 12 Q0 -8 24 -8 Q48 -8 48 12'/><path class='c' d='M6 12 Q6 -2 24 -2 Q42 -2 42 12'/><path class='c' d='M12 12 Q12 4 24 4 Q36 4 36 12'/></g><g transform='translate(380,375) rotate(-10)'><circle class='a' cx='0' cy='0' r='8'/><path class='c' d='M0 -14 L0 -10 M0 10 L0 14 M-14 0 L-10 0 M10 0 L14 0 M-10 -10 L-7 -7 M7 7 L10 10 M-10 10 L-7 7 M7 -7 L10 -10'/></g></svg>`
-
-const PATTERN_DARK_SVG = `<svg xmlns='http://www.w3.org/2000/svg' width='400' height='400' viewBox='0 0 400 400'><defs><style>.a{fill:none;stroke:#fff;stroke-width:1.2;opacity:0.055}.b{fill:none;stroke:#fff;stroke-width:1;opacity:0.045}.c{fill:none;stroke:#fff;stroke-width:0.8;opacity:0.05}</style></defs><g transform='translate(45,35) rotate(-8)'><circle class='a' cx='0' cy='0' r='16'/><circle class='a' cx='-5' cy='-4' r='2.5'/><circle class='a' cx='5' cy='-4' r='2.5'/><path class='a' d='M-8 4 Q0 12 8 4'/></g><g transform='translate(320,28) rotate(15) scale(0.7)'><path class='b' d='M0 -12 l3 9 9 0 -7 5 3 9 -8 -6 -8 6 3 -9 -7 -5 9 0z'/></g><g transform='translate(180,55) rotate(12)'><path class='a' d='M0 -8 C0 -14 8 -17 12 -10 C16 -17 24 -14 24 -8 C24 4 12 14 12 14 C12 14 0 4 0 -8'/></g><g transform='translate(95,120) rotate(-5) scale(1.1)'><path class='b' d='M0 10 Q-8 10 -8 3 Q-8 -4 0 -4 Q0 -12 10 -12 Q22 -12 22 -2 Q30 -2 30 5 Q30 12 22 12 Z'/></g><g transform='translate(355,95) rotate(8)'><path class='c' d='M0 0 L0 18 M0 0 L18 -4 L18 14'/><ellipse class='c' cx='-4' cy='20' rx='6' ry='4'/><ellipse class='c' cx='14' cy='16' rx='6' ry='4'/></g><g transform='translate(250,110) rotate(-12) scale(0.9)'><rect class='b' x='0' y='0' width='26' height='18' rx='2'/><path class='b' d='M0 2 L13 11 L26 2'/></g><g transform='translate(28,195) rotate(6)'><circle class='a' cx='0' cy='0' r='11'/><path class='a' d='M-5 11 L5 11 M-4 14 L4 14'/><path class='c' d='M-3 -2 L0 -6 L3 -2'/></g><g transform='translate(155,175) rotate(-3) scale(0.85)'><path class='b' d='M0 0 L0 28 Q14 22 28 28 L28 0 Q14 6 0 0'/><path class='b' d='M28 0 L28 28 Q42 22 56 28 L56 0 Q42 6 28 0'/></g><g transform='translate(340,185) rotate(-20) scale(1.2)'><path class='a' d='M0 8 L20 0 L5 6 L8 14 L5 6 L-12 12 Z'/></g><g transform='translate(70,280) rotate(5)'><rect class='b' x='0' y='5' width='30' height='22' rx='4'/><circle class='b' cx='15' cy='16' r='7'/><rect class='b' x='8' y='0' width='14' height='6' rx='2'/></g><g transform='translate(230,250) rotate(-8) scale(1.1)'><rect class='a' x='0' y='6' width='22' height='18' rx='2'/><rect class='a' x='-3' y='0' width='28' height='7' rx='2'/><path class='a' d='M11 0 L11 24 M-3 13 L25 13'/></g><g transform='translate(365,280) rotate(10)'><ellipse class='b' cx='0' cy='0' rx='10' ry='14'/><path class='b' d='M0 14 Q-3 20 0 28 Q2 24 -1 20'/></g><g transform='translate(145,310) rotate(-6)'><path class='c' d='M0 0 L4 28 L24 28 L28 0 Z'/><path class='c' d='M28 6 Q40 6 40 16 Q40 24 28 24'/><path class='c' d='M8 8 Q10 4 12 8'/></g><g transform='translate(310,340) rotate(5) scale(0.9)'><path class='a' d='M0 8 L8 0 L24 0 L32 8 L16 28 Z'/><path class='a' d='M8 0 L12 8 L0 8 M24 0 L20 8 L32 8 M12 8 L16 28 L20 8'/></g><g transform='translate(55,365) rotate(25) scale(1.15)'><path class='a' d='M8 0 Q12 -14 16 0 L14 6 L18 12 L12 9 L6 12 L10 6 Z'/><circle class='c' cx='12' cy='-2' r='2'/></g><g transform='translate(200,375) rotate(-4)'><path class='b' d='M0 12 Q0 -8 24 -8 Q48 -8 48 12'/><path class='c' d='M6 12 Q6 -2 24 -2 Q42 -2 42 12'/><path class='c' d='M12 12 Q12 4 24 4 Q36 4 36 12'/></g><g transform='translate(380,375) rotate(-10)'><circle class='a' cx='0' cy='0' r='8'/><path class='c' d='M0 -14 L0 -10 M0 10 L0 14 M-14 0 L-10 0 M10 0 L14 0 M-10 -10 L-7 -7 M7 7 L10 10 M-10 10 L-7 7 M7 -7 L10 -10'/></g></svg>`
-
-// 绘制 SVG 图案背景到 canvas
-const drawPatternBackground = async (ctx: CanvasRenderingContext2D, width: number, height: number, bgColor: string, isDark: boolean) => {
-  // 先填充背景色
-  ctx.fillStyle = bgColor
-  ctx.fillRect(0, 0, width, height)
-
-  // 加载 SVG 图案
-  const svgString = isDark ? PATTERN_DARK_SVG : PATTERN_LIGHT_SVG
-  const blob = new Blob([svgString], { type: 'image/svg+xml' })
-  const url = URL.createObjectURL(blob)
-
-  return new Promise<void>((resolve) => {
-    const img = new window.Image()
-    img.onload = () => {
-      // 平铺绘制图案
-      const pattern = ctx.createPattern(img, 'repeat')
-      if (pattern) {
-        ctx.fillStyle = pattern
-        ctx.fillRect(0, 0, width, height)
-      }
-      URL.revokeObjectURL(url)
-      resolve()
-    }
-    img.onerror = () => {
-      URL.revokeObjectURL(url)
-      resolve()
-    }
-    img.src = url
-  })
-}
-
 interface TopContact {
   username: string
   displayName: string

src/pages/BizPage.scss

@@ -0,0 +1,360 @@
+.biz-account-list {
+  flex: 1;
+  overflow-y: auto;
+  background-color: var(--bg-secondary); // 对齐会话列表背景
+
+  .biz-loading {
+    padding: 20px;
+    text-align: center;
+    font-size: 12px;
+    color: var(--text-tertiary);
+  }
+
+  .biz-account-item {
+    display: flex;
+    align-items: center;
+    gap: 12px;
+    padding: 12px 16px;
+    cursor: pointer;
+    transition: all 0.2s;
+    border-bottom: 1px solid var(--border-color);
+
+    &:hover {
+      background-color: var(--bg-hover);
+    }
+
+    &.active {
+      background-color: var(--primary-light) !important;
+      border-left: 3px solid var(--primary);
+      padding-left: 13px; // 补偿 border-left
+    }
+
+    &.pay-account {
+      background-color: var(--bg-primary);
+      &.active { 
+        background-color: var(--primary-light) !important;
+        border-left: 3px solid var(--primary);
+      }
+    }
+
+    .biz-avatar {
+      width: 48px;
+      height: 48px;
+      border-radius: 8px; // 对齐会话列表头像圆角
+      object-fit: cover;
+      flex-shrink: 0;
+      background-color: var(--bg-tertiary);
+    }
+
+    .biz-info {
+      flex: 1;
+      min-width: 0;
+      display: flex;
+      flex-direction: column;
+      gap: 2px;
+
+      .biz-info-top {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+
+        .biz-name {
+          font-size: 14px;
+          font-weight: 500;
+          color: var(--text-primary);
+          white-space: nowrap;
+          overflow: hidden;
+          text-overflow: ellipsis;
+        }
+
+        .biz-time {
+          font-size: 11px;
+          color: var(--text-tertiary);
+          flex-shrink: 0;
+        }
+      }
+
+      .biz-badge {
+        font-size: 10px;
+        padding: 1px 6px;
+        border-radius: 4px;
+        width: fit-content;
+        margin-top: 2px;
+
+        &.type-service { color: #07c160; background: rgba(7, 193, 96, 0.1); }
+        &.type-sub { color: var(--primary); background: var(--primary-light); }
+        &.type-enterprise { color: #f5222d; background: rgba(245, 34, 45, 0.1); }
+        &.type-unknown { color: var(--text-tertiary); background: var(--bg-tertiary); }
+      }
+    }
+  }
+}
+
+.biz-main {
+  height: 100%;
+  display: flex;
+  flex-direction: column;
+  background-color: var(--bg-secondary); // 对齐聊天页背景
+
+  .main-header {
+    height: 56px;
+    padding: 0 20px;
+    display: flex;
+    align-items: center;
+    border-bottom: 1px solid var(--border-color);
+    background-color: var(--card-bg);
+    flex-shrink: 0;
+
+    h2 {
+      font-size: 16px;
+      font-weight: 600;
+      color: var(--text-primary);
+    }
+  }
+
+  .message-container {
+    flex: 1;
+    overflow-y: auto;
+    padding: 24px 16px;
+    background: var(--chat-pattern);
+    background-color: var(--bg-tertiary); // 对齐聊天背景色
+
+    .messages-wrapper {
+      width: 100%;
+      max-width: 600px;
+      margin: 0 auto;
+      display: flex;
+      flex-direction: column;
+      gap: 16px; // 减小间距，因为有了 time-divider
+    }
+  }
+
+  .time-divider {
+    text-align: center;
+    margin: 16px 0 8px;
+    
+    span {
+      display: inline-block;
+      padding: 2px 8px;
+      background-color: var(--bg-primary);
+      color: var(--text-tertiary);
+      font-size: 11px;
+      border-radius: 4px;
+      opacity: 0.8;
+    }
+  }
+
+  // 占位状态：对齐 Chat 页面风格
+  .biz-no-record-container {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    padding: 60px 20px;
+    text-align: center;
+    background: var(--bg-tertiary);
+
+    .no-record-icon {
+      width: 64px;
+      height: 64px;
+      border-radius: 50%;
+      background-color: var(--bg-secondary);
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      margin-bottom: 20px;
+      color: var(--text-tertiary);
+      opacity: 0.5;
+
+      svg { width: 32px; height: 32px; }
+    }
+
+    h3 {
+      font-size: 16px;
+      font-weight: 500;
+      color: var(--text-primary);
+      margin-bottom: 8px;
+    }
+
+    p {
+      font-size: 13px;
+      color: var(--text-secondary);
+      max-width: 280px;
+      line-height: 1.5;
+    }
+  }
+
+  .biz-loading-more {
+    text-align: center;
+    padding: 20px;
+    font-size: 12px;
+    color: var(--text-tertiary);
+  }
+
+  .pay-card {
+    background-color: var(--card-bg);
+    border: 1px solid var(--border-color);
+    border-radius: 12px;
+    padding: 20px;
+    box-shadow: 0 2px 8px rgba(0,0,0,0.05);
+
+    .pay-header {
+      display: flex;
+      align-items: center;
+      gap: 8px;
+      font-size: 13px;
+      color: var(--text-tertiary);
+      margin-bottom: 20px;
+
+      .pay-icon {
+        width: 24px;
+        height: 24px;
+        border-radius: 50%;
+        object-fit: cover;
+      }
+      .pay-icon-placeholder {
+        width: 24px;
+        height: 24px;
+        border-radius: 50%;
+        background-color: #07c160;
+        color: white;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        font-size: 12px;
+      }
+    }
+
+    .pay-title {
+      text-align: center;
+      font-size: 22px;
+      font-weight: 500;
+      color: var(--text-primary);
+      margin-bottom: 24px;
+    }
+
+    .pay-desc {
+      font-size: 13px;
+      line-height: 1.6;
+      color: var(--text-secondary);
+      white-space: pre-wrap;
+    }
+
+    .pay-footer {
+      margin-top: 16px;
+      padding-top: 12px;
+      border-top: 1px solid var(--border-color);
+      font-size: 12px;
+      color: var(--text-tertiary);
+      text-align: right;
+    }
+  }
+
+  .article-card {
+    background-color: var(--card-bg);
+    border: 1px solid var(--border-color);
+    border-radius: 12px;
+    overflow: hidden;
+    box-shadow: 0 2px 8px rgba(0,0,0,0.05);
+
+    .main-article {
+      position: relative;
+      cursor: pointer;
+
+      .article-cover {
+        width: 100%;
+        height: 220px;
+        object-fit: cover;
+        background-color: var(--bg-tertiary);
+      }
+
+      .article-overlay {
+        position: absolute;
+        bottom: 0;
+        left: 0;
+        right: 0;
+        padding: 16px;
+        background: linear-gradient(transparent, rgba(0,0,0,0.8));
+
+        .article-title {
+          color: white;
+          font-size: 17px;
+          font-weight: 500;
+          line-height: 1.4;
+          display: -webkit-box;
+          -webkit-line-clamp: 2;
+          -webkit-box-orient: vertical;
+          overflow: hidden;
+        }
+      }
+    }
+
+    .article-digest {
+      padding: 12px 16px;
+      font-size: 14px;
+      color: var(--text-secondary);
+      border-bottom: 1px solid var(--border-color);
+    }
+
+    .sub-articles {
+      .sub-item {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        padding: 16px;
+        border-top: 1px solid var(--border-color);
+        cursor: pointer;
+        
+        &:hover { background-color: var(--bg-hover); }
+
+        .sub-title {
+          flex: 1;
+          font-size: 15px;
+          color: var(--text-primary);
+          padding-right: 12px;
+          display: -webkit-box;
+          -webkit-line-clamp: 2;
+          -webkit-box-orient: vertical;
+          overflow: hidden;
+        }
+
+        .sub-cover {
+          width: 48px;
+          height: 48px;
+          border-radius: 4px;
+          object-fit: cover;
+          flex-shrink: 0;
+          border: 1px solid var(--border-color);
+        }
+      }
+    }
+  }
+}
+
+.biz-empty-state {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  text-align: center;
+  height: 100%;
+  background: var(--bg-tertiary); // 对齐 Chat 页面空白背景
+
+  .empty-icon {
+    width: 80px;
+    height: 80px;
+    margin-bottom: 20px;
+    border-radius: 16px;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background-color: var(--bg-secondary);
+    color: var(--text-tertiary);
+
+    svg { width: 40px; height: 40px; }
+  }
+
+  p { color: var(--text-tertiary); font-size: 14px; }
+}

src/pages/BizPage.tsx

@@ -0,0 +1,336 @@
+import React, { useState, useEffect, useMemo, useRef } from 'react';
+import { useThemeStore } from '../stores/themeStore';
+import { Newspaper, MessageSquareOff } from 'lucide-react';
+import './BizPage.scss';
+
+export interface BizAccount {
+  username: string;
+  name: string;
+  avatar: string;
+  type: string;
+  last_time: number;
+  formatted_last_time: string;
+}
+
+export const BizAccountList: React.FC<{
+  onSelect: (account: BizAccount) => void;
+  selectedUsername?: string;
+  searchKeyword?: string;
+}> = ({ onSelect, selectedUsername, searchKeyword }) => {
+  const [accounts, setAccounts] = useState<BizAccount[]>([]);
+  const [loading, setLoading] = useState(false);
+
+  const [myWxid, setMyWxid] = useState<string>('');
+
+  useEffect(() => {
+    const initWxid = async () => {
+      try {
+        const wxid = await window.electronAPI.config.get('myWxid');
+        if (wxid) {
+          setMyWxid(wxid as string);
+        }
+      } catch (e) {
+        console.error("获取 myWxid 失败:", e);
+      }
+    };
+    initWxid().then(_r => { });
+  }, []);
+
+  useEffect(() => {
+    const fetch = async () => {
+      if (!myWxid) {
+        return;
+      }
+
+      setLoading(true);
+      try {
+        const res = await window.electronAPI.biz.listAccounts(myWxid)
+        setAccounts(res || []);
+      } catch (err) {
+        console.error('获取服务号列表失败:', err);
+      } finally {
+        setLoading(false);
+      }
+    };
+    fetch().then(_r => { } );
+  }, [myWxid]);
+
+
+  const filtered = useMemo(() => {
+    let result = accounts;
+    if (searchKeyword) {
+      const q = searchKeyword.toLowerCase();
+      result = accounts.filter(a =>
+          (a.name && a.name.toLowerCase().includes(q)) ||
+          (a.username && a.username.toLowerCase().includes(q))
+      );
+    }
+    return result.sort((a, b) => {
+      if (a.username === 'gh_3dfda90e39d6') return -1; // 微信支付置顶
+      if (b.username === 'gh_3dfda90e39d6') return 1;
+      return b.last_time - a.last_time;
+    });
+  }, [accounts, searchKeyword]);
+
+
+  if (loading) return <div className="biz-loading">加载中...</div>;
+
+  return (
+      <div className="biz-account-list">
+        {filtered.map(item => (
+            <div
+                key={item.username}
+                onClick={() => onSelect(item)}
+                className={`biz-account-item ${selectedUsername === item.username ? 'active' : ''} ${item.username === 'gh_3dfda90e39d6' ? 'pay-account' : ''}`}
+            >
+              <img
+                  src={item.avatar}
+                  className="biz-avatar"
+                  alt=""
+              />
+              <div className="biz-info">
+                <div className="biz-info-top">
+                  <span className="biz-name">{item.name || item.username}</span>
+                  <span className="biz-time">{item.formatted_last_time}</span>
+                </div>
+                {/*{item.username === 'gh_3dfda90e39d6' && (*/}
+                {/*    <div className="biz-badge type-service">微信支付</div>*/}
+                {/*)}*/}
+
+                <div className={`biz-badge ${
+                    item.type === '1' ? 'type-service' :
+                        item.type === '0' ? 'type-sub' :
+                            item.type === '2' ? 'type-enterprise' : 
+                                item.type === '3' ? 'type-enterprise' : 'type-unknown'
+                }`}>
+                  {item.type === '0' ? '公众号' : item.type === '1' ? '服务号' : item.type === '2' ? '企业号' : item.type === '3' ? '企业附属' :  '未知'}
+                </div>
+
+              </div>
+            </div>
+        ))}
+      </div>
+  );
+};
+
+export const BizMessageArea: React.FC<{
+  account: BizAccount | null;
+}> = ({ account }) => {
+  const themeMode = useThemeStore((state) => state.themeMode);
+  const [messages, setMessages] = useState<any[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [offset, setOffset] = useState(0);
+  const [hasMore, setHasMore] = useState(true);
+  const limit = 20;
+  const messageListRef = useRef<HTMLDivElement>(null);
+  const lastScrollHeightRef = useRef<number>(0);
+  const isInitialLoadRef = useRef<boolean>(true);
+
+  const [myWxid, setMyWxid] = useState<string>('');
+
+  useEffect(() => {
+    const initWxid = async () => {
+      try {
+        const wxid = await window.electronAPI.config.get('myWxid');
+        if (wxid) {
+          setMyWxid(wxid as string);
+        }
+      } catch (e) { }
+    };
+    initWxid();
+  }, []);
+
+  const isDark = useMemo(() => {
+    if (themeMode === 'dark') return true;
+    if (themeMode === 'system') {
+      return window.matchMedia('(prefers-color-scheme: dark)').matches;
+    }
+    return false;
+  }, [themeMode]);
+
+  useEffect(() => {
+    if (account && myWxid) {
+      setMessages([]);
+      setOffset(0);
+      setHasMore(true);
+      isInitialLoadRef.current = true;
+      loadMessages(account.username, 0);
+    }
+  }, [account, myWxid]);
+
+  const loadMessages = async (username: string, currentOffset: number) => {
+    if (loading || !myWxid) return;
+
+    setLoading(true);
+    if (messageListRef.current) {
+      lastScrollHeightRef.current = messageListRef.current.scrollHeight;
+    }
+
+    try {
+      let res;
+      if (username === 'gh_3dfda90e39d6') {
+        res = await window.electronAPI.biz.listPayRecords(myWxid, limit, currentOffset);
+      } else {
+        res = await window.electronAPI.biz.listMessages(username, myWxid, limit, currentOffset);
+      }
+
+      if (res) {
+        if (res.length < limit) setHasMore(false);
+
+        setMessages(prev => {
+          const combined = currentOffset === 0 ? res : [...res, ...prev];
+          const uniqueMessages = Array.from(new Map(combined.map(item => [item.local_id || item.create_time, item])).values());
+          return uniqueMessages.sort((a, b) => a.create_time - b.create_time);
+        });
+        setOffset(currentOffset + limit);
+      }
+    } catch (err) {
+      console.error('加载消息失败:', err);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  useEffect(() => {
+    if (!messageListRef.current) return;
+
+    if (isInitialLoadRef.current && messages.length > 0) {
+      messageListRef.current.scrollTop = messageListRef.current.scrollHeight;
+      isInitialLoadRef.current = false;
+    } else if (messages.length > 0 && !isInitialLoadRef.current && !loading) {
+
+      const newScrollHeight = messageListRef.current.scrollHeight;
+      const heightDiff = newScrollHeight - lastScrollHeightRef.current;
+      if (heightDiff > 0 && messageListRef.current.scrollTop < 100) {
+        messageListRef.current.scrollTop += heightDiff;
+      }
+    }
+  }, [messages, loading]);
+
+  const handleScroll = (e: React.UIEvent<HTMLDivElement>) => {
+    const target = e.currentTarget;
+    // 向上滚动到顶部附近触发加载更多（更旧的消息）
+    if (target.scrollTop < 50) {
+      if (!loading && hasMore && account) {
+        loadMessages(account.username, offset);
+      }
+    }
+  };
+
+  if (!account) {
+    return (
+        <div className="biz-empty-state">
+          <div className="empty-icon"><Newspaper size={40} /></div>
+          <p>请选择一个服务号查看消息</p>
+        </div>
+    );
+  }
+
+  const formatMessageTime = (timestamp: number) => {
+    if (!timestamp) return '';
+    const date = new Date(timestamp * 1000);
+    const now = new Date();
+    
+    const isToday = date.toDateString() === now.toDateString();
+    if (isToday) {
+      return date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit', hour12: false });
+    }
+    
+    const yesterday = new Date(now);
+    yesterday.setDate(now.getDate() - 1);
+    if (date.toDateString() === yesterday.toDateString()) {
+      return `昨天 ${date.getHours().toString().padStart(2, '0')}:${date.getMinutes().toString().padStart(2, '0')}`;
+    }
+
+    const isThisYear = date.getFullYear() === now.getFullYear();
+    if (isThisYear) {
+      return `${date.getMonth() + 1}月${date.getDate()}日 ${date.getHours().toString().padStart(2, '0')}:${date.getMinutes().toString().padStart(2, '0')}`;
+    }
+    
+    return `${date.getFullYear()}年${date.getMonth() + 1}月${date.getDate()}日`;
+  };
+
+  const defaultImage = 'data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSI0MDAiIGhlaWdodD0iMTgwIj48cmVjdCB3aWR0aD0iNDAwIiBoZWlnaHQ9IjE4MCIgZmlsbD0iI2Y1ZjVmNSIvPjwvc3ZnPg==';
+
+  return (
+      <div className={`biz-main ${isDark ? 'dark' : ''}`}>
+        <div className="main-header">
+          <h2>{account.name}</h2>
+        </div>
+        <div className="message-container" onScroll={handleScroll} ref={messageListRef}>
+          <div className="messages-wrapper">
+            {hasMore && messages.length > 0 && (
+                <div className="biz-loading-more">{loading ? '加载中...' : '向上滚动加载更多历史消息'}</div>
+            )}
+            {!loading && messages.length === 0 && (
+              <div className="biz-no-record-container">
+                <div className="no-record-icon">
+                  <MessageSquareOff size={48} />
+                </div>
+                <h3>暂无本地记录</h3>
+                <p>该公众号在当前数据库中没有可显示的聊天历史</p>
+              </div>
+            )}
+            {messages.map((msg, index) => {
+                const showTime = true;
+                
+                return (
+                    <div key={msg.local_id || index}>
+                      {showTime && (
+                          <div className="time-divider">
+                            <span>{formatMessageTime(msg.create_time)}</span>
+                          </div>
+                      )}
+                      
+                      {account.username === 'gh_3dfda90e39d6' ? (
+                          <div className="pay-card">
+                            <div className="pay-header">
+                              {msg.merchant_icon ? <img src={msg.merchant_icon} className="pay-icon" alt=""/> : <div className="pay-icon-placeholder">¥</div>}
+                              <span>{msg.merchant_name || '微信支付'}</span>
+                            </div>
+                            <div className="pay-title">{msg.title}</div>
+                            <div className="pay-desc">{msg.description}</div>
+                            {/* <div className="pay-footer">{msg.formatted_time}</div> */}
+                          </div>
+                      ) : (
+                          <div className="article-card">
+                            <div onClick={() => window.electronAPI.shell.openExternal(msg.url)} className="main-article">
+                              <img src={msg.cover || defaultImage} className="article-cover" alt=""/>
+                              <div className="article-overlay"><h3 className="article-title">{msg.title}</h3></div>
+                            </div>
+                            {msg.des && <div className="article-digest">{msg.des}</div>}
+                            {msg.content_list && msg.content_list.length > 1 && (
+                                <div className="sub-articles">
+                                  {msg.content_list.slice(1).map((item: any, idx: number) => (
+                                      <div key={idx} onClick={() => window.electronAPI.shell.openExternal(item.url)} className="sub-item">
+                                        <span className="sub-title">{item.title}</span>
+                                        {item.cover && <img src={item.cover} className="sub-cover" alt=""/>}
+                                      </div>
+                                  ))}
+                                </div>
+                            )}
+                          </div>
+                      )}
+                    </div>
+                );
+            })}
+            {loading && offset === 0 && <div className="biz-loading-more">加载中...</div>}
+          </div>
+        </div>
+      </div>
+  );
+};
+
+const BizPage: React.FC = () => {
+  const [selectedAccount, setSelectedAccount] = useState<BizAccount | null>(null);
+  return (
+      <div className="biz-page">
+        <div className="biz-sidebar">
+          <BizAccountList onSelect={setSelectedAccount} selectedUsername={selectedAccount?.username} />
+        </div>
+        <BizMessageArea account={selectedAccount} />
+      </div>
+  );
+}
+
+export default BizPage;

src/pages/ChatHistoryPage.scss

@@ -2,15 +2,16 @@
   display: flex;
   flex-direction: column;
   height: 100vh;
-  background: var(--bg-primary);
+  background:
+    linear-gradient(180deg, color-mix(in srgb, var(--bg-primary) 96%, white) 0%, var(--bg-primary) 100%);
 
   .history-list {
     flex: 1;
     overflow-y: auto;
-    padding: 16px;
+    padding: 18px 18px 28px;
     display: flex;
     flex-direction: column;
-    gap: 12px;
+    gap: 0;
 
     .status-msg {
       text-align: center;
@@ -30,8 +31,9 @@
 
   .history-item {
     display: flex;
-    gap: 12px;
+    gap: 14px;
     align-items: flex-start;
+    padding: 14px 0 0;
 
     &.error-item {
       padding: 12px;
@@ -43,65 +45,70 @@
       justify-content: center;
     }
 
-    .avatar {
-      width: 40px;
-      height: 40px;
-      border-radius: 4px;
+    .history-avatar {
+      width: 36px;
+      height: 36px;
+      border-radius: 8px;
       overflow: hidden;
       flex-shrink: 0;
-      background: var(--bg-tertiary);
+      border: none;
+      box-shadow: none;
+      background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+      display: flex;
+      align-items: center;
+      justify-content: center;
 
-      img {
+      .avatar-component.avatar-inner {
         width: 100%;
         height: 100%;
-        object-fit: cover;
-      }
+        border-radius: inherit;
+        background: transparent;
 
-      .avatar-placeholder {
-        width: 100%;
-        height: 100%;
-        display: flex;
-        align-items: center;
-        justify-content: center;
-        color: var(--text-tertiary);
-        font-size: 16px;
-        font-weight: 500;
-        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-        color: white;
+        img.avatar-image {
+          // Forwarded record head images may include a light matte edge.
+          // Slightly zoom in to crop that edge and align with normal chat avatars.
+          transform: scale(1.12);
+          transform-origin: center;
+        }
       }
     }
 
     .content-wrapper {
       flex: 1;
       min-width: 0;
+      padding-bottom: 18px;
+      border-bottom: 1px solid color-mix(in srgb, var(--border-color) 82%, transparent);
 
       .header {
         display: flex;
         justify-content: space-between;
-        align-items: center;
-        margin-bottom: 6px;
+        align-items: flex-start;
+        gap: 12px;
+        margin-bottom: 4px;
 
         .sender {
-          font-size: 14px;
-          font-weight: 500;
-          color: var(--text-primary);
+          font-size: 13px;
+          font-weight: 400;
+          color: color-mix(in srgb, var(--text-secondary) 82%, transparent);
+          line-height: 1.3;
         }
 
         .time {
           font-size: 12px;
-          color: var(--text-tertiary);
+          color: color-mix(in srgb, var(--text-tertiary) 92%, transparent);
           flex-shrink: 0;
           margin-left: 8px;
+          line-height: 1.3;
         }
       }
 
       .bubble {
-        background: var(--bg-secondary);
-        padding: 10px 14px;
-        border-radius: 18px 18px 18px 4px;
+        background: transparent;
+        padding: 0;
+        border-radius: 0;
         word-wrap: break-word;
         max-width: 100%;
-        display: inline-block;
+        display: block;
 
         &.image-bubble {
           padding: 0;
@@ -109,8 +116,8 @@
         }
 
         .text-content {
-          font-size: 14px;
-          line-height: 1.6;
+          font-size: 15px;
+          line-height: 1.7;
           color: var(--text-primary);
           white-space: pre-wrap;
           word-break: break-word;
@@ -118,23 +125,84 @@
 
         .media-content {
           img {
-            max-width: 100%;
-            max-height: 300px;
-            border-radius: 8px;
+            max-width: min(100%, 420px);
+            max-height: 320px;
+            border-radius: 12px;
             display: block;
+            box-shadow: 0 6px 20px rgba(0, 0, 0, 0.08);
+            background: color-mix(in srgb, var(--bg-secondary) 88%, transparent);
           }
 
           .media-tip {
-            padding: 8px 12px;
+            padding: 6px 0;
             color: var(--text-tertiary);
             font-size: 13px;
           }
         }
 
         .media-placeholder {
-          font-size: 14px;
+          font-size: 13px;
           color: var(--text-secondary);
-          padding: 4px 0;
+          padding: 4px 0 0;
+        }
+
+        .nested-chat-record-card {
+          min-width: 220px;
+          max-width: 320px;
+          background: color-mix(in srgb, var(--bg-secondary) 97%, #f5f7fb);
+          border: 1px solid var(--border-color);
+          border-radius: 14px;
+          overflow: hidden;
+          padding: 0;
+          text-align: left;
+          cursor: default;
+          box-shadow: 0 4px 16px rgba(0, 0, 0, 0.04);
+
+          &.clickable {
+            cursor: pointer;
+            transition: transform 0.15s ease, box-shadow 0.15s ease, border-color 0.15s ease;
+
+            &:hover {
+              transform: translateY(-1px);
+              box-shadow: 0 6px 18px rgba(0, 0, 0, 0.08);
+              border-color: color-mix(in srgb, var(--primary) 28%, var(--border-color));
+            }
+          }
+
+          &:disabled {
+            border: 1px solid var(--border-color);
+            opacity: 1;
+          }
+        }
+
+        .nested-chat-record-title {
+          padding: 13px 15px 9px;
+          font-size: 14px;
+          font-weight: 600;
+          color: var(--text-primary);
+        }
+
+        .nested-chat-record-list {
+          padding: 0 15px 11px;
+          display: flex;
+          flex-direction: column;
+          gap: 4px;
+          border-bottom: 1px solid var(--border-color);
+        }
+
+        .nested-chat-record-line {
+          font-size: 13px;
+          line-height: 1.45;
+          color: var(--text-secondary);
+          white-space: nowrap;
+          overflow: hidden;
+          text-overflow: ellipsis;
+        }
+
+        .nested-chat-record-footer {
+          padding: 8px 15px 11px;
+          font-size: 12px;
+          color: var(--text-tertiary);
         }
       }
     }

src/pages/ChatHistoryPage.tsx

@@ -3,10 +3,13 @@ import { useParams, useLocation } from 'react-router-dom'
 import { ChatRecordItem } from '../types/models'
 import TitleBar from '../components/TitleBar'
 import { ErrorBoundary } from '../components/ErrorBoundary'
+import { Avatar } from '../components/Avatar'
 import './ChatHistoryPage.scss'
 
+const forwardedImageCache = new Map<string, string>()
+
 export default function ChatHistoryPage() {
-  const params = useParams<{ sessionId: string; messageId: string }>()
+  const params = useParams<{ sessionId: string; messageId: string; payloadId: string }>()
   const location = useLocation()
   const [recordList, setRecordList] = useState<ChatRecordItem[]>([])
   const [loading, setLoading] = useState(true)
@@ -30,64 +33,212 @@ export default function ChatHistoryPage() {
       .replace(/&#39;/g, "'")
   }
 
+  const extractTopLevelXmlElements = (source: string, tagName: string): Array<{ attrs: string; inner: string }> => {
+    const xml = source || ''
+    if (!xml) return []
+
+    const pattern = new RegExp(`<(/?)${tagName}\\b([^>]*)>`, 'gi')
+    const result: Array<{ attrs: string; inner: string }> = []
+    let match: RegExpExecArray | null
+    let depth = 0
+    let openEnd = -1
+    let openStart = -1
+    let openAttrs = ''
+
+    while ((match = pattern.exec(xml)) !== null) {
+      const isClosing = match[1] === '/'
+      const attrs = match[2] || ''
+      const rawTag = match[0] || ''
+      const selfClosing = !isClosing && /\/\s*>$/.test(rawTag)
+
+      if (!isClosing) {
+        if (depth === 0) {
+          openStart = match.index
+          openEnd = pattern.lastIndex
+          openAttrs = attrs
+        }
+        if (!selfClosing) {
+          depth += 1
+        } else if (depth === 0 && openEnd >= 0) {
+          result.push({ attrs: openAttrs, inner: '' })
+          openStart = -1
+          openEnd = -1
+          openAttrs = ''
+        }
+        continue
+      }
+
+      if (depth <= 0) continue
+      depth -= 1
+      if (depth === 0 && openEnd >= 0 && openStart >= 0) {
+        result.push({
+          attrs: openAttrs,
+          inner: xml.slice(openEnd, match.index)
+        })
+        openStart = -1
+        openEnd = -1
+        openAttrs = ''
+      }
+    }
+
+    return result
+  }
+
+  const parseChatRecordDataItem = (body: string, attrs = ''): ChatRecordItem | null => {
+    const datatypeMatch = /datatype\s*=\s*["']?(\d+)["']?/i.exec(attrs || '')
+    const datatype = datatypeMatch ? parseInt(datatypeMatch[1], 10) : parseInt(extractXmlValue(body, 'datatype') || '0', 10)
+
+    const sourcename = decodeHtmlEntities(extractXmlValue(body, 'sourcename')) || ''
+    const sourcetime = extractXmlValue(body, 'sourcetime') || ''
+    const sourceheadurl = extractXmlValue(body, 'sourceheadurl') || undefined
+    const datadesc = decodeHtmlEntities(extractXmlValue(body, 'datadesc') || extractXmlValue(body, 'content')) || undefined
+    const datatitle = decodeHtmlEntities(extractXmlValue(body, 'datatitle')) || undefined
+    const fileext = extractXmlValue(body, 'fileext') || undefined
+    const datasize = parseInt(extractXmlValue(body, 'datasize') || '0', 10) || undefined
+    const messageuuid = extractXmlValue(body, 'messageuuid') || undefined
+
+    const dataurl = decodeHtmlEntities(extractXmlValue(body, 'dataurl')) || undefined
+    const datathumburl = decodeHtmlEntities(
+      extractXmlValue(body, 'datathumburl') ||
+      extractXmlValue(body, 'thumburl') ||
+      extractXmlValue(body, 'cdnthumburl')
+    ) || undefined
+    const datacdnurl = decodeHtmlEntities(
+      extractXmlValue(body, 'datacdnurl') ||
+      extractXmlValue(body, 'cdnurl') ||
+      extractXmlValue(body, 'cdndataurl')
+    ) || undefined
+    const cdndatakey = decodeHtmlEntities(extractXmlValue(body, 'cdndatakey')) || undefined
+    const cdnthumbkey = decodeHtmlEntities(extractXmlValue(body, 'cdnthumbkey')) || undefined
+    const aeskey = decodeHtmlEntities(extractXmlValue(body, 'aeskey') || extractXmlValue(body, 'qaeskey')) || undefined
+    const md5 = extractXmlValue(body, 'md5') || extractXmlValue(body, 'datamd5') || undefined
+    const fullmd5 = extractXmlValue(body, 'fullmd5') || undefined
+    const thumbfullmd5 = extractXmlValue(body, 'thumbfullmd5') || undefined
+    const srcMsgLocalid = parseInt(extractXmlValue(body, 'srcMsgLocalid') || '0', 10) || undefined
+    const imgheight = parseInt(extractXmlValue(body, 'imgheight') || '0', 10) || undefined
+    const imgwidth = parseInt(extractXmlValue(body, 'imgwidth') || '0', 10) || undefined
+    const duration = parseInt(extractXmlValue(body, 'duration') || '0', 10) || undefined
+    const nestedRecordXml = extractXmlValue(body, 'recordxml') || undefined
+    const chatRecordTitle = decodeHtmlEntities(
+      (nestedRecordXml && extractXmlValue(nestedRecordXml, 'title')) ||
+      datatitle ||
+      ''
+    ) || undefined
+    const chatRecordDesc = decodeHtmlEntities(
+      (nestedRecordXml && extractXmlValue(nestedRecordXml, 'desc')) ||
+      datadesc ||
+      ''
+    ) || undefined
+    const chatRecordList =
+      datatype === 17 && nestedRecordXml
+        ? parseChatRecordContainer(nestedRecordXml)
+        : undefined
+
+    if (!(datatype || sourcename || datadesc || datatitle || messageuuid || srcMsgLocalid)) return null
+
+    return {
+      datatype: Number.isFinite(datatype) ? datatype : 0,
+      sourcename,
+      sourcetime,
+      sourceheadurl,
+      datadesc,
+      datatitle,
+      fileext,
+      datasize,
+      messageuuid,
+      dataurl,
+      datathumburl,
+      datacdnurl,
+      cdndatakey,
+      cdnthumbkey,
+      aeskey,
+      md5,
+      fullmd5,
+      thumbfullmd5,
+      srcMsgLocalid,
+      imgheight,
+      imgwidth,
+      duration,
+      chatRecordTitle,
+      chatRecordDesc,
+      chatRecordList
+    }
+  }
+
+  const parseChatRecordContainer = (containerXml: string): ChatRecordItem[] => {
+    const source = containerXml || ''
+    if (!source) return []
+
+    const segments: string[] = [source]
+    const decodedContainer = decodeHtmlEntities(source)
+    if (decodedContainer && decodedContainer !== source) {
+      segments.push(decodedContainer)
+    }
+
+    const cdataRegex = /<!\[CDATA\[([\s\S]*?)\]\]>/g
+    let cdataMatch: RegExpExecArray | null
+    while ((cdataMatch = cdataRegex.exec(source)) !== null) {
+      const cdataInner = cdataMatch[1] || ''
+      if (!cdataInner) continue
+      segments.push(cdataInner)
+      const decodedInner = decodeHtmlEntities(cdataInner)
+      if (decodedInner && decodedInner !== cdataInner) {
+        segments.push(decodedInner)
+      }
+    }
+
+    const items: ChatRecordItem[] = []
+    const dedupe = new Set<string>()
+    for (const segment of segments) {
+      if (!segment) continue
+      const dataItems = extractTopLevelXmlElements(segment, 'dataitem')
+      for (const dataItem of dataItems) {
+        const item = parseChatRecordDataItem(dataItem.inner || '', dataItem.attrs || '')
+        if (!item) continue
+        const key = `${item.datatype}|${item.sourcename}|${item.sourcetime}|${item.datadesc || ''}|${item.datatitle || ''}|${item.messageuuid || ''}`
+        if (!dedupe.has(key)) {
+          dedupe.add(key)
+          items.push(item)
+        }
+      }
+    }
+
+    if (items.length > 0) return items
+    const fallback = parseChatRecordDataItem(source, '')
+    return fallback ? [fallback] : []
+  }
+
   // 前端兜底解析合并转发聊天记录
   const parseChatHistory = (content: string): ChatRecordItem[] | undefined => {
     try {
-      const type = extractXmlValue(content, 'type')
-      if (type !== '19') return undefined
+      const decodedContent = decodeHtmlEntities(content) || content
+      const type = extractXmlValue(decodedContent, 'type')
+      if (type !== '19' && !decodedContent.includes('<recorditem')) return undefined
 
-      const match = /<recorditem>[\s\S]*?<!\[CDATA\[([\s\S]*?)\]\]>[\s\S]*?<\/recorditem>/.exec(content)
-      if (!match) return undefined
-
-      const innerXml = match[1]
       const items: ChatRecordItem[] = []
-      const itemRegex = /<dataitem\s+(.*?)>([\s\S]*?)<\/dataitem>/g
-      let itemMatch: RegExpExecArray | null
+      const dedupe = new Set<string>()
+      const recordItemRegex = /<recorditem>([\s\S]*?)<\/recorditem>/gi
+      let recordItemMatch: RegExpExecArray | null
+      while ((recordItemMatch = recordItemRegex.exec(decodedContent)) !== null) {
+        const parsedItems = parseChatRecordContainer(recordItemMatch[1] || '')
+        for (const item of parsedItems) {
+          const key = `${item.datatype}|${item.sourcename}|${item.sourcetime}|${item.datadesc || ''}|${item.datatitle || ''}|${item.messageuuid || ''}`
+          if (!dedupe.has(key)) {
+            dedupe.add(key)
+            items.push(item)
+          }
+        }
+      }
 
-      while ((itemMatch = itemRegex.exec(innerXml)) !== null) {
-        const attrs = itemMatch[1]
-        const body = itemMatch[2]
-
-        const datatypeMatch = /datatype="(\d+)"/.exec(attrs)
-        const datatype = datatypeMatch ? parseInt(datatypeMatch[1]) : 0
-
-        const sourcename = extractXmlValue(body, 'sourcename')
-        const sourcetime = extractXmlValue(body, 'sourcetime')
-        const sourceheadurl = extractXmlValue(body, 'sourceheadurl')
-        const datadesc = extractXmlValue(body, 'datadesc')
-        const datatitle = extractXmlValue(body, 'datatitle')
-        const fileext = extractXmlValue(body, 'fileext')
-        const datasize = parseInt(extractXmlValue(body, 'datasize') || '0')
-        const messageuuid = extractXmlValue(body, 'messageuuid')
-
-        const dataurl = extractXmlValue(body, 'dataurl')
-        const datathumburl = extractXmlValue(body, 'datathumburl') || extractXmlValue(body, 'thumburl')
-        const datacdnurl = extractXmlValue(body, 'datacdnurl') || extractXmlValue(body, 'cdnurl')
-        const aeskey = extractXmlValue(body, 'aeskey') || extractXmlValue(body, 'qaeskey')
-        const md5 = extractXmlValue(body, 'md5') || extractXmlValue(body, 'datamd5')
-        const imgheight = parseInt(extractXmlValue(body, 'imgheight') || '0')
-        const imgwidth = parseInt(extractXmlValue(body, 'imgwidth') || '0')
-        const duration = parseInt(extractXmlValue(body, 'duration') || '0')
-
-        items.push({
-          datatype,
-          sourcename,
-          sourcetime,
-          sourceheadurl,
-          datadesc: decodeHtmlEntities(datadesc),
-          datatitle: decodeHtmlEntities(datatitle),
-          fileext,
-          datasize,
-          messageuuid,
-          dataurl: decodeHtmlEntities(dataurl),
-          datathumburl: decodeHtmlEntities(datathumburl),
-          datacdnurl: decodeHtmlEntities(datacdnurl),
-          aeskey: decodeHtmlEntities(aeskey),
-          md5,
-          imgheight,
-          imgwidth,
-          duration
-        })
+      if (items.length === 0 && decodedContent.includes('<dataitem')) {
+        const parsedItems = parseChatRecordContainer(decodedContent)
+        for (const item of parsedItems) {
+          const key = `${item.datatype}|${item.sourcename}|${item.sourcetime}|${item.datadesc || ''}|${item.datatitle || ''}|${item.messageuuid || ''}`
+          if (!dedupe.has(key)) {
+            dedupe.add(key)
+            items.push(item)
+          }
+        }
       }
 
       return items.length > 0 ? items : undefined
@@ -115,9 +266,34 @@ export default function ChatHistoryPage() {
     return { sid: '', mid: '' }
   }
 
+  const ids = getIds()
+  const payloadId = params.payloadId || (() => {
+    const match = /^\/chat-history-inline\/([^/]+)/.exec(location.pathname)
+    return match ? match[1] : ''
+  })()
+
   useEffect(() => {
     const loadData = async () => {
-      const { sid, mid } = getIds()
+      if (payloadId) {
+        try {
+          const result = await window.electronAPI.window.getChatHistoryPayload(payloadId)
+          if (result.success && result.payload) {
+            setRecordList(Array.isArray(result.payload.recordList) ? result.payload.recordList : [])
+            setTitle(result.payload.title || '聊天记录')
+            setError('')
+          } else {
+            setError(result.error || '聊天记录载荷不存在')
+          }
+        } catch (e) {
+          console.error(e)
+          setError('加载详情失败')
+        } finally {
+          setLoading(false)
+        }
+        return
+      }
+
+      const { sid, mid } = ids
       if (!sid || !mid) {
         setError('无效的聊天记录链接')
         setLoading(false)
@@ -153,7 +329,7 @@ export default function ChatHistoryPage() {
       }
     }
     loadData()
-  }, [params.sessionId, params.messageId, location.pathname])
+  }, [ids.mid, ids.sid, location.pathname, payloadId])
 
   return (
     <div className="chat-history-page">
@@ -168,7 +344,7 @@ export default function ChatHistoryPage() {
         ) : (
           recordList.map((item, i) => (
             <ErrorBoundary key={i} fallback={<div className="history-item error-item">消息解析失败</div>}>
-              <HistoryItem item={item} />
+              <HistoryItem item={item} sessionId={ids.sid} />
             </ErrorBoundary>
           ))
         )}
@@ -177,9 +353,198 @@ export default function ChatHistoryPage() {
   )
 }
 
-function HistoryItem({ item }: { item: ChatRecordItem }) {
-  const [imageError, setImageError] = useState(false)
-  
+function detectImageMimeFromBase64(base64: string): string {
+  try {
+    const head = window.atob(base64.slice(0, 48))
+    const bytes = new Uint8Array(head.length)
+    for (let i = 0; i < head.length; i++) {
+      bytes[i] = head.charCodeAt(i)
+    }
+    if (bytes[0] === 0x47 && bytes[1] === 0x49 && bytes[2] === 0x46) return 'image/gif'
+    if (bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4E && bytes[3] === 0x47) return 'image/png'
+    if (bytes[0] === 0xFF && bytes[1] === 0xD8 && bytes[2] === 0xFF) return 'image/jpeg'
+    if (
+      bytes[0] === 0x52 && bytes[1] === 0x49 && bytes[2] === 0x46 && bytes[3] === 0x46 &&
+      bytes[8] === 0x57 && bytes[9] === 0x45 && bytes[10] === 0x42 && bytes[11] === 0x50
+    ) {
+      return 'image/webp'
+    }
+  } catch { }
+  return 'image/jpeg'
+}
+
+function normalizeChatRecordText(value?: string): string {
+  return String(value || '')
+    .replace(/\u00a0/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+}
+
+function getChatRecordPreviewText(item: ChatRecordItem): string {
+  const text = normalizeChatRecordText(item.datadesc) || normalizeChatRecordText(item.datatitle)
+  if (item.datatype === 17) {
+    return normalizeChatRecordText(item.chatRecordTitle) || normalizeChatRecordText(item.datatitle) || '聊天记录'
+  }
+  if (item.datatype === 2 || item.datatype === 3) return '[图片]'
+  if (item.datatype === 43) return '[视频]'
+  if (item.datatype === 34) return '[语音]'
+  if (item.datatype === 47) return '[表情]'
+  return text || '[媒体消息]'
+}
+
+function ForwardedImage({ item, sessionId }: { item: ChatRecordItem; sessionId: string }) {
+  const cacheKey =
+    item.thumbfullmd5 ||
+    item.fullmd5 ||
+    item.md5 ||
+    item.messageuuid ||
+    item.datathumburl ||
+    item.datacdnurl ||
+    item.dataurl ||
+    `local:${item.srcMsgLocalid || 0}`
+  const [localPath, setLocalPath] = useState<string | undefined>(() => forwardedImageCache.get(cacheKey))
+  const [loading, setLoading] = useState(!forwardedImageCache.has(cacheKey))
+  const [error, setError] = useState(false)
+
+  useEffect(() => {
+    if (localPath || error) return
+
+    let cancelled = false
+    const candidateMd5s = Array.from(new Set([
+      item.thumbfullmd5,
+      item.fullmd5,
+      item.md5
+    ].filter(Boolean) as string[]))
+
+    const load = async () => {
+      setLoading(true)
+
+      for (const imageMd5 of candidateMd5s) {
+        const cached = await window.electronAPI.image.resolveCache({ imageMd5 })
+        if (cached.success && cached.localPath) {
+          if (!cancelled) {
+            forwardedImageCache.set(cacheKey, cached.localPath)
+            setLocalPath(cached.localPath)
+            setLoading(false)
+          }
+          return
+        }
+      }
+
+      for (const imageMd5 of candidateMd5s) {
+        const decrypted = await window.electronAPI.image.decrypt({ imageMd5 })
+        if (decrypted.success && decrypted.localPath) {
+          if (!cancelled) {
+            forwardedImageCache.set(cacheKey, decrypted.localPath)
+            setLocalPath(decrypted.localPath)
+            setLoading(false)
+          }
+          return
+        }
+      }
+
+      if (sessionId && item.srcMsgLocalid) {
+        const fallback = await window.electronAPI.chat.getImageData(sessionId, String(item.srcMsgLocalid))
+        if (fallback.success && fallback.data) {
+          const dataUrl = `data:${detectImageMimeFromBase64(fallback.data)};base64,${fallback.data}`
+          if (!cancelled) {
+            forwardedImageCache.set(cacheKey, dataUrl)
+            setLocalPath(dataUrl)
+            setLoading(false)
+          }
+          return
+        }
+      }
+
+      const remoteSrc = item.dataurl || item.datathumburl || item.datacdnurl
+      if (remoteSrc && /^https?:\/\//i.test(remoteSrc)) {
+        if (!cancelled) {
+          setLocalPath(remoteSrc)
+          setLoading(false)
+        }
+        return
+      }
+
+      if (!cancelled) {
+        setError(true)
+        setLoading(false)
+      }
+    }
+
+    load().catch(() => {
+      if (!cancelled) {
+        setError(true)
+        setLoading(false)
+      }
+    })
+
+    return () => {
+      cancelled = true
+    }
+  }, [cacheKey, error, item.dataurl, item.datacdnurl, item.datathumburl, item.fullmd5, item.md5, item.messageuuid, item.srcMsgLocalid, item.thumbfullmd5, localPath, sessionId])
+
+  if (localPath) {
+    return (
+      <div className="media-content">
+        <img src={localPath} alt="图片" referrerPolicy="no-referrer" />
+      </div>
+    )
+  }
+
+  if (loading) {
+    return <div className="media-tip">图片加载中...</div>
+  }
+
+  if (error) {
+    return <div className="media-tip">图片未索引到本地缓存</div>
+  }
+
+  return <div className="media-placeholder">[图片]</div>
+}
+
+function NestedChatRecordCard({ item, sessionId }: { item: ChatRecordItem; sessionId: string }) {
+  const previewItems = (item.chatRecordList || []).slice(0, 3)
+  const title = normalizeChatRecordText(item.chatRecordTitle) || normalizeChatRecordText(item.datatitle) || '聊天记录'
+  const description = normalizeChatRecordText(item.chatRecordDesc) || normalizeChatRecordText(item.datadesc)
+  const canOpen = Boolean(sessionId && item.chatRecordList && item.chatRecordList.length > 0)
+
+  const handleOpen = () => {
+    if (!canOpen) return
+    window.electronAPI.window.openChatHistoryPayloadWindow({
+      sessionId,
+      title,
+      recordList: item.chatRecordList || []
+    }).catch(() => { })
+  }
+
+  return (
+    <button
+      type="button"
+      className={`nested-chat-record-card${canOpen ? ' clickable' : ''}`}
+      onClick={handleOpen}
+      disabled={!canOpen}
+      title={canOpen ? '点击打开聊天记录' : undefined}
+    >
+      <div className="nested-chat-record-title">{title}</div>
+      {previewItems.length > 0 ? (
+        <div className="nested-chat-record-list">
+          {previewItems.map((previewItem, index) => (
+            <div key={`${previewItem.messageuuid || previewItem.srcMsgLocalid || index}`} className="nested-chat-record-line">
+              {getChatRecordPreviewText(previewItem)}
+            </div>
+          ))}
+        </div>
+      ) : description ? (
+        <div className="nested-chat-record-list">
+          <div className="nested-chat-record-line">{description}</div>
+        </div>
+      ) : null}
+      <div className="nested-chat-record-footer">聊天记录</div>
+    </button>
+  )
+}
+
+function HistoryItem({ item, sessionId }: { item: ChatRecordItem; sessionId: string }) {
   // sourcetime 在合并转发里有两种格式：
   // 1) 时间戳（秒） 2) 已格式化的字符串 "2026-01-21 09:56:46"
   let time = ''
@@ -191,31 +556,18 @@ function HistoryItem({ item }: { item: ChatRecordItem }) {
     }
   }
 
+  const senderDisplayName = item.sourcename ?? '未知发送者'
+
   const renderContent = () => {
     if (item.datatype === 1) {
       // 文本消息
       return <div className="text-content">{item.datadesc || ''}</div>
     }
-    if (item.datatype === 3) {
-      // 图片
-      const src = item.datathumburl || item.datacdnurl
-      if (src) {
-        return (
-          <div className="media-content">
-            {imageError ? (
-              <div className="media-tip">图片无法加载</div>
-            ) : (
-              <img 
-                src={src} 
-                alt="图片" 
-                referrerPolicy="no-referrer" 
-                onError={() => setImageError(true)} 
-              />
-            )}
-          </div>
-        )
-      }
-      return <div className="media-placeholder">[图片]</div>
+    if (item.datatype === 2 || item.datatype === 3) {
+      return <ForwardedImage item={item} sessionId={sessionId} />
+    }
+    if (item.datatype === 17) {
+      return <NestedChatRecordCard item={item} sessionId={sessionId} />
     }
     if (item.datatype === 43) {
       return <div className="media-placeholder">[视频] {item.datatitle}</div>
@@ -229,21 +581,20 @@ function HistoryItem({ item }: { item: ChatRecordItem }) {
 
   return (
     <div className="history-item">
-      <div className="avatar">
-        {item.sourceheadurl ? (
-          <img src={item.sourceheadurl} alt="" referrerPolicy="no-referrer" />
-        ) : (
-          <div className="avatar-placeholder">
-            {item.sourcename?.slice(0, 1)}
-          </div>
-        )}
+      <div className="history-avatar">
+        <Avatar
+          src={item.sourceheadurl}
+          name={senderDisplayName}
+          size={36}
+          className="avatar-inner"
+        />
       </div>
       <div className="content-wrapper">
         <div className="header">
-          <span className="sender">{item.sourcename || '未知发送者'}</span>
+          <span className="sender">{senderDisplayName}</span>
           <span className="time">{time}</span>
         </div>
-        <div className={`bubble ${item.datatype === 3 ? 'image-bubble' : ''}`}>
+        <div className={`bubble ${(item.datatype === 2 || item.datatype === 3) ? 'image-bubble' : ''}`}>
           {renderContent()}
         </div>
       </div>

src/pages/ChatPage.scss

@@ -566,7 +566,8 @@
         flex: 1;
         background: var(--chat-pattern);
         background-color: var(--bg-secondary);
-        padding: 20px 24px;
+        padding: 20px 24px 112px;
+        padding-bottom: calc(112px + env(safe-area-inset-bottom));
 
         &::-webkit-scrollbar {
           width: 6px;
@@ -600,7 +601,8 @@
       }
 
       .message-wrapper {
-        margin-bottom: 16px;
+        box-sizing: border-box;
+        padding-bottom: 16px;
       }
 
       .message-bubble {
@@ -623,7 +625,7 @@
 
           .bubble-content {
             background: var(--primary-gradient);
-            color: #fff;
+            color: var(--on-primary);
             border-radius: 18px 18px 4px 18px;
             padding: 10px 14px;
             font-size: 14px;
@@ -1129,8 +1131,12 @@
   color: var(--text-secondary);
   white-space: nowrap;
   overflow: hidden;
-  text-overflow: ellipsis;
   flex: 1;
+
+  .highlight {
+    color: var(--primary);
+    font-weight: 500;
+  }
 }
 
 .unread-badge {
@@ -1744,7 +1750,8 @@
   overflow-y: auto;
   overflow-x: hidden;
   min-height: 0;
-  padding: 20px 24px;
+  padding: 20px 24px 112px;
+  padding-bottom: calc(112px + env(safe-area-inset-bottom));
   display: flex;
   flex-direction: column;
   gap: 16px;
@@ -1773,6 +1780,10 @@
   }
 }
 
+.message-virtuoso {
+  width: 100%;
+}
+
 .loading-messages.loading-overlay {
   position: absolute;
   inset: 0;
@@ -1830,9 +1841,9 @@
 
 // 回到底部按钮
 .scroll-to-bottom {
-  position: sticky;
+  position: absolute;
   bottom: 20px;
-  align-self: center;
+  left: 50%;
   padding: 8px 16px;
   border-radius: 20px;
   background: var(--bg-secondary);
@@ -1847,13 +1858,13 @@
   font-size: 13px;
   z-index: 10;
   opacity: 0;
-  transform: translateY(20px);
+  transform: translate(-50%, 20px);
   pointer-events: none;
   transition: all 0.3s ease;
 
   &.show {
     opacity: 1;
-    transform: translateY(0);
+    transform: translate(-50%, 0);
     pointer-events: auto;
   }
 
@@ -1890,6 +1901,8 @@
 .message-wrapper {
   display: flex;
   flex-direction: column;
+  box-sizing: border-box;
+  padding-bottom: 16px;
   -webkit-app-region: no-drag;
 
   &.sent {
@@ -1949,7 +1962,7 @@
 
     .bubble-content {
       background: var(--primary);
-      color: white;
+      color: var(--on-primary);
       border-radius: 18px 18px 4px 18px;
     }
   }
@@ -2056,6 +2069,10 @@
   object-fit: contain;
 }
 
+.emoji-message-wrapper {
+  display: inline-block;
+}
+
 .emoji-loading {
   width: 90px;
   height: 90px;
@@ -2403,7 +2420,6 @@
   background: rgba(0, 0, 0, 0.04);
   border-left: 2px solid var(--primary);
   padding: 6px 10px;
-  margin-bottom: 8px;
   border-radius: 4px;
   font-size: 13px;
 
@@ -2437,15 +2453,15 @@
 
 // 自己发送的消息中的引用样式
 .message-bubble.sent .quoted-message {
-  background: rgba(255, 255, 255, 0.15);
-  border-left-color: rgba(255, 255, 255, 0.5);
+  background: color-mix(in srgb, var(--on-primary) 12%, var(--primary));
+  border-left-color: color-mix(in srgb, var(--on-primary) 36%, var(--primary));
 
   .quoted-sender {
-    color: rgba(255, 255, 255, 0.9);
+    color: color-mix(in srgb, var(--on-primary) 92%, var(--primary));
   }
 
   .quoted-text {
-    color: rgba(255, 255, 255, 0.8);
+    color: color-mix(in srgb, var(--on-primary) 80%, var(--primary));
   }
 }
 
@@ -2465,6 +2481,14 @@
 
 .bubble-content {
   -webkit-app-region: no-drag;
+
+  &.quote-layout-top .quoted-message {
+    margin-bottom: 8px;
+  }
+
+  &.quote-layout-bottom .quoted-message {
+    margin-top: 8px;
+  }
 }
 
 // 时间分隔
@@ -2761,7 +2785,7 @@
       display: flex;
       align-items: center;
       gap: 6px;
-      font-size: 12px;
+      font-size: 14px;
       font-weight: 600;
       color: var(--text-secondary);
       margin-bottom: 12px;
@@ -3045,13 +3069,15 @@
   }
 
   .member-flag {
-    width: 18px;
     height: 18px;
+    padding: 0 6px;
     border-radius: 9999px;
     display: inline-flex;
     align-items: center;
     justify-content: center;
     border: 1px solid var(--border-color);
+    font-size: 11px;
+    white-space: nowrap;
 
     &.owner {
       color: #f59e0b;
@@ -3288,13 +3314,89 @@
 
 // 聊天记录消息 (合并转发)
 .chat-record-message {
-  background: var(--card-inner-bg) !important;
-  border: 1px solid var(--border-color) !important;
-  transition: opacity 0.2s ease;
+  width: 300px;
+  min-width: 240px;
+  max-width: 336px;
+  background: color-mix(in srgb, var(--bg-secondary) 97%, #f5f7fb);
+  border: 1px solid var(--border-color);
+  border-radius: 16px;
+  overflow: hidden;
+  box-shadow: 0 4px 16px rgba(0, 0, 0, 0.04);
+  transition: transform 0.15s ease, box-shadow 0.15s ease, border-color 0.15s ease;
   cursor: pointer;
+  padding: 0;
 
   &:hover {
-    opacity: 0.85;
+    transform: translateY(-1px);
+    box-shadow: 0 6px 18px rgba(0, 0, 0, 0.08);
+    border-color: color-mix(in srgb, var(--primary) 28%, var(--border-color));
+  }
+
+  .chat-record-title {
+    padding: 13px 16px 6px;
+    font-size: 13px;
+    font-weight: 600;
+    color: var(--text-primary);
+    line-height: 1.45;
+    display: -webkit-box;
+    -webkit-line-clamp: 2;
+    line-clamp: 2;
+    -webkit-box-orient: vertical;
+    overflow: hidden;
+  }
+
+  .chat-record-meta-line {
+    padding: 0 16px 10px;
+    font-size: 11px;
+    color: var(--text-tertiary);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+  }
+
+  .chat-record-list {
+    padding: 0 16px 11px;
+    display: flex;
+    flex-direction: column;
+    gap: 4px;
+    max-height: 92px;
+    overflow: hidden;
+    border-bottom: 1px solid var(--border-color);
+  }
+
+  .chat-record-item {
+    font-size: 12px;
+    line-height: 1.45;
+    color: var(--text-secondary);
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+  }
+
+  .source-name {
+    color: currentColor;
+    opacity: 0.92;
+    font-weight: 500;
+    margin-right: 4px;
+  }
+
+  .chat-record-more {
+    font-size: 11px;
+    color: var(--text-tertiary);
+  }
+
+  .chat-record-desc {
+    padding: 0 16px 11px;
+    font-size: 12px;
+    line-height: 1.45;
+    color: var(--text-secondary);
+    border-bottom: 1px solid var(--border-color);
+  }
+
+  .chat-record-footer {
+    padding: 8px 16px 10px;
+    font-size: 11px;
+    color: var(--text-tertiary);
   }
 }
 
@@ -3368,75 +3470,6 @@
   }
 }
 
-// 聊天记录消息 - 复用 link-message 基础样式
-.chat-record-message {
-  cursor: pointer;
-
-  .link-header {
-    padding-bottom: 4px;
-  }
-
-  .chat-record-preview {
-    display: flex;
-    flex-direction: column;
-    gap: 4px;
-    flex: 1;
-    min-width: 0;
-  }
-
-  .chat-record-meta-line {
-    font-size: 11px;
-    color: var(--text-tertiary);
-    white-space: nowrap;
-    overflow: hidden;
-    text-overflow: ellipsis;
-  }
-
-  .chat-record-list {
-    display: flex;
-    flex-direction: column;
-    gap: 2px;
-    max-height: 70px;
-    overflow: hidden;
-  }
-
-  .chat-record-item {
-    font-size: 12px;
-    color: var(--text-secondary);
-    white-space: nowrap;
-    overflow: hidden;
-    text-overflow: ellipsis;
-  }
-
-  .source-name {
-    color: var(--text-primary);
-    font-weight: 500;
-    margin-right: 4px;
-  }
-
-  .chat-record-more {
-    font-size: 12px;
-    color: var(--primary);
-  }
-
-  .chat-record-desc {
-    font-size: 12px;
-    color: var(--text-secondary);
-  }
-
-  .chat-record-icon {
-    width: 40px;
-    height: 40px;
-    border-radius: 10px;
-    background: var(--primary-gradient);
-    display: flex;
-    align-items: center;
-    justify-content: center;
-    color: #fff;
-    flex-shrink: 0;
-  }
-}
-
 // 小程序消息
 .miniapp-message {
   display: flex;
@@ -3533,23 +3566,18 @@
 .message-bubble.sent {
 
   .card-message,
-  .chat-record-message,
   .miniapp-message,
   .appmsg-rich-card {
     background: var(--sent-card-bg);
 
     .card-name,
     .miniapp-title,
-    .source-name,
     .link-title {
       color: white;
     }
 
     .card-label,
     .miniapp-label,
-    .chat-record-item,
-    .chat-record-meta-line,
-    .chat-record-desc,
     .link-desc,
     .appmsg-url-line {
       color: rgba(255, 255, 255, 0.8);
@@ -3557,14 +3585,10 @@
 
     .card-icon,
     .miniapp-icon,
-    .chat-record-icon {
+    .link-thumb-placeholder {
       color: white;
     }
 
-    .chat-record-more {
-      color: rgba(255, 255, 255, 0.9);
-    }
-
     .appmsg-meta-badge {
       color: rgba(255, 255, 255, 0.92);
       background: rgba(255, 255, 255, 0.12);
@@ -3645,11 +3669,11 @@
 // 批量转写按钮
 .batch-transcribe-btn {
   &:hover:not(:disabled) {
-    color: var(--primary-color);
+    color: var(--primary);
   }
 
   &.transcribing {
-    color: var(--primary-color);
+    color: var(--primary);
     cursor: pointer;
     opacity: 1 !important;
   }
@@ -3673,7 +3697,7 @@
     border-bottom: 1px solid var(--border-color);
 
     svg {
-      color: var(--primary-color);
+      color: var(--primary);
     }
 
     h3 {
@@ -3694,6 +3718,36 @@
       line-height: 1.6;
     }
 
+    .batch-task-switch {
+      display: grid;
+      grid-template-columns: 1fr 1fr;
+      gap: 0.5rem;
+      margin-bottom: 1rem;
+
+      .batch-task-btn {
+        border: 1px solid var(--border-color);
+        background: var(--bg-secondary);
+        color: var(--text-secondary);
+        border-radius: 8px;
+        padding: 0.55rem 0.75rem;
+        font-size: 13px;
+        cursor: pointer;
+        transition: all 0.2s;
+
+        &:hover {
+          border-color: color-mix(in srgb, var(--primary) 50%, var(--border-color));
+          color: var(--text-primary);
+        }
+
+        &.active {
+          border-color: var(--primary);
+          color: var(--primary);
+          background: color-mix(in srgb, var(--primary) 10%, var(--bg-primary));
+          box-shadow: 0 0 0 1px color-mix(in srgb, var(--primary) 25%, transparent);
+        }
+      }
+    }
+
     .batch-dates-list-wrap {
       margin-bottom: 1rem;
       background: var(--bg-tertiary);
@@ -3711,7 +3765,7 @@
         .batch-dates-btn {
           padding: 0.35rem 0.75rem;
           font-size: 12px;
-          color: var(--primary-color);
+          color: var(--primary);
           background: transparent;
           border: 1px solid var(--border-color);
           border-radius: 6px;
@@ -3720,7 +3774,7 @@
 
           &:hover {
             background: var(--bg-hover);
-            border-color: var(--primary-color);
+            border-color: var(--primary);
           }
         }
       }
@@ -3753,9 +3807,14 @@
           }
 
           input[type="checkbox"] {
-            accent-color: var(--primary-color);
+            accent-color: var(--primary);
             cursor: pointer;
             flex-shrink: 0;
+
+            &:focus-visible {
+              outline: 2px solid color-mix(in srgb, var(--primary) 45%, transparent);
+              outline-offset: 1px;
+            }
           }
 
           .batch-date-label {
@@ -3798,7 +3857,7 @@
         .value {
           font-size: 14px;
           font-weight: 600;
-          color: var(--primary-color);
+          color: var(--primary);
         }
 
         .batch-concurrency-field {
@@ -3924,7 +3983,7 @@
 
       &.btn-primary,
       &.batch-transcribe-start-btn {
-        background: var(--primary-color);
+        background: var(--primary);
         color: #000;
 
         &:hover {
@@ -4171,43 +4230,6 @@
   }
 }
 
-// 聊天记录消息外观
-.chat-record-message {
-  background: var(--card-inner-bg) !important;
-  border: 1px solid var(--border-color);
-  border-radius: 8px;
-  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.06);
-
-  &:hover {
-    background: var(--bg-hover) !important;
-  }
-
-  .chat-record-list {
-    font-size: 13px;
-    color: var(--text-tertiary);
-    line-height: 1.6;
-    margin-top: 8px;
-    padding-top: 8px;
-    border-top: 1px solid var(--border-color);
-
-    .chat-record-item {
-      white-space: nowrap;
-      overflow: hidden;
-      text-overflow: ellipsis;
-
-      .source-name {
-        color: var(--text-secondary);
-      }
-    }
-  }
-
-  .chat-record-more {
-    font-size: 12px;
-    color: var(--text-tertiary);
-    margin-top: 4px;
-  }
-}
-
 // 公众号文章图文消息外观 (大图模式)
 .official-message {
   display: flex;
@@ -4465,6 +4487,32 @@
     font-weight: 500;
   }
 }
+
+// 公众号入口样式
+.session-item.biz-entry {
+  cursor: pointer;
+  transition: background-color 0.2s;
+
+  &:hover {
+    background: var(--hover-bg, rgba(0,0,0,0.05));
+  }
+
+  .biz-entry-avatar {
+    width: 48px;
+    height: 48px;
+    border-radius: 8px;
+    background: #fff;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    flex-shrink: 0;
+    color: #07c160;
+  }
+
+  .session-name {
+    font-weight: 500;
+  }
+}
 // 消息信息弹窗
 .message-info-overlay {
   position: fixed;
@@ -4538,7 +4586,7 @@
       display: flex;
       align-items: center;
       gap: 6px;
-      font-size: 12px;
+      font-size: 14px;
       font-weight: 600;
       color: var(--text-secondary);
       margin-bottom: 12px;
@@ -4630,3 +4678,260 @@
     }
   }
 }
+
+// 会话内搜索栏
+// 会话内搜索浮窗
+.in-session-search-popup {
+  position: absolute;
+  top: 60px;
+  right: 16px;
+  width: 360px;
+  max-height: 500px;
+  background: var(--card-bg);
+  border: 1px solid var(--border-color);
+  border-radius: 12px;
+  box-shadow: 0 8px 24px rgba(0, 0, 0, 0.15);
+  z-index: 1000;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+
+  .in-session-search-header {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    padding: 12px 16px;
+    border-bottom: 1px solid var(--border-color);
+    flex-shrink: 0;
+
+    .search-icon {
+      color: var(--text-secondary);
+      flex-shrink: 0;
+    }
+
+    .search-input {
+      flex: 1;
+      border: none;
+      background: transparent;
+      outline: none;
+      font-size: 14px;
+      color: var(--text-primary);
+      min-width: 0;
+      &::placeholder { color: var(--text-tertiary); }
+    }
+
+    .spin {
+      animation: spin 1s linear infinite;
+      color: var(--primary);
+      flex-shrink: 0;
+    }
+
+    .close-btn {
+      padding: 4px;
+      border-radius: 4px;
+      background: transparent;
+      border: none;
+      color: var(--text-tertiary);
+      cursor: pointer;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      transition: all 0.2s;
+      flex-shrink: 0;
+
+      &:hover {
+        background: var(--bg-tertiary);
+        color: var(--text-primary);
+      }
+    }
+  }
+
+  .search-result-header {
+    padding: 6px 16px;
+    font-size: 12px;
+    color: var(--text-secondary);
+    background: var(--bg-secondary);
+    border-bottom: 1px solid var(--border-color);
+    flex-shrink: 0;
+  }
+
+  .in-session-results {
+    flex: 1;
+    overflow-y: auto;
+    min-height: 0;
+
+    .result-item {
+      display: flex;
+      align-items: flex-start;
+      padding: 12px 16px;
+      cursor: pointer;
+      gap: 10px;
+      border-bottom: 1px solid var(--border-color);
+      transition: background 0.15s;
+
+      &:last-child {
+        border-bottom: none;
+      }
+
+      &:hover {
+        background: var(--bg-secondary);
+      }
+
+      .result-header {
+        flex-shrink: 0;
+
+        .result-info {
+          display: none;
+        }
+      }
+
+      .result-content {
+        flex: 1;
+        display: flex;
+        flex-direction: column;
+        gap: 2px;
+        min-width: 0;
+
+        .result-sender {
+          font-size: 13px;
+          color: var(--text-primary);
+          font-weight: 500;
+          overflow: hidden;
+          text-overflow: ellipsis;
+          white-space: nowrap;
+        }
+
+        .result-text {
+          font-size: 13px;
+          color: var(--text-secondary);
+          overflow: hidden;
+          white-space: nowrap;
+          text-overflow: ellipsis;
+          line-height: 1.4;
+        }
+      }
+
+      .result-time {
+        font-size: 11px;
+        color: var(--text-tertiary);
+        flex-shrink: 0;
+      }
+    }
+  }
+
+  .no-results {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    padding: 40px 20px;
+    color: var(--text-tertiary);
+    gap: 12px;
+
+    p {
+      margin: 0;
+      font-size: 14px;
+    }
+  }
+}
+
+// 搜索分类标题
+.search-section-header {
+  padding: 8px 16px;
+  font-size: 12px;
+  color: var(--text-tertiary);
+  background: var(--bg-secondary);
+  font-weight: 500;
+  display: flex;
+  align-items: center;
+  gap: 6px;
+
+  .search-phase-hint {
+    color: var(--primary);
+    font-weight: 400;
+
+    &.done {
+      color: var(--text-tertiary);
+    }
+  }
+}
+
+// 全局消息搜索结果面板
+.global-msg-search-results {
+  max-height: 300px;
+  overflow-y: auto;
+  background: var(--bg-secondary);
+  border-bottom: 1px solid var(--border-color);
+
+  .search-loading,
+  .no-results {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    gap: 8px;
+    padding: 24px;
+    color: var(--text-tertiary);
+    font-size: 13px;
+  }
+
+  .search-results-list {
+    .session-item {
+      display: flex;
+      padding: 12px 16px;
+      cursor: pointer;
+      border-bottom: 1px solid var(--border-color);
+      gap: 12px;
+      background: var(--bg-secondary);
+
+      &:hover {
+        background: var(--bg-hover);
+      }
+
+      .session-content {
+        flex: 1;
+        min-width: 0;
+        display: flex;
+        flex-direction: column;
+        gap: 4px;
+
+        .session-top {
+          display: flex;
+          justify-content: space-between;
+          align-items: center;
+
+          .session-name {
+            font-size: 14px;
+            font-weight: 500;
+            color: var(--text-primary);
+          }
+        }
+
+        .session-preview {
+          font-size: 13px;
+          color: var(--text-secondary);
+          overflow: hidden;
+          text-overflow: ellipsis;
+          white-space: nowrap;
+
+          .highlight {
+            color: var(--primary);
+            font-weight: 500;
+          }
+        }
+
+        .search-count {
+          font-size: 12px;
+          color: var(--primary);
+        }
+      }
+    }
+  }
+}
+
+.msg-search-toggle-btn.active {
+  color: var(--accent-color, #07c160);
+}
+.in-session-search-btn.active {
+  color: var(--accent-color, #07c160);
+}

src/pages/ContactsPage.tsx

@@ -18,7 +18,7 @@ const AVATAR_ENRICH_BATCH_SIZE = 80
 const SEARCH_DEBOUNCE_MS = 120
 const VIRTUAL_ROW_HEIGHT = 76
 const VIRTUAL_OVERSCAN = 10
-const DEFAULT_CONTACTS_LOAD_TIMEOUT_MS = 3000
+const DEFAULT_CONTACTS_LOAD_TIMEOUT_MS = 10000
 const AVATAR_RECHECK_INTERVAL_MS = 24 * 60 * 60 * 1000
 
 interface ContactsLoadSession {
@@ -397,6 +397,10 @@ function ContactsPage() {
                         displayName: contact.displayName,
                         remark: contact.remark,
                         nickname: contact.nickname,
+                        alias: contact.alias,
+                        labels: contact.labels,
+                        detailDescription: contact.detailDescription,
+                        region: contact.region,
                         type: contact.type
                     }))
                 ).catch((error) => {
@@ -1110,6 +1114,16 @@ function ContactsPage() {
                             <div className="detail-row"><span className="detail-label">用户名</span><span className="detail-value">{selectedContact.username}</span></div>
                             <div className="detail-row"><span className="detail-label">昵称</span><span className="detail-value">{selectedContact.nickname || selectedContact.displayName}</span></div>
                             {selectedContact.remark && <div className="detail-row"><span className="detail-label">备注</span><span className="detail-value">{selectedContact.remark}</span></div>}
+                            {selectedContact.alias && <div className="detail-row"><span className="detail-label">微信号</span><span className="detail-value">{selectedContact.alias}</span></div>}
+                            {selectedContact.labels && selectedContact.labels.length > 0 && (
+                                <div className="detail-row"><span className="detail-label">标签</span><span className="detail-value">{selectedContact.labels.join('、')}</span></div>
+                            )}
+                            {selectedContact.detailDescription && (
+                                <div className="detail-row"><span className="detail-label">个性签名</span><span className="detail-value">{selectedContact.detailDescription}</span></div>
+                            )}
+                            {selectedContact.region && (
+                                <div className="detail-row"><span className="detail-label">地区</span><span className="detail-value">{selectedContact.region}</span></div>
+                            )}
                             <div className="detail-row"><span className="detail-label">类型</span><span className="detail-value">{getContactTypeName(selectedContact.type)}</span></div>
                             {selectedContactSupportsSns && (
                                 <div className="detail-row">

src/pages/DualReportWindow.scss

@@ -238,7 +238,7 @@
   }
 
   .scene-message.sent .scene-avatar {
-    border-color: color-mix(in srgb, var(--primary) 30%, var(--bg-tertiary, rgba(0, 0, 0, 0.08)));
+    border-color: rgba(var(--ar-primary-rgb), 0.3);
   }
 
   .dual-stat-grid {
@@ -981,4 +981,4 @@
       transform: translateY(0);
     }
   }
-}
+}

src/pages/DualReportWindow.tsx

@@ -1,6 +1,10 @@
-import { useEffect, useState } from 'react'
+import { useEffect, useRef, useState } from 'react'
+import { Check, Download, Image, SlidersHorizontal, X } from 'lucide-react'
+import html2canvas from 'html2canvas'
 import ReportHeatmap from '../components/ReportHeatmap'
 import ReportWordCloud from '../components/ReportWordCloud'
+import { useThemeStore } from '../stores/themeStore'
+import { drawPatternBackground } from '../utils/reportExport'
 import './AnnualReportWindow.scss'
 import './DualReportWindow.scss'
 
@@ -66,6 +70,12 @@ interface DualReportData {
   streak?: { days: number; startDate: string; endDate: string }
 }
 
+interface SectionInfo {
+  id: string
+  name: string
+  ref: React.RefObject<HTMLElement | null>
+}
+
 function DualReportWindow() {
   const [reportData, setReportData] = useState<DualReportData | null>(null)
   const [isLoading, setIsLoading] = useState(true)
@@ -75,6 +85,29 @@ function DualReportWindow() {
   const [myEmojiUrl, setMyEmojiUrl] = useState<string | null>(null)
   const [friendEmojiUrl, setFriendEmojiUrl] = useState<string | null>(null)
   const [activeWordCloudTab, setActiveWordCloudTab] = useState<'shared' | 'my' | 'friend'>('shared')
+  const [isExporting, setIsExporting] = useState(false)
+  const [exportProgress, setExportProgress] = useState('')
+  const [showExportModal, setShowExportModal] = useState(false)
+  const [selectedSections, setSelectedSections] = useState<Set<string>>(new Set())
+  const [fabOpen, setFabOpen] = useState(false)
+  const [exportMode, setExportMode] = useState<'separate' | 'long'>('separate')
+
+  const { themeMode } = useThemeStore()
+
+  const sectionRefs = {
+    cover: useRef<HTMLElement>(null),
+    firstChat: useRef<HTMLElement>(null),
+    yearFirstChat: useRef<HTMLElement>(null),
+    heatmap: useRef<HTMLElement>(null),
+    initiative: useRef<HTMLElement>(null),
+    response: useRef<HTMLElement>(null),
+    streak: useRef<HTMLElement>(null),
+    wordCloud: useRef<HTMLElement>(null),
+    stats: useRef<HTMLElement>(null),
+    ending: useRef<HTMLElement>(null)
+  }
+
+  const containerRef = useRef<HTMLDivElement>(null)
 
   useEffect(() => {
     const params = new URLSearchParams(window.location.hash.split('?')[1] || '')
@@ -151,6 +184,351 @@ function DualReportWindow() {
     void loadEmojis()
   }, [reportData])
 
+  const formatFileYearLabel = (year: number) => (year === 0 ? '历史以来' : String(year))
+
+  const sanitizeFileNameSegment = (value: string) => {
+    const sanitized = value.replace(/[\\/:*?"<>|]/g, '_').trim()
+    return sanitized || '好友'
+  }
+
+  const getAvailableSections = (): SectionInfo[] => {
+    if (!reportData) return []
+
+    const sections: SectionInfo[] = [
+      { id: 'cover', name: '封面', ref: sectionRefs.cover },
+      { id: 'firstChat', name: '首次聊天', ref: sectionRefs.firstChat }
+    ]
+
+    if (reportData.yearFirstChat && (!reportData.firstChat || reportData.yearFirstChat.createTime !== reportData.firstChat.createTime)) {
+      sections.push({ id: 'yearFirstChat', name: '第一段对话', ref: sectionRefs.yearFirstChat })
+    }
+    if (reportData.heatmap) {
+      sections.push({ id: 'heatmap', name: '作息规律', ref: sectionRefs.heatmap })
+    }
+    if (reportData.initiative) {
+      sections.push({ id: 'initiative', name: '主动性', ref: sectionRefs.initiative })
+    }
+    if (reportData.response) {
+      sections.push({ id: 'response', name: '回应速度', ref: sectionRefs.response })
+    }
+    if (reportData.streak) {
+      sections.push({ id: 'streak', name: '最长连续聊天', ref: sectionRefs.streak })
+    }
+
+    sections.push({ id: 'wordCloud', name: '常用语', ref: sectionRefs.wordCloud })
+    sections.push({ id: 'stats', name: '年度统计', ref: sectionRefs.stats })
+    sections.push({ id: 'ending', name: '尾声', ref: sectionRefs.ending })
+
+    return sections
+  }
+
+  const exportSection = async (section: SectionInfo): Promise<{ name: string; data: string } | null> => {
+    const element = section.ref.current
+    if (!element) {
+      return null
+    }
+
+    const OUTPUT_WIDTH = 1920
+    const OUTPUT_HEIGHT = 1080
+    let wordCloudInner: HTMLElement | null = null
+    let wordTags: NodeListOf<HTMLElement> | null = null
+    let wordCloudOriginalStyle = ''
+    const wordTagOriginalStyles: string[] = []
+    const originalStyle = element.style.cssText
+
+    try {
+      const selection = window.getSelection()
+      if (selection && selection.rangeCount > 0) selection.removeAllRanges()
+      const activeEl = document.activeElement as HTMLElement | null
+      activeEl?.blur?.()
+      document.body.classList.add('exporting-snapshot')
+      document.documentElement.classList.add('exporting-snapshot')
+
+      element.style.minHeight = 'auto'
+      element.style.padding = '40px 20px'
+      element.style.background = 'transparent'
+      element.style.backgroundColor = 'transparent'
+      element.style.boxShadow = 'none'
+
+      wordCloudInner = element.querySelector('.word-cloud-inner') as HTMLElement | null
+      wordTags = element.querySelectorAll('.word-tag') as NodeListOf<HTMLElement>
+
+      if (wordCloudInner) {
+        wordCloudOriginalStyle = wordCloudInner.style.cssText
+        wordCloudInner.style.transform = 'none'
+      }
+
+      wordTags.forEach((tag, index) => {
+        wordTagOriginalStyles[index] = tag.style.cssText
+        tag.style.opacity = String(tag.style.getPropertyValue('--final-opacity') || '1')
+        tag.style.animation = 'none'
+      })
+
+      await new Promise((resolve) => setTimeout(resolve, 50))
+
+      const computedStyle = getComputedStyle(document.documentElement)
+      const bgColor = computedStyle.getPropertyValue('--bg-primary').trim() || '#F9F8F6'
+
+      const canvas = await html2canvas(element, {
+        backgroundColor: 'transparent',
+        scale: 2,
+        useCORS: true,
+        allowTaint: true,
+        logging: false,
+        onclone: (clonedDoc) => {
+          clonedDoc.body.classList.add('exporting-snapshot')
+          clonedDoc.documentElement.classList.add('exporting-snapshot')
+          clonedDoc.getSelection?.()?.removeAllRanges()
+        }
+      })
+
+      const outputCanvas = document.createElement('canvas')
+      outputCanvas.width = OUTPUT_WIDTH
+      outputCanvas.height = OUTPUT_HEIGHT
+      const ctx = outputCanvas.getContext('2d')
+      if (!ctx) {
+        return null
+      }
+
+      const isDark = themeMode === 'dark'
+      await drawPatternBackground(ctx, OUTPUT_WIDTH, OUTPUT_HEIGHT, bgColor, isDark)
+
+      const PADDING = 80
+      const contentWidth = OUTPUT_WIDTH - PADDING * 2
+      const contentHeight = OUTPUT_HEIGHT - PADDING * 2
+      const srcRatio = canvas.width / canvas.height
+      const dstRatio = contentWidth / contentHeight
+
+      let drawWidth: number
+      let drawHeight: number
+      let drawX: number
+      let drawY: number
+
+      if (srcRatio > dstRatio) {
+        drawWidth = contentWidth
+        drawHeight = contentWidth / srcRatio
+        drawX = PADDING
+        drawY = PADDING + (contentHeight - drawHeight) / 2
+      } else {
+        drawHeight = contentHeight
+        drawWidth = contentHeight * srcRatio
+        drawX = PADDING + (contentWidth - drawWidth) / 2
+        drawY = PADDING
+      }
+
+      ctx.drawImage(canvas, drawX, drawY, drawWidth, drawHeight)
+      return { name: section.name, data: outputCanvas.toDataURL('image/png') }
+    } catch {
+      return null
+    } finally {
+      element.style.cssText = originalStyle
+      if (wordCloudInner) {
+        wordCloudInner.style.cssText = wordCloudOriginalStyle
+      }
+      wordTags?.forEach((tag, index) => {
+        tag.style.cssText = wordTagOriginalStyles[index]
+      })
+      document.body.classList.remove('exporting-snapshot')
+      document.documentElement.classList.remove('exporting-snapshot')
+    }
+  }
+
+  const exportFullReport = async (filterIds?: Set<string>) => {
+    if (!containerRef.current || !reportData) {
+      return
+    }
+
+    setIsExporting(true)
+    setExportProgress('正在生成长图...')
+
+    let wordCloudInner: HTMLElement | null = null
+    let wordTags: NodeListOf<HTMLElement> | null = null
+    let wordCloudOriginalStyle = ''
+    const wordTagOriginalStyles: string[] = []
+    const container = containerRef.current
+    const sections = Array.from(container.querySelectorAll('.section')) as HTMLElement[]
+    const originalStyles = sections.map((section) => section.style.cssText)
+
+    try {
+      const selection = window.getSelection()
+      if (selection && selection.rangeCount > 0) selection.removeAllRanges()
+      const activeEl = document.activeElement as HTMLElement | null
+      activeEl?.blur?.()
+      document.body.classList.add('exporting-snapshot')
+      document.documentElement.classList.add('exporting-snapshot')
+
+      sections.forEach((section) => {
+        section.style.minHeight = 'auto'
+        section.style.padding = '40px 0'
+      })
+
+      if (filterIds) {
+        getAvailableSections().forEach((section) => {
+          if (!filterIds.has(section.id) && section.ref.current) {
+            section.ref.current.style.display = 'none'
+          }
+        })
+      }
+
+      wordCloudInner = container.querySelector('.word-cloud-inner') as HTMLElement | null
+      wordTags = container.querySelectorAll('.word-tag') as NodeListOf<HTMLElement>
+
+      if (wordCloudInner) {
+        wordCloudOriginalStyle = wordCloudInner.style.cssText
+        wordCloudInner.style.transform = 'none'
+      }
+
+      wordTags.forEach((tag, index) => {
+        wordTagOriginalStyles[index] = tag.style.cssText
+        tag.style.opacity = String(tag.style.getPropertyValue('--final-opacity') || '1')
+        tag.style.animation = 'none'
+      })
+
+      await new Promise((resolve) => setTimeout(resolve, 100))
+
+      const computedStyle = getComputedStyle(document.documentElement)
+      const bgColor = computedStyle.getPropertyValue('--bg-primary').trim() || '#F9F8F6'
+
+      const canvas = await html2canvas(container, {
+        backgroundColor: 'transparent',
+        scale: 2,
+        useCORS: true,
+        allowTaint: true,
+        logging: false,
+        onclone: (clonedDoc) => {
+          clonedDoc.body.classList.add('exporting-snapshot')
+          clonedDoc.documentElement.classList.add('exporting-snapshot')
+          clonedDoc.getSelection?.()?.removeAllRanges()
+        }
+      })
+
+      const outputCanvas = document.createElement('canvas')
+      outputCanvas.width = canvas.width
+      outputCanvas.height = canvas.height
+      const ctx = outputCanvas.getContext('2d')
+      if (!ctx) {
+        throw new Error('无法创建导出画布')
+      }
+
+      const isDark = themeMode === 'dark'
+      await drawPatternBackground(ctx, canvas.width, canvas.height, bgColor, isDark)
+      ctx.drawImage(canvas, 0, 0)
+
+      const yearFilePrefix = formatFileYearLabel(reportData.year)
+      const friendFileSegment = sanitizeFileNameSegment(reportData.friendName || reportData.friendUsername)
+      const link = document.createElement('a')
+      link.download = `${yearFilePrefix}双人年度报告_${friendFileSegment}${filterIds ? '_自定义' : ''}.png`
+      link.href = outputCanvas.toDataURL('image/png')
+      document.body.appendChild(link)
+      link.click()
+      document.body.removeChild(link)
+    } catch (e) {
+      alert('导出失败: ' + String(e))
+    } finally {
+      sections.forEach((section, index) => {
+        section.style.cssText = originalStyles[index]
+      })
+      if (wordCloudInner) {
+        wordCloudInner.style.cssText = wordCloudOriginalStyle
+      }
+      wordTags?.forEach((tag, index) => {
+        tag.style.cssText = wordTagOriginalStyles[index]
+      })
+      document.body.classList.remove('exporting-snapshot')
+      document.documentElement.classList.remove('exporting-snapshot')
+      setIsExporting(false)
+      setExportProgress('')
+    }
+  }
+
+  const exportSelectedSections = async () => {
+    if (!reportData) return
+
+    const sections = getAvailableSections().filter((section) => selectedSections.has(section.id))
+    if (sections.length === 0) {
+      alert('请至少选择一个板块')
+      return
+    }
+
+    if (exportMode === 'long') {
+      setShowExportModal(false)
+      await exportFullReport(selectedSections)
+      setSelectedSections(new Set())
+      return
+    }
+
+    setIsExporting(true)
+    setShowExportModal(false)
+
+    const exportedImages: Array<{ name: string; data: string }> = []
+
+    for (let index = 0; index < sections.length; index++) {
+      const section = sections[index]
+      setExportProgress(`正在导出: ${section.name} (${index + 1}/${sections.length})`)
+
+      const result = await exportSection(section)
+      if (result) {
+        exportedImages.push(result)
+      }
+    }
+
+    if (exportedImages.length === 0) {
+      alert('导出失败')
+      setIsExporting(false)
+      setExportProgress('')
+      return
+    }
+
+    const dirResult = await window.electronAPI.dialog.openDirectory({
+      title: '选择导出文件夹',
+      properties: ['openDirectory', 'createDirectory']
+    })
+    if (dirResult.canceled || !dirResult.filePaths?.[0]) {
+      setIsExporting(false)
+      setExportProgress('')
+      return
+    }
+
+    setExportProgress('正在写入文件...')
+    const yearFilePrefix = formatFileYearLabel(reportData.year)
+    const friendFileSegment = sanitizeFileNameSegment(reportData.friendName || reportData.friendUsername)
+    const exportResult = await window.electronAPI.annualReport.exportImages({
+      baseDir: dirResult.filePaths[0],
+      folderName: `${yearFilePrefix}双人年度报告_${friendFileSegment}_分模块`,
+      images: exportedImages.map((image) => ({
+        name: `${yearFilePrefix}双人年度报告_${friendFileSegment}_${image.name}.png`,
+        dataUrl: image.data
+      }))
+    })
+
+    if (!exportResult.success) {
+      alert('导出失败: ' + (exportResult.error || '未知错误'))
+    }
+
+    setIsExporting(false)
+    setExportProgress('')
+    setSelectedSections(new Set())
+  }
+
+  const toggleSection = (id: string) => {
+    const next = new Set(selectedSections)
+    if (next.has(id)) {
+      next.delete(id)
+    } else {
+      next.add(id)
+    }
+    setSelectedSections(next)
+  }
+
+  const toggleAll = () => {
+    const sections = getAvailableSections()
+    if (selectedSections.size === sections.length) {
+      setSelectedSections(new Set())
+      return
+    }
+    setSelectedSections(new Set(sections.map((section) => section.id)))
+  }
+
   if (isLoading) {
     return (
       <div className="annual-report-window loading">
@@ -305,7 +683,7 @@ function DualReportWindow() {
       if (emojiUrl) {
         return (
           <div className="report-emoji-container">
-            <img src={emojiUrl} alt="表情" className="report-emoji-img" onError={(e) => {
+            <img src={emojiUrl} alt="表情" className="report-emoji-img" crossOrigin="anonymous" onError={(e) => {
               (e.target as HTMLImageElement).style.display = 'none';
               (e.target as HTMLImageElement).nextElementSibling?.removeAttribute('style');
             }} />
@@ -356,7 +734,7 @@ function DualReportWindow() {
     if (avatarUrl) {
       return (
         <div className="scene-avatar with-image">
-          <img src={avatarUrl} alt={isSentByMe ? 'me-avatar' : 'friend-avatar'} />
+          <img src={avatarUrl} alt={isSentByMe ? 'me-avatar' : 'friend-avatar'} crossOrigin="anonymous" />
         </div>
       )
     }
@@ -419,9 +797,99 @@ function DualReportWindow() {
         <div className="deco-circle c5" />
       </div>
 
+      <div className={`fab-container ${fabOpen ? 'open' : ''}`}>
+        <button
+          className="fab-item"
+          onClick={() => {
+            setFabOpen(false)
+            setExportMode('separate')
+            setShowExportModal(true)
+          }}
+          title="分模块导出"
+        >
+          <Image size={18} />
+        </button>
+        <button
+          className="fab-item"
+          onClick={() => {
+            setFabOpen(false)
+            setExportMode('long')
+            setShowExportModal(true)
+          }}
+          title="自定义导出长图"
+        >
+          <SlidersHorizontal size={18} />
+        </button>
+        <button
+          className="fab-item"
+          onClick={() => {
+            setFabOpen(false)
+            void exportFullReport()
+          }}
+          title="导出长图"
+        >
+          <Download size={18} />
+        </button>
+        <button className="fab-main" onClick={() => setFabOpen(!fabOpen)}>
+          {fabOpen ? <X size={22} /> : <Download size={22} />}
+        </button>
+      </div>
+
+      {isExporting && (
+        <div className="export-overlay">
+          <div className="export-progress-modal">
+            <div className="export-spinner">
+              <div className="spinner-ring"></div>
+              <Download size={24} className="spinner-icon" />
+            </div>
+            <p className="export-title">正在导出</p>
+            <p className="export-status">{exportProgress}</p>
+          </div>
+        </div>
+      )}
+
+      {showExportModal && (
+        <div className="export-overlay" onClick={() => setShowExportModal(false)}>
+          <div className="export-modal section-selector" onClick={(e) => e.stopPropagation()}>
+            <div className="modal-header">
+              <h3>{exportMode === 'long' ? '自定义导出长图' : '选择要导出的板块'}</h3>
+              <button className="close-btn" onClick={() => setShowExportModal(false)}>
+                <X size={20} />
+              </button>
+            </div>
+            <div className="section-grid">
+              {getAvailableSections().map((section) => (
+                <div
+                  key={section.id}
+                  className={`section-card ${selectedSections.has(section.id) ? 'selected' : ''}`}
+                  onClick={() => toggleSection(section.id)}
+                >
+                  <div className="card-check">
+                    {selectedSections.has(section.id) && <Check size={14} />}
+                  </div>
+                  <span>{section.name}</span>
+                </div>
+              ))}
+            </div>
+            <div className="modal-footer">
+              <button className="select-all-btn" onClick={toggleAll}>
+                {selectedSections.size === getAvailableSections().length ? '取消全选' : '全选'}
+              </button>
+              <button
+                className="confirm-btn"
+                onClick={() => void exportSelectedSections()}
+                disabled={selectedSections.size === 0}
+              >
+                {exportMode === 'long' ? '生成长图' : '导出'} {selectedSections.size > 0 ? `(${selectedSections.size})` : ''}
+              </button>
+            </div>
+          </div>
+        </div>
+      )}
+
       <div className="report-scroll-view">
-        <div className="report-container">
-          <section className="section">
+        <div className="report-container" ref={containerRef}>
+          <section className="section" ref={sectionRefs.cover}>
             <div className="label-text">WEFLOW · DUAL REPORT</div>
             <h1 className="hero-title dual-cover-title">{yearTitle}<br />双人聊天报告</h1>
             <hr className="divider" />
@@ -433,7 +901,7 @@ function DualReportWindow() {
             <p className="hero-desc">每一次对话都值得被珍藏</p>
           </section>
 
-          <section className="section">
+          <section className="section" ref={sectionRefs.firstChat}>
             <div className="label-text">首次聊天</div>
             <h2 className="hero-title">故事的开始</h2>
             {firstChat ? (
@@ -457,7 +925,7 @@ function DualReportWindow() {
           </section>
 
           {yearFirstChat && (!firstChat || yearFirstChat.createTime !== firstChat.createTime) ? (
-            <section className="section">
+            <section className="section" ref={sectionRefs.yearFirstChat}>
               <div className="label-text">第一段对话</div>
               <h2 className="hero-title">
                 {reportData.year === 0 ? '你们的第一段对话' : `${reportData.year}年的第一段对话`}
@@ -473,7 +941,7 @@ function DualReportWindow() {
           ) : null}
 
           {reportData.heatmap && (
-            <section className="section">
+            <section className="section" ref={sectionRefs.heatmap}>
               <div className="label-text">聊天习惯</div>
               <h2 className="hero-title">作息规律</h2>
               {mostActive && (
@@ -486,14 +954,14 @@ function DualReportWindow() {
           )}
 
           {reportData.initiative && (
-            <section className="section">
+            <section className="section" ref={sectionRefs.initiative}>
               <div className="label-text">主动性</div>
               <h2 className="hero-title">情感的天平</h2>
               <div className="initiative-container">
                 <div className="initiative-bar-wrapper">
                   <div className="initiative-side">
                     <div className="avatar-placeholder">
-                      {reportData.selfAvatarUrl ? <img src={reportData.selfAvatarUrl} alt="me-avatar" /> : '我'}
+                      {reportData.selfAvatarUrl ? <img src={reportData.selfAvatarUrl} alt="me-avatar" crossOrigin="anonymous" /> : '我'}
                     </div>
                     <div className="count">{reportData.initiative.initiated}次</div>
                     <div className="percent">{initiatedPercent.toFixed(1)}%</div>
@@ -507,7 +975,7 @@ function DualReportWindow() {
                   </div>
                   <div className="initiative-side">
                     <div className="avatar-placeholder">
-                      {reportData.friendAvatarUrl ? <img src={reportData.friendAvatarUrl} alt="friend-avatar" /> : reportData.friendName.substring(0, 1)}
+                      {reportData.friendAvatarUrl ? <img src={reportData.friendAvatarUrl} alt="friend-avatar" crossOrigin="anonymous" /> : reportData.friendName.substring(0, 1)}
                     </div>
                     <div className="count">{reportData.initiative.received}次</div>
                     <div className="percent">{receivedPercent.toFixed(1)}%</div>
@@ -521,7 +989,7 @@ function DualReportWindow() {
           )}
 
           {reportData.response && (
-            <section className="section">
+            <section className="section" ref={sectionRefs.response}>
               <div className="label-text">回应速度</div>
               <h2 className="hero-title">你说，我在</h2>
               <div className="response-pulse-container">
@@ -558,7 +1026,7 @@ function DualReportWindow() {
           )}
 
           {reportData.streak && (
-            <section className="section">
+            <section className="section" ref={sectionRefs.streak}>
               <div className="label-text">聊天火花</div>
               <h2 className="hero-title">最长连续聊天</h2>
               <div className="streak-spark-visual premium">
@@ -596,7 +1064,7 @@ function DualReportWindow() {
             </section>
           )}
 
-          <section className="section word-cloud-section">
+          <section className="section word-cloud-section" ref={sectionRefs.wordCloud}>
             <div className="label-text">常用语</div>
             <h2 className="hero-title">{yearTitle}常用语</h2>
 
@@ -640,7 +1108,7 @@ function DualReportWindow() {
             </div>
           </section>
 
-          <section className="section">
+          <section className="section" ref={sectionRefs.stats}>
             <div className="label-text">年度统计</div>
             <h2 className="hero-title">{yearTitle}数据概览</h2>
             <div className="dual-stat-grid">
@@ -664,7 +1132,7 @@ function DualReportWindow() {
               <div className="emoji-card">
                 <div className="emoji-title">我常用的表情</div>
                 {myEmojiUrl ? (
-                  <img src={myEmojiUrl} alt="my-emoji" onError={(e) => {
+                  <img src={myEmojiUrl} alt="my-emoji" crossOrigin="anonymous" onError={(e) => {
                     (e.target as HTMLImageElement).nextElementSibling?.removeAttribute('style');
                     (e.target as HTMLImageElement).style.display = 'none';
                   }} />
@@ -677,7 +1145,7 @@ function DualReportWindow() {
               <div className="emoji-card">
                 <div className="emoji-title">{reportData.friendName}常用的表情</div>
                 {friendEmojiUrl ? (
-                  <img src={friendEmojiUrl} alt="friend-emoji" onError={(e) => {
+                  <img src={friendEmojiUrl} alt="friend-emoji" crossOrigin="anonymous" onError={(e) => {
                     (e.target as HTMLImageElement).nextElementSibling?.removeAttribute('style');
                     (e.target as HTMLImageElement).style.display = 'none';
                   }} />
@@ -690,7 +1158,7 @@ function DualReportWindow() {
             </div>
           </section>
 
-          <section className="section">
+          <section className="section" ref={sectionRefs.ending}>
             <div className="label-text">尾声</div>
             <h2 className="hero-title">谢谢你一直在</h2>
             <p className="hero-desc">愿我们继续把故事写下去</p>

src/pages/GroupAnalyticsPage.scss

@@ -2,7 +2,9 @@
   display: flex;
   flex-direction: column;
   gap: 16px;
-  min-height: 100%;
+  height: 100%;
+  min-height: 0;
+  overflow: hidden;
 }
 
 .group-analytics-page {
@@ -10,6 +12,7 @@
   flex: 1;
   min-height: 0;
   gap: 16px;
+  overflow: hidden;
 
   &.standalone {
     height: 100vh;
@@ -197,6 +200,7 @@
   flex-direction: column;
   min-width: 250px;
   max-width: 450px;
+  min-height: 0;
   background: var(--bg-secondary);
   border-radius: 16px;
   overflow: hidden;
@@ -207,6 +211,7 @@
   display: flex;
   align-items: center;
   min-height: 56px;
+  flex-shrink: 0;
 
   .search-row {
     flex: 1;
@@ -296,6 +301,7 @@
 
 .group-list {
   flex: 1;
+  min-height: 0;
   overflow-y: auto;
   overflow-x: hidden;
 
@@ -468,11 +474,18 @@
   display: flex;
   flex-direction: column;
   min-width: 0;
+  min-height: 0;
   background: var(--bg-secondary);
   border-radius: 16px;
   overflow: hidden;
 }
 
+.detail-drag-region {
+  height: 16px;
+  flex-shrink: 0;
+  -webkit-app-region: drag;
+}
+
 .resize-handle {
   width: 4px;
   cursor: col-resize;
@@ -495,22 +508,30 @@
 
 .function-menu {
   flex: 1;
+  min-height: 0;
   display: flex;
   flex-direction: column;
-  align-items: center;
-  justify-content: center;
-  padding: 32px;
+  gap: 20px;
+  padding: 24px;
+  overflow-y: auto;
 
   .selected-group-info {
-    text-align: center;
-    margin-bottom: 40px;
+    display: flex;
+    align-items: center;
+    gap: 18px;
+    padding: 20px 24px;
+    background: var(--card-bg);
+    border: 1px solid var(--border-color);
+    border-radius: 20px;
+    box-shadow: var(--shadow-sm);
 
     .group-avatar.large {
       width: 80px;
       height: 80px;
       border-radius: 10px;
       overflow: hidden;
-      margin: 0 auto 16px;
+      margin: 0;
+      flex-shrink: 0;
 
       img {
         width: 100%;
@@ -529,45 +550,64 @@
       }
     }
 
+    .selected-group-meta {
+      min-width: 0;
+      display: flex;
+      flex-direction: column;
+      gap: 4px;
+    }
+
+    .group-summary-label {
+      font-size: 12px;
+      color: var(--text-tertiary);
+      letter-spacing: 0.04em;
+    }
+
     h2 {
-      font-size: 20px;
+      font-size: 22px;
       font-weight: 600;
       color: var(--text-primary);
-      margin-bottom: 4px;
+      margin: 0;
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
     }
 
     p {
       color: var(--text-secondary);
       font-size: 14px;
+      margin: 0;
     }
   }
 
   .function-grid {
-    display: flex;
-    flex-wrap: wrap;
-    gap: 20px;
-    justify-content: center;
+    width: 100%;
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
+    gap: 16px;
   }
 
   .function-card {
-    width: 140px;
-    padding: 24px 16px;
-    background: rgba(255, 255, 255, 0.15);
+    min-height: 148px;
+    padding: 20px 18px;
+    background: color-mix(in srgb, var(--card-bg) 92%, var(--bg-secondary));
     border-radius: 16px;
     display: flex;
     flex-direction: column;
-    align-items: center;
-    gap: 12px;
+    align-items: flex-start;
+    justify-content: flex-start;
+    gap: 10px;
     cursor: pointer;
     transition: all 0.2s;
-    box-shadow: 0 2px 8px rgba(0, 0, 0, 0.04);
+    box-shadow: var(--shadow-sm);
     backdrop-filter: blur(8px);
-    border: 1px solid rgba(255, 255, 255, 0.15);
+    border: 1px solid var(--border-color);
+    text-align: left;
 
     &:hover {
       transform: translateY(-2px);
-      box-shadow: 0 4px 16px rgba(0, 0, 0, 0.1);
-      background: rgba(255, 255, 255, 0.25);
+      box-shadow: var(--shadow-md);
+      background: color-mix(in srgb, var(--card-bg) 100%, var(--bg-hover));
     }
 
     svg {
@@ -575,15 +615,22 @@
     }
 
     span {
-      font-size: 13px;
-      font-weight: 500;
+      font-size: 15px;
+      font-weight: 600;
       color: var(--text-primary);
     }
+
+    small {
+      font-size: 12px;
+      line-height: 1.5;
+      color: var(--text-secondary);
+    }
   }
 }
 
 .function-content {
   flex: 1;
+  min-height: 0;
   display: flex;
   flex-direction: column;
   overflow: hidden;
@@ -694,6 +741,7 @@
 
   .content-body {
     flex: 1;
+    min-height: 0;
     overflow-y: auto;
     padding: 20px 24px;
     display: flex;
@@ -785,11 +833,14 @@
   }
 }
 
-.member-export-panel {
+.member-export-panel,
+.member-messages-panel,
+.member-analytics-panel {
   display: flex;
   flex-direction: column;
   gap: 16px;
   min-height: 0;
+  flex: 1;
 
   .member-export-empty {
     padding: 20px;
@@ -1121,6 +1172,153 @@
       cursor: not-allowed;
     }
   }
+
+  .member-message-empty {
+    padding: 20px;
+    border-radius: 12px;
+    background: var(--bg-tertiary);
+    color: var(--text-secondary);
+    text-align: center;
+    font-size: 14px;
+  }
+
+  .member-message-toolbar {
+    display: grid;
+    gap: 12px;
+    grid-template-columns: minmax(240px, 360px) minmax(160px, 1fr);
+    align-items: end;
+
+    @media (max-width: 900px) {
+      grid-template-columns: 1fr;
+    }
+  }
+
+  .member-message-toolbar-actions {
+    display: flex;
+    justify-content: flex-end;
+    align-items: center;
+
+    @media (max-width: 900px) {
+      justify-content: flex-start;
+    }
+  }
+
+  .member-message-select-trigger {
+    border-radius: 12px;
+  }
+
+  .member-message-summary-text {
+    align-self: flex-start;
+    font-size: 14px;
+    font-weight: 600;
+    color: var(--text-primary);
+    line-height: 1.2;
+  }
+
+  .member-message-summary-card {
+    min-height: 48px;
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
+    gap: 6px;
+    padding: 12px 14px;
+    border-radius: 14px;
+    background: color-mix(in srgb, var(--card-bg) 88%, var(--bg-secondary));
+    border: 1px solid var(--border-color);
+  }
+
+  .summary-title {
+    font-size: 14px;
+    font-weight: 600;
+    color: var(--text-primary);
+  }
+
+  .summary-desc {
+    font-size: 12px;
+    color: var(--text-secondary);
+  }
+
+  .member-message-list {
+    display: flex;
+    flex-direction: column;
+    gap: 12px;
+  }
+
+  .member-message-item {
+    padding: 14px 16px;
+    border-radius: 14px;
+    background: color-mix(in srgb, var(--card-bg) 92%, var(--bg-secondary));
+    border: 1px solid var(--border-color);
+    box-shadow: var(--shadow-sm);
+  }
+
+  .member-message-meta {
+    display: flex;
+    align-items: center;
+    flex-wrap: wrap;
+    gap: 8px;
+    margin-bottom: 8px;
+  }
+
+  .member-message-time {
+    font-size: 12px;
+    color: var(--text-secondary);
+  }
+
+  .member-message-type {
+    display: inline-flex;
+    align-items: center;
+    padding: 2px 8px;
+    border-radius: 9999px;
+    background: color-mix(in srgb, var(--primary) 12%, transparent);
+    color: var(--primary);
+    font-size: 11px;
+    font-weight: 600;
+  }
+
+  .member-message-content {
+    color: var(--text-primary);
+    font-size: 14px;
+    line-height: 1.6;
+    white-space: pre-wrap;
+    word-break: break-word;
+  }
+
+  .member-message-actions {
+    display: flex;
+    justify-content: center;
+    padding-top: 4px;
+  }
+
+  .member-message-load-more {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: 8px;
+    min-width: 132px;
+    padding: 10px 16px;
+    border: 1px solid var(--border-color);
+    border-radius: 9999px;
+    background: var(--bg-primary);
+    color: var(--text-primary);
+    cursor: pointer;
+    transition: all 0.2s;
+
+    &:hover {
+      border-color: var(--primary);
+      color: var(--primary);
+    }
+
+    &:disabled {
+      opacity: 0.55;
+      cursor: not-allowed;
+    }
+  }
+
+  .member-message-end {
+    font-size: 12px;
+    color: var(--text-tertiary);
+  }
 }
 
 .rankings-list {
@@ -1325,29 +1523,73 @@
     }
   }
 
-  .stats-cards {
+  .stats-overview {
     display: grid;
-    grid-template-columns: repeat(5, 1fr);
-    gap: 12px;
-    margin-bottom: 20px;
+    grid-template-columns: repeat(4, 1fr);
+    gap: 16px;
+    margin-bottom: 24px;
+    padding-top: 10px;
+  }
 
-    .stat-card {
-      background: transparent;
+  .stat-card {
+    display: flex;
+    align-items: center;
+    gap: 16px;
+    padding: 20px;
+    background: var(--card-bg);
+    border-radius: 12px;
+    border: 1px solid var(--border-color);
+
+    .stat-icon {
+      width: 48px;
+      height: 48px;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      background: var(--primary-light);
       border-radius: 12px;
-      padding: 16px;
-      text-align: center;
+      color: var(--primary);
+    }
 
-      .value {
-        display: block;
+    .stat-info {
+      display: flex;
+      flex-direction: column;
+      gap: 4px;
+
+      .stat-value {
         font-size: 24px;
         font-weight: 600;
-        color: var(--primary);
-        margin-bottom: 4px;
+        color: var(--text-primary);
       }
 
-      .label {
+      .stat-label {
         font-size: 13px;
-        color: var(--text-secondary);
+        color: var(--text-tertiary);
+      }
+    }
+  }
+
+  .charts-grid {
+    display: grid;
+    grid-template-columns: repeat(2, 1fr);
+    gap: 16px;
+    margin-bottom: 24px;
+
+    .chart-card {
+      background: var(--card-bg);
+      border-radius: 12px;
+      border: 1px solid var(--border-color);
+      padding: 20px;
+
+      &.wide {
+        grid-column: span 2;
+      }
+
+      h3 {
+        font-size: 15px;
+        font-weight: 500;
+        color: var(--text-primary);
+        margin: 0 0 16px;
       }
     }
   }
@@ -1405,6 +1647,16 @@
     background: rgba(30, 30, 30, 0.95);
     border: 1px solid rgba(255, 255, 255, 0.1);
   }
+
+  .member-export-modal {
+    background: rgba(30, 30, 30, 0.95);
+    border: 1px solid rgba(255, 255, 255, 0.1);
+  }
+
+  .member-result-modal {
+    background: rgba(30, 30, 30, 0.95);
+    border: 1px solid rgba(255, 255, 255, 0.1);
+  }
 }
 
 // 成员详情弹框
@@ -1496,6 +1748,34 @@
     gap: 12px;
   }
 
+  .member-modal-actions {
+    width: 100%;
+    margin-top: 18px;
+    display: flex;
+    justify-content: center;
+  }
+
+  .member-modal-primary-btn {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: 8px;
+    width: 100%;
+    border: none;
+    border-radius: 12px;
+    background: var(--primary);
+    color: #fff;
+    padding: 12px 16px;
+    font-size: 14px;
+    font-weight: 600;
+    cursor: pointer;
+    transition: opacity 0.2s;
+
+    &:hover {
+      opacity: 0.92;
+    }
+  }
+
   .detail-row {
     display: flex;
     align-items: center;
@@ -1537,3 +1817,141 @@
     }
   }
 }
+
+.member-export-modal {
+  background: rgba(255, 255, 255, 0.97);
+  border-radius: 20px;
+  padding: 28px;
+  width: min(720px, calc(100vw - 32px));
+  max-height: min(760px, calc(100vh - 32px));
+  overflow-y: auto;
+  position: relative;
+  backdrop-filter: blur(20px);
+  box-shadow: 0 20px 60px rgba(0, 0, 0, 0.3);
+
+  .modal-close {
+    position: absolute;
+    top: 16px;
+    right: 16px;
+    background: var(--bg-tertiary);
+    border: none;
+    width: 32px;
+    height: 32px;
+    border-radius: 50%;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    color: var(--text-secondary);
+    transition: all 0.15s;
+
+    &:hover {
+      background: var(--bg-hover);
+      color: var(--text-primary);
+    }
+  }
+
+  .member-export-modal-header {
+    margin-bottom: 18px;
+    padding-right: 40px;
+
+    h3 {
+      margin: 0;
+      font-size: 20px;
+      font-weight: 600;
+      color: var(--text-primary);
+    }
+
+    p {
+      margin: 6px 0 0;
+      font-size: 13px;
+      color: var(--text-secondary);
+    }
+  }
+
+  .member-export-panel {
+    gap: 18px;
+  }
+}
+
+.member-result-modal {
+  background: rgba(255, 255, 255, 0.97);
+  border-radius: 20px;
+  padding: 28px;
+  width: min(420px, calc(100vw - 32px));
+  position: relative;
+  backdrop-filter: blur(20px);
+  box-shadow: 0 20px 60px rgba(0, 0, 0, 0.3);
+
+  &.success {
+    border: 1px solid color-mix(in srgb, var(--primary) 35%, var(--border-color));
+  }
+
+  &.error {
+    border: 1px solid color-mix(in srgb, #ef4444 38%, var(--border-color));
+  }
+
+  .modal-close {
+    position: absolute;
+    top: 16px;
+    right: 16px;
+    background: var(--bg-tertiary);
+    border: none;
+    width: 32px;
+    height: 32px;
+    border-radius: 50%;
+    cursor: pointer;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    color: var(--text-secondary);
+    transition: all 0.15s;
+
+    &:hover {
+      background: var(--bg-hover);
+      color: var(--text-primary);
+    }
+  }
+}
+
+.member-result-modal-body {
+  padding-right: 40px;
+
+  h3 {
+    margin: 0;
+    font-size: 20px;
+    font-weight: 600;
+    color: var(--text-primary);
+  }
+
+  p {
+    margin: 10px 0 0;
+    font-size: 14px;
+    line-height: 1.6;
+    color: var(--text-secondary);
+    word-break: break-word;
+  }
+}
+
+.member-result-modal-actions {
+  margin-top: 24px;
+  display: flex;
+  justify-content: flex-end;
+}
+
+.member-result-modal-btn {
+  min-width: 96px;
+  border: none;
+  border-radius: 12px;
+  background: var(--primary);
+  color: #fff;
+  padding: 10px 18px;
+  font-size: 14px;
+  font-weight: 600;
+  cursor: pointer;
+  transition: opacity 0.2s;
+
+  &:hover {
+    opacity: 0.92;
+  }
+}

src/pages/NotificationWindow.scss

@@ -10,6 +10,18 @@
     }
 }
 
+@keyframes noti-enter-center {
+    0% {
+        opacity: 0;
+        transform: translateY(-50px) scale(0.7);
+    }
+
+    100% {
+        opacity: 1;
+        transform: translateY(0) scale(1);
+    }
+}
+
 @keyframes noti-exit {
     0% {
         opacity: 1;
@@ -24,6 +36,18 @@
     }
 }
 
+@keyframes noti-exit-center {
+    0% {
+        opacity: 1;
+        transform: translateY(0) scale(1);
+    }
+
+    100% {
+        opacity: 0;
+        transform: translateY(-50px) scale(0.7);
+    }
+}
+
 body {
     // Ensure the body background is transparent to let the rounded corners show
     background: transparent;
@@ -41,6 +65,10 @@ body {
     // New notification slides in
     animation: noti-enter 0.4s cubic-bezier(0.16, 1, 0.3, 1) forwards;
     will-change: transform, opacity;
+
+    &.anim-center {
+        animation: noti-enter-center 0.5s cubic-bezier(0.16, 1, 0.3, 1) forwards;
+    }
 }
 
 #notification-prev {
@@ -51,4 +79,8 @@ body {
 
     // Ensure it stays behind
     z-index: 0 !important;
+
+    &.anim-center {
+        animation: noti-exit-center 0.5s cubic-bezier(0.33, 1, 0.68, 1) forwards;
+    }
 }

src/pages/NotificationWindow.tsx

@@ -6,8 +6,9 @@ import './NotificationWindow.scss'
 export default function NotificationWindow() {
     const [notification, setNotification] = useState<NotificationData | null>(null)
     const [prevNotification, setPrevNotification] = useState<NotificationData | null>(null)
+    const [position, setPosition] = useState<string>('top-right')
 
-    // We need a ref to access the current notification inside the callback 
+    // We need a ref to access the current notification inside the callback
     // without satisfying the dependency array which would recreate the listener
     // Actually, setNotification(prev => ...) pattern is better, but we need the VALUE of current to set as prev.
     // So we use setNotification callback: setNotification(current => { ... return newNode })
@@ -34,6 +35,11 @@ export default function NotificationWindow() {
                 avatarUrl: data.avatarUrl
             }
 
+            // 获取位置配置
+            if (data.position) {
+                setPosition(data.position)
+            }
+
             // Set previous to current (ref)
             if (notificationRef.current) {
                 setPrevNotification(notificationRef.current)
@@ -117,6 +123,7 @@ export default function NotificationWindow() {
                 <div
                     id="notification-prev"
                     key={prevNotification.id}
+                    className={position === 'top-center' ? 'anim-center' : ''}
                     style={{
                         position: 'absolute',
                         top: 2, // Match padding
@@ -131,7 +138,7 @@ export default function NotificationWindow() {
                         data={prevNotification}
                         onClose={() => { }} // No-op for background item
                         onClick={() => { }}
-                        position="top-right"
+                        position={position as any}
                         isStatic={true}
                         initialVisible={true}
                     />
@@ -143,6 +150,7 @@ export default function NotificationWindow() {
                 <div
                     id="notification-current"
                     key={notification.id}
+                    className={position === 'top-center' ? 'anim-center' : ''}
                     style={{
                         position: 'relative', // Takes up space
                         zIndex: 2,
@@ -154,7 +162,7 @@ export default function NotificationWindow() {
                         data={notification}
                         onClose={handleClose}
                         onClick={handleClick}
-                        position="top-right"
+                        position={position as any}
                         isStatic={true}
                         initialVisible={true}
                     />