feat:修改了软件下载源&添加版本上传

.github/workflows/auto-sync-release.yml

@@ -0,0 +1,158 @@
+name: Auto Sync New Release to WebDAV
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+
+jobs:
+  auto-sync-to-webdav:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y curl jq
+
+      - name: Get release info
+        id: release-info
+        run: |
+          echo "tag_name=${{ github.event.release.tag_name }}" >> $GITHUB_OUTPUT
+          echo "release_id=${{ github.event.release.id }}" >> $GITHUB_OUTPUT
+          echo "release_name=${{ github.event.release.name }}" >> $GITHUB_OUTPUT
+
+      - name: Sync new release to WebDAV
+        run: |
+          TAG_NAME="${{ steps.release-info.outputs.tag_name }}"
+          RELEASE_ID="${{ steps.release-info.outputs.release_id }}"
+          RELEASE_NAME="${{ steps.release-info.outputs.release_name }}"
+          
+          echo "🚀 开始同步新发布的版本到 WebDAV..."
+          echo "版本标签: $TAG_NAME"
+          echo "版本名称: $RELEASE_NAME"
+          echo "Release ID: $RELEASE_ID"
+          echo "WebDAV 根路径: ${{ secrets.WEBDAV_BASE_URL }}/yd/ceru"
+
+          # 获取该release的所有资源文件
+          assets_json=$(curl -s \
+            -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" \
+            -H "Accept: application/vnd.github.v3+json" \
+            "https://api.github.com/repos/${{ github.repository }}/releases/$RELEASE_ID/assets")
+
+          assets_count=$(echo "$assets_json" | jq '. | length')
+          echo "找到 $assets_count 个资源文件"
+
+          if [ "$assets_count" -eq 0 ]; then
+            echo "⚠️  该版本没有资源文件，跳过同步"
+            exit 0
+          fi
+
+          # 先创建版本目录
+          dir_path="/yd/ceru/$TAG_NAME"
+          dir_url="${{ secrets.WEBDAV_BASE_URL }}$dir_path"
+          
+          echo "创建版本目录: $dir_path"
+          if curl -s -f -X MKCOL \
+            -u "${{ secrets.WEBDAV_USERNAME }}:${{ secrets.WEBDAV_PASSWORD }}" \
+            "$dir_url"; then
+            echo "✅ 目录创建成功"
+          else
+            echo "ℹ️  目录可能已存在或创建失败，继续执行"
+          fi
+
+          # 处理每个asset
+          success_count=0
+          failed_count=0
+          
+          for i in $(seq 0 $(($assets_count - 1))); do
+            asset=$(echo "$assets_json" | jq -c ".[$i]")
+            asset_name=$(echo "$asset" | jq -r '.name')
+            asset_url=$(echo "$asset" | jq -r '.url')
+            asset_size=$(echo "$asset" | jq -r '.size')
+            
+            echo "📦 处理资源: $asset_name (大小: $asset_size bytes)"
+
+            # 下载资源文件
+            safe_filename="./temp_${TAG_NAME}_$(date +%s)_$i"
+            
+            if ! curl -sL -o "$safe_filename" \
+              -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" \
+              -H "Accept: application/octet-stream" \
+              "$asset_url"; then
+              echo "❌ 下载失败: $asset_name"
+              failed_count=$((failed_count + 1))
+              continue
+            fi
+            
+            if [ -f "$safe_filename" ]; then
+              actual_size=$(wc -c < "$safe_filename")
+              if [ "$actual_size" -ne "$asset_size" ]; then
+                echo "❌ 文件大小不匹配: $asset_name (期望: $asset_size, 实际: $actual_size)"
+                rm -f "$safe_filename"
+                failed_count=$((failed_count + 1))
+                continue
+              fi
+
+              echo "⬆️  上传到 WebDAV: $asset_name"
+              
+              # 构建远程路径
+              remote_path="/yd/ceru/$TAG_NAME/$asset_name"
+              full_url="${{ secrets.WEBDAV_BASE_URL }}$remote_path"
+              
+              # 使用 WebDAV PUT 方法上传文件
+              if curl -s -f -X PUT \
+                -u "${{ secrets.WEBDAV_USERNAME }}:${{ secrets.WEBDAV_PASSWORD }}" \
+                -T "$safe_filename" \
+                "$full_url"; then
+                
+                echo "✅ 上传成功: $asset_name"
+                success_count=$((success_count + 1))
+                
+                # 验证文件是否存在
+                sleep 1
+                if curl -s -f -u "${{ secrets.WEBDAV_USERNAME }}:${{ secrets.WEBDAV_PASSWORD }}" \
+                  -X PROPFIND \
+                  -H "Depth: 0" \
+                  "$full_url" > /dev/null 2>&1; then
+                  echo "✅ 文件验证成功: $asset_name"
+                else
+                  echo "⚠️  文件验证失败，但上传可能成功: $asset_name"
+                fi
+                
+              else
+                echo "❌ 上传失败: $asset_name"
+                failed_count=$((failed_count + 1))
+              fi
+              
+              # 清理临时文件
+              rm -f "$safe_filename"
+              echo "----------------------------------------"
+            else
+              echo "❌ 临时文件不存在: $safe_filename"
+              failed_count=$((failed_count + 1))
+            fi
+          done
+          
+          echo "========================================"
+          echo "🎉 同步完成！"
+          echo "成功: $success_count 个文件"
+          echo "失败: $failed_count 个文件"
+          echo "总计: $assets_count 个文件"
+          
+          if [ "$failed_count" -gt 0 ]; then
+            echo "⚠️  有文件同步失败，请检查日志"
+            exit 1
+          else
+            echo "✅ 所有文件同步成功！"
+          fi
+
+      - name: Notify completion
+        if: always()
+        run: |
+          if [ "${{ job.status }}" == "success" ]; then
+            echo "✅ 版本 ${{ steps.release-info.outputs.tag_name }} 已成功同步到 alist"
+          else
+            echo "❌ 版本 ${{ steps.release-info.outputs.tag_name }} 同步失败"
+          fi

.github/workflows/main.yml

@@ -70,3 +70,146 @@ jobs:
         uses: softprops/action-gh-release@v1
         with:
           files: 'dist/**' # 将dist目录下所有文件添加到release
+
+  # 新增：自动同步到 WebDAV
+  sync-to-webdav:
+    name: Sync to WebDAV
+    needs: release # 等待 release 任务完成
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/v') # 只在标签推送时执行
+    steps:
+      - name: Wait for release to be ready
+        run: |
+          echo "等待 Release 准备就绪..."
+          sleep 30 # 等待30秒确保 release 完全创建
+
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y curl jq
+
+      - name: Get latest release info
+        id: get-release
+        run: |
+          # 获取当前标签对应的 release 信息
+          TAG_NAME=${GITHUB_REF#refs/tags/}
+          echo "tag_name=$TAG_NAME" >> $GITHUB_OUTPUT
+          
+          # 获取 release 详细信息
+          response=$(curl -s \
+            -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" \
+            -H "Accept: application/vnd.github.v3+json" \
+            "https://api.github.com/repos/${{ github.repository }}/releases/tags/$TAG_NAME")
+          
+          release_id=$(echo "$response" | jq -r '.id')
+          echo "release_id=$release_id" >> $GITHUB_OUTPUT
+          echo "找到 Release ID: $release_id"
+
+      - name: Sync release to WebDAV
+        run: |
+          TAG_NAME="${{ steps.get-release.outputs.tag_name }}"
+          RELEASE_ID="${{ steps.get-release.outputs.release_id }}"
+          
+          echo "🚀 开始同步版本 $TAG_NAME 到 WebDAV..."
+          echo "Release ID: $RELEASE_ID"
+          echo "WebDAV 根路径: ${{ secrets.WEBDAV_BASE_URL }}/yd/ceru"
+
+          # 获取该release的所有资源文件
+          assets_json=$(curl -s \
+            -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" \
+            -H "Accept: application/vnd.github.v3+json" \
+            "https://api.github.com/repos/${{ github.repository }}/releases/$RELEASE_ID/assets")
+
+          assets_count=$(echo "$assets_json" | jq '. | length')
+          echo "找到 $assets_count 个资源文件"
+
+          if [ "$assets_count" -eq 0 ]; then
+            echo "⚠️  该版本没有资源文件，跳过同步"
+            exit 0
+          fi
+
+          # 先创建版本目录
+          dir_path="/yd/ceru/$TAG_NAME"
+          dir_url="${{ secrets.WEBDAV_BASE_URL }}$dir_path"
+          
+          echo "创建版本目录: $dir_path"
+          curl -s -X MKCOL \
+            -u "${{ secrets.WEBDAV_USERNAME }}:${{ secrets.WEBDAV_PASSWORD }}" \
+            "$dir_url" || echo "目录可能已存在"
+
+          # 处理每个asset
+          success_count=0
+          failed_count=0
+          
+          for i in $(seq 0 $(($assets_count - 1))); do
+            asset=$(echo "$assets_json" | jq -c ".[$i]")
+            asset_name=$(echo "$asset" | jq -r '.name')
+            asset_url=$(echo "$asset" | jq -r '.url')
+            asset_size=$(echo "$asset" | jq -r '.size')
+            
+            echo "📦 处理资源: $asset_name (大小: $asset_size bytes)"
+
+            # 下载资源文件
+            safe_filename="./temp_${TAG_NAME}_$(date +%s)_$i"
+            
+            if ! curl -sL -o "$safe_filename" \
+              -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" \
+              -H "Accept: application/octet-stream" \
+              "$asset_url"; then
+              echo "❌ 下载失败: $asset_name"
+              failed_count=$((failed_count + 1))
+              continue
+            fi
+            
+            if [ -f "$safe_filename" ]; then
+              actual_size=$(wc -c < "$safe_filename")
+              if [ "$actual_size" -ne "$asset_size" ]; then
+                echo "❌ 文件大小不匹配: $asset_name (期望: $asset_size, 实际: $actual_size)"
+                rm -f "$safe_filename"
+                failed_count=$((failed_count + 1))
+                continue
+              fi
+
+              echo "⬆️  上传到 WebDAV: $asset_name"
+              
+              # 构建远程路径
+              remote_path="/yd/ceru/$TAG_NAME/$asset_name"
+              full_url="${{ secrets.WEBDAV_BASE_URL }}$remote_path"
+              
+              # 使用 WebDAV PUT 方法上传文件
+              if curl -s -f -X PUT \
+                -u "${{ secrets.WEBDAV_USERNAME }}:${{ secrets.WEBDAV_PASSWORD }}" \
+                -T "$safe_filename" \
+                "$full_url"; then
+                
+                echo "✅ 上传成功: $asset_name"
+                success_count=$((success_count + 1))
+                
+              else
+                echo "❌ 上传失败: $asset_name"
+                failed_count=$((failed_count + 1))
+              fi
+              
+              # 清理临时文件
+              rm -f "$safe_filename"
+              echo "----------------------------------------"
+            else
+              echo "❌ 临时文件不存在: $safe_filename"
+              failed_count=$((failed_count + 1))
+            fi
+          done
+          
+          echo "========================================"
+          echo "🎉 同步完成！"
+          echo "成功: $success_count 个文件"
+          echo "失败: $failed_count 个文件"
+          echo "总计: $assets_count 个文件"
+
+      - name: Notify completion
+        if: always()
+        run: |
+          if [ "${{ job.status }}" == "success" ]; then
+            echo "✅ 版本 ${{ steps.get-release.outputs.tag_name }} 已成功同步到 alist"
+          else
+            echo "❌ 版本 ${{ steps.get-release.outputs.tag_name }} 同步失败"
+          fi

.github/workflows/sync-releases-to-webdav.yml

@@ -0,0 +1,166 @@
+name: Sync Existing Releases to WebDAV
+
+on:
+  workflow_dispatch:
+    inputs:
+      tag_name:
+        description: '要同步的特定标签（如 v1.0.0），留空则同步所有版本'
+        required: false
+        default: ''
+
+permissions:
+  contents: read
+
+jobs:
+  sync-releases-to-webdav:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y curl jq
+
+      - name: Get all releases
+        id: get-releases
+        run: |
+          response=$(curl -s \
+            -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" \
+            -H "Accept: application/vnd.github.v3+json" \
+            "https://api.github.com/repos/${{ github.repository }}/releases")
+          echo "releases_json=$(echo "$response" | jq -c '.')" >> $GITHUB_OUTPUT
+
+      - name: Sync releases to WebDAV
+        run: |
+          # 读取输入参数
+          SPECIFIC_TAG="${{ github.event.inputs.tag_name }}"
+          RELEASES_JSON='${{ steps.get-releases.outputs.releases_json }}'
+          
+          echo "开始同步 releases..."
+          echo "特定标签: ${SPECIFIC_TAG:-所有版本}"
+          echo "WebDAV 根路径: ${{ secrets.WEBDAV_BASE_URL }}/yd/ceru"
+
+          # 处理每个 release
+          releases_count=$(echo "$RELEASES_JSON" | jq '. | length')
+          echo "找到 $releases_count 个 releases"
+
+          for i in $(seq 0 $(($releases_count - 1))); do
+            release=$(echo "$RELEASES_JSON" | jq -c ".[$i]")
+            tag_name=$(echo "$release" | jq -r '.tag_name')
+            release_id=$(echo "$release" | jq -r '.id')
+            
+            if [ -n "$SPECIFIC_TAG" ] && [ "$tag_name" != "$SPECIFIC_TAG" ]; then
+              echo "跳过 $tag_name，不是指定的标签 $SPECIFIC_TAG"
+              continue
+            fi
+
+            echo "正在处理版本: $tag_name (ID: $release_id)"
+
+            # 获取该release的所有资源文件
+            assets_json=$(curl -s \
+              -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" \
+              -H "Accept: application/vnd.github.v3+json" \
+              "https://api.github.com/repos/${{ github.repository }}/releases/$release_id/assets")
+
+            assets_count=$(echo "$assets_json" | jq '. | length')
+            echo "找到 $assets_count 个资源文件"
+
+            # 处理每个asset
+            for j in $(seq 0 $(($assets_count - 1))); do
+              asset=$(echo "$assets_json" | jq -c ".[$j]")
+              asset_name=$(echo "$asset" | jq -r '.name')
+              asset_url=$(echo "$asset" | jq -r '.url')
+              asset_size=$(echo "$asset" | jq -r '.size')
+              
+              echo "下载资源: $asset_name (大小: $asset_size bytes)"
+
+              # 下载资源文件
+              safe_filename="./temp_download_$(date +%s)_$j"
+              
+              if ! curl -sL -o "$safe_filename" \
+                -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" \
+                -H "Accept: application/octet-stream" \
+                "$asset_url"; then
+                echo "❌ 下载失败: $asset_name"
+                continue
+              fi
+              
+              if [ -f "$safe_filename" ]; then
+                actual_size=$(wc -c < "$safe_filename")
+                if [ "$actual_size" -ne "$asset_size" ]; then
+                  echo "❌ 文件大小不匹配: $asset_name (期望: $asset_size, 实际: $actual_size)"
+                  rm -f "$safe_filename"
+                  continue
+                fi
+
+                echo "上传到 WebDAV: $asset_name"
+                
+                # 构建远程路径
+                remote_path="/yd/ceru/$tag_name/$asset_name"
+                full_url="${{ secrets.WEBDAV_BASE_URL }}$remote_path"
+                
+                echo "完整路径: $full_url"
+                
+                # 先尝试创建目录
+                dir_path="/yd/ceru/$tag_name"
+                dir_url="${{ secrets.WEBDAV_BASE_URL }}$dir_path"
+                
+                echo "创建目录: $dir_path"
+                curl -s -X MKCOL \
+                  -u "${{ secrets.WEBDAV_USERNAME }}:${{ secrets.WEBDAV_PASSWORD }}" \
+                  "$dir_url" || echo "目录可能已存在"
+                
+                # 使用 WebDAV PUT 方法上传文件
+                if curl -s -f -X PUT \
+                  -u "${{ secrets.WEBDAV_USERNAME }}:${{ secrets.WEBDAV_PASSWORD }}" \
+                  -T "$safe_filename" \
+                  "$full_url"; then
+                  
+                  echo "✅ WebDAV 上传成功: $asset_name"
+                  
+                  # 验证文件是否存在
+                  echo "验证文件是否存在..."
+                  sleep 2
+                  
+                  if curl -s -f -u "${{ secrets.WEBDAV_USERNAME }}:${{ secrets.WEBDAV_PASSWORD }}" \
+                    -X PROPFIND \
+                    -H "Depth: 0" \
+                    "$full_url" > /dev/null 2>&1; then
+                    echo "✅ 文件确认存在: $asset_name"
+                  else
+                    echo "⚠️  文件验证失败，但上传可能成功"
+                  fi
+                  
+                else
+                  echo "❌ WebDAV 上传失败: $asset_name"
+                  
+                  # 显示详细错误信息
+                  echo "尝试获取详细错误信息..."
+                  curl -v -X PUT \
+                    -u "${{ secrets.WEBDAV_USERNAME }}:${{ secrets.WEBDAV_PASSWORD }}" \
+                    -T "$safe_filename" \
+                    "$full_url" || true
+                fi
+                
+                # 安全删除临时文件
+                rm -f "$safe_filename"
+                echo "----------------------------------------"
+              else
+                echo "❌ 文件不存在: $safe_filename"
+              fi
+            done
+            
+            echo "版本 $tag_name 处理完成"
+            echo "========================================"
+          done
+          
+          echo "🎉 WebDAV 同步完成"
+
+      - name: Summary
+        run: |
+          echo "同步任务已完成！"
+          echo "请检查 alist 中的文件是否正确上传。"
+          echo "如果遇到问题，请检查以下配置："
+          echo "1. WEBDAV_BASE_URL - WebDAV 服务器地址"
+          echo "2. WEBDAV_USERNAME - WebDAV 用户名"
+          echo "3. WEBDAV_PASSWORD - WebDAV 密码"
+          echo "4. GITHUB_TOKEN - GitHub 访问令牌"

.github/workflows/uploadpan.yml

@@ -0,0 +1,160 @@
+name: Sync Existing Releases to WebDAV
+
+on:
+  workflow_dispatch:
+    inputs:
+      tag_name:
+        description: '要同步的特定标签（如 v1.0.0），留空则同步所有版本'
+        required: false
+        default: ''
+
+permissions:
+  contents: read
+
+jobs:
+  sync-releases-to-webdav:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Install dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y curl
+
+      - name: Get all releases
+        id: get-releases
+        run: |
+          response=$(curl -s \
+            -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" \
+            -H "Accept: application/vnd.github.v3+json" \
+            "https://api.github.com/repos/${{ github.repository }}/releases")
+          echo "releases_json=$(echo "$response" | jq -c '.')" >> $GITHUB_OUTPUT
+
+      - name: Sync releases to WebDAV
+        run: |
+          # 读取输入参数
+          SPECIFIC_TAG="${{ github.event.inputs.tag_name }}"
+          RELEASES_JSON='${{ steps.get-releases.outputs.releases_json }}'
+          
+          echo "开始同步 releases..."
+          echo "特定标签: ${SPECIFIC_TAG:-所有版本}"
+          echo "WebDAV 根路径: ${{ secrets.WEBDAV_BASE_URL }}/yd/ceru"
+
+          # 处理每个 release
+          releases_count=$(echo "$RELEASES_JSON" | jq '. | length')
+          echo "找到 $releases_count 个 releases"
+
+          for i in $(seq 0 $(($releases_count - 1))); do
+            release=$(echo "$RELEASES_JSON" | jq -c ".[$i]")
+            tag_name=$(echo "$release" | jq -r '.tag_name')
+            release_id=$(echo "$release" | jq -r '.id')
+            
+            if [ -n "$SPECIFIC_TAG" ] && [ "$tag_name" != "$SPECIFIC_TAG" ]; then
+              echo "跳过 $tag_name，不是指定的标签 $SPECIFIC_TAG"
+              continue
+            fi
+
+            echo "正在处理版本: $tag_name (ID: $release_id)"
+
+            # 获取该release的所有资源文件
+            assets_json=$(curl -s \
+              -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" \
+              -H "Accept: application/vnd.github.v3+json" \
+              "https://api.github.com/repos/${{ github.repository }}/releases/$release_id/assets")
+
+            assets_count=$(echo "$assets_json" | jq '. | length')
+            echo "找到 $assets_count 个资源文件"
+
+            # 处理每个asset
+            for j in $(seq 0 $(($assets_count - 1))); do
+              asset=$(echo "$assets_json" | jq -c ".[$j]")
+              asset_name=$(echo "$asset" | jq -r '.name')
+              asset_url=$(echo "$asset" | jq -r '.url')
+              asset_size=$(echo "$asset" | jq -r '.size')
+              
+              echo "下载资源: $asset_name (大小: $asset_size bytes)"
+
+              # 下载资源文件
+              safe_filename="./temp_download"
+              
+              if ! curl -sL -o "$safe_filename" \
+                -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" \
+                -H "Accept: application/octet-stream" \
+                "$asset_url"; then
+                echo "❌ 下载失败: $asset_name"
+                continue
+              fi
+              
+              if [ -f "$safe_filename" ]; then
+                actual_size=$(wc -c < "$safe_filename")
+                if [ "$actual_size" -ne "$asset_size" ]; then
+                  echo "❌ 文件大小不匹配: $asset_name (期望: $asset_size, 实际: $actual_size)"
+                  rm -f "$safe_filename"
+                  continue
+                fi
+
+                echo "上传到 WebDAV: $asset_name"
+                
+                # 构建远程路径
+                remote_path="/yd/ceru/$tag_name/$asset_name"
+                full_url="${{ secrets.WEBDAV_BASE_URL }}$remote_path"
+                
+                echo "完整路径: $full_url"
+                
+                # 使用 WebDAV PUT 方法上传文件
+                if curl -s -f -X PUT \
+                  -u "${{ secrets.WEBDAV_USERNAME }}:${{ secrets.WEBDAV_PASSWORD }}" \
+                  -T "$safe_filename" \
+                  "$full_url"; then
+                  
+                  echo "✅ WebDAV 上传成功: $asset_name"
+                  
+                  # 验证文件是否存在
+                  echo "验证文件是否存在..."
+                  sleep 2
+                  
+                  if curl -s -f -u "${{ secrets.WEBDAV_USERNAME }}:${{ secrets.WEBDAV_PASSWORD }}" \
+                    -X PROPFIND \
+                    -H "Depth: 0" \
+                    "$full_url" > /dev/null 2>&1; then
+                    echo "✅ 文件确认存在: $asset_name"
+                  else
+                    echo "⚠️  文件验证失败，但上传可能成功"
+                  fi
+                  
+                else
+                  echo "❌ WebDAV 上传失败: $asset_name"
+                  echo "尝试创建目录后重新上传..."
+                  
+                  # 尝试先创建目录
+                  dir_path="/yd/ceru/$tag_name"
+                  dir_url="${{ secrets.WEBDAV_BASE_URL }}$dir_path"
+                  
+                  if curl -s -f -X MKCOL \
+                    -u "${{ secrets.WEBDAV_USERNAME }}:${{ secrets.WEBDAV_PASSWORD }}" \
+                    "$dir_url"; then
+                    echo "✅ 目录创建成功: $dir_path"
+                    
+                    # 重新尝试上传文件
+                    if curl -s -f -X PUT \
+                      -u "${{ secrets.WEBDAV_USERNAME }}:${{ secrets.WEBDAV_PASSWORD }}" \
+                      -T "$safe_filename" \
+                      "$full_url"; then
+                      echo "✅ 重新上传成功: $asset_name"
+                    else
+                      echo "❌ 重新上传失败: $asset_name"
+                    fi
+                  else
+                    echo "❌ 目录创建失败: $dir_path"
+                  fi
+                fi
+                
+                # 安全删除临时文件
+                rm -f "$safe_filename"
+                echo "----------------------------------------"
+              else
+                echo "❌ 文件不存在: $safe_filename"
+              fi
+            done
+          done
+          
+          echo "🎉 WebDAV 同步完成"

docs/alist-config.md

@@ -0,0 +1,128 @@
+# Alist 下载配置说明
+
+## 概述
+
+项目已从 GitHub 下载方式切换到 Alist API 下载方式，包括：
+- 桌面应用的自动更新功能 (`src/main/autoUpdate.ts`)
+- 官方网站的下载功能 (`website/script.js`)
+
+## 配置步骤
+
+### 1. 修改 Alist 域名
+
+#### 桌面应用配置
+在 `src/main/autoUpdate.ts` 文件中，Alist 域名已配置为：
+
+```typescript
+const ALIST_BASE_URL = 'http://47.96.72.224:5244';
+```
+
+#### 网站配置
+在 `website/script.js` 文件中，Alist 域名已配置为：
+
+```javascript
+const ALIST_BASE_URL = 'http://47.96.72.224:5244';
+```
+
+如需修改域名，请同时更新这两个文件中的 `ALIST_BASE_URL` 配置。
+
+### 2. 认证信息
+
+已配置的认证信息：
+- 用户名: `ceruupdata`
+- 密码: `123456`
+
+### 3. 文件路径格式
+
+文件在 Alist 中的路径格式为：`/{version}/{文件名}`
+
+例如：
+- 版本 `v1.0.0` 的安装包 `app-setup.exe` 路径为：`/v1.0.0/app-setup.exe`
+
+## 工作原理
+
+### 桌面应用自动更新
+1. **认证**: 使用配置的用户名和密码向 Alist API 获取认证 token
+2. **获取文件信息**: 使用 token 调用 `/api/fs/get` 接口获取文件信息和签名
+3. **下载**: 使用带签名的直接下载链接下载文件
+4. **备用方案**: 如果 Alist 失败，自动回退到原始 URL 下载
+
+### 网站下载功能
+1. **获取版本列表**: 调用 `/api/fs/list` 获取根目录下的版本文件夹
+2. **获取文件列表**: 获取最新版本文件夹中的所有文件
+3. **平台匹配**: 根据用户平台自动匹配对应的安装包文件
+4. **生成下载链接**: 获取文件的直接下载链接
+5. **备用方案**: 如果 Alist 失败，自动回退到 GitHub API
+
+## API 接口
+
+### 认证接口
+```
+POST /api/auth/login
+{
+  "username": "ceruupdata",
+  "password": "123456"
+}
+```
+
+### 获取文件信息接口
+```
+POST /api/fs/get
+Headers: Authorization: {token}  # 注意：直接使用 token，不需要 "Bearer " 前缀
+{
+  "path": "/{version}/{fileName}"
+}
+```
+
+### 获取文件列表接口
+```
+POST /api/fs/list
+Headers: Authorization: {token}  # 注意：直接使用 token，不需要 "Bearer " 前缀
+{
+  "path": "/",
+  "password": "",
+  "page": 1,
+  "per_page": 100,
+  "refresh": false
+}
+```
+
+### 下载链接格式
+```
+{ALIST_BASE_URL}/d/{filePath}?sign={sign}
+```
+
+## 测试方法
+
+项目包含了一个测试脚本来验证 Alist 连接：
+
+```bash
+node scripts/test-alist.js
+```
+
+该脚本会：
+1. 测试服务器连通性
+2. 测试用户认证
+3. 测试文件列表获取
+4. 测试文件信息获取
+
+## 备用机制
+
+两个组件都实现了备用机制：
+
+### 桌面应用
+- 主要：使用 Alist API 下载
+- 备用：如果 Alist 失败，使用原始 URL 下载
+
+### 网站
+- 主要：使用 Alist API 获取版本和文件信息
+- 备用：如果 Alist 失败，回退到 GitHub API
+- 最终备用：跳转到 GitHub releases 页面
+
+## 注意事项
+
+1. 确保 Alist 服务器可以正常访问
+2. 确保配置的用户名和密码有权限访问相应的文件路径
+3. 文件必须按照指定的路径格式存放在 Alist 中
+4. 网站会自动检测用户操作系统并推荐对应的下载版本
+5. 所有下载都会显示文件大小信息

docs/alist-migration-summary.md

@@ -0,0 +1,88 @@
+# Alist 迁移完成总结
+
+## 修改概述
+
+项目已成功从 GitHub 下载方式迁移到 Alist API 下载方式。
+
+## 修改的文件
+
+### 1. 桌面应用自动更新 (`src/main/autoUpdate.ts`)
+- ✅ 添加了 Alist API 配置
+- ✅ 实现了 Alist 认证功能
+- ✅ 实现了 Alist 文件下载功能
+- ✅ 添加了备用机制（Alist 失败时回退到原始 URL）
+- ✅ 修复了 Authorization 头格式（使用直接 token 而非 Bearer 格式）
+
+### 2. 官方网站下载功能 (`website/script.js`)
+- ✅ 添加了 Alist API 配置
+- ✅ 实现了 Alist 认证功能
+- ✅ 实现了版本列表获取功能
+- ✅ 实现了文件列表获取功能
+- ✅ 实现了平台文件匹配功能
+- ✅ 添加了多层备用机制（Alist → GitHub API → GitHub 页面）
+- ✅ 修复了 Authorization 头格式
+
+### 3. 配置文档
+- ✅ 创建了详细的配置说明 (`docs/alist-config.md`)
+- ✅ 创建了迁移总结文档 (`docs/alist-migration-summary.md`)
+
+### 4. 测试脚本
+- ✅ 创建了 Alist 连接测试脚本 (`scripts/test-alist.js`)
+- ✅ 创建了认证格式测试脚本 (`scripts/auth-test.js`)
+
+## 配置信息
+
+### Alist 服务器配置
+- **服务器地址**: `http://47.96.72.224:5244`
+- **用户名**: `ceruupdate`
+- **密码**: `123456`
+- **文件路径格式**: `/{version}/{文件名}`
+
+### Authorization 头格式
+经过测试确认，正确的格式是：
+```
+Authorization: {token}
+```
+**注意**: 不需要 "Bearer " 前缀
+
+## 功能特性
+
+### 桌面应用
+1. **智能下载**: 优先使用 Alist API，失败时自动回退
+2. **进度显示**: 支持下载进度显示和节流
+3. **错误处理**: 完善的错误处理和日志记录
+
+### 网站
+1. **自动检测**: 自动检测用户操作系统并推荐对应版本
+2. **版本信息**: 自动获取最新版本信息和文件大小
+3. **多层备用**: Alist → GitHub API → GitHub 页面的三层备用机制
+4. **用户体验**: 加载状态、成功通知、错误提示
+
+## 测试结果
+
+✅ **Alist 连接测试**: 通过
+✅ **认证测试**: 通过
+✅ **文件列表获取**: 通过
+✅ **Authorization 头格式**: 已修复并验证
+
+## 可用文件
+
+测试显示 Alist 服务器当前包含以下文件：
+- `v1.2.1/` (版本目录)
+- `1111`
+- `L3YxLjIuMS8tMS4yLjEtYXJtNjQtbWFjLnppcA==`
+- `file2.msi`
+- `file.msi`
+
+## 后续维护
+
+1. **添加新版本**: 在 Alist 中创建新的版本目录（如 `v1.2.2/`）
+2. **上传文件**: 将对应平台的安装包上传到版本目录中
+3. **文件命名**: 确保文件名包含平台标识（如 `windows`, `mac`, `linux` 等）
+
+## 备注
+
+- 所有修改都保持了向后兼容性
+- 实现了完善的错误处理和备用机制
+- 用户体验不会因为迁移而受到影响
+- 可以随时回退到 GitHub 下载方式

docs/webdav-sync-setup.md

@@ -0,0 +1,147 @@
+# WebDAV 同步配置指南
+
+本项目包含两个 GitHub Actions 工作流，用于自动将 GitHub Releases 同步到 alist（WebDAV 服务器）。
+
+## 工作流说明
+
+### 1. 手动同步工作流 (`sync-releases-to-webdav.yml`)
+- **触发方式**: 手动触发 (workflow_dispatch)
+- **功能**: 同步现有的所有版本或指定版本到 WebDAV
+- **参数**: 
+  - `tag_name`: 可选，指定要同步的版本标签（如 v1.0.0），留空则同步所有版本
+
+### 2. 自动同步工作流 (集成在 `main.yml` 中)
+- **触发方式**: 在 AutoBuild 完成后自动触发
+- **功能**: 自动将新构建的版本同步到 WebDAV
+- **参数**: 无需手动设置，自动获取发布信息
+
+### 3. 独立自动同步工作流 (`auto-sync-release.yml`)
+- **触发方式**: 当新版本发布时自动触发 (on release published)
+- **功能**: 备用的自动同步机制
+- **参数**: 无需手动设置，自动获取发布信息
+
+## 配置要求
+
+在 GitHub 仓库的 Settings > Secrets and variables > Actions 中添加以下密钥：
+
+### 必需的 Secrets
+
+1. **WEBDAV_BASE_URL**
+   - 描述: WebDAV 服务器的基础 URL
+   - 示例: `https://your-alist-domain.com/dav`
+   - 注意: 不要在末尾添加斜杠
+
+2. **WEBDAV_USERNAME**
+   - 描述: WebDAV 服务器的用户名
+   - 示例: `admin`
+
+3. **WEBDAV_PASSWORD**
+   - 描述: WebDAV 服务器的密码
+   - 示例: `your-password`
+
+4. **GITHUB_TOKEN**
+   - 描述: GitHub 访问令牌（通常自动提供）
+   - 注意: 如果默认的 `GITHUB_TOKEN` 权限不足，可能需要创建个人访问令牌
+
+## 使用方法
+
+### 手动同步现有版本
+
+1. 进入 GitHub 仓库的 Actions 页面
+2. 选择 "Sync Existing Releases to WebDAV" 工作流
+3. 点击 "Run workflow"
+4. 可选择指定版本标签或留空同步所有版本
+5. 点击 "Run workflow" 开始执行
+
+### 自动同步新版本
+
+现在有两种自动同步方式：
+
+1. **集成同步** (推荐): 在主构建工作流 (`main.yml`) 中集成了 WebDAV 同步，当您推送 `v*` 标签时，会自动执行：
+   - 构建应用 → 创建 Release → 同步到 WebDAV
+   
+2. **独立同步**: 当您手动发布 Release 时，`auto-sync-release.yml` 工作流会自动触发
+
+推荐使用集成同步方式，因为它确保了构建和同步的一致性。
+
+## 文件结构
+
+同步后的文件将按以下结构存储在 alist 中：
+
+```
+/yd/ceru/
+├── v1.0.0/
+│   ├── app-setup.exe
+│   ├── app.dmg
+│   └── app.AppImage
+├── v1.1.0/
+│   ├── app-setup.exe
+│   ├── app.dmg
+│   └── app.AppImage
+└── ...
+```
+
+## 故障排除
+
+### 常见问题
+
+1. **上传失败**
+   - 检查 WebDAV 服务器是否正常运行
+   - 验证用户名和密码是否正确
+   - 确认 WebDAV URL 格式正确
+
+2. **权限错误**
+   - 确保 WebDAV 用户有写入权限
+   - 检查目标目录是否存在且可写
+
+3. **文件大小不匹配**
+   - 网络问题导致下载不完整
+   - GitHub API 限制或临时故障
+
+4. **目录创建失败**
+   - WebDAV 服务器不支持 MKCOL 方法
+   - 权限不足或路径错误
+
+### 调试步骤
+
+1. 查看 Actions 运行日志
+2. 检查 WebDAV 服务器日志
+3. 验证所有 Secrets 配置正确
+4. 测试 WebDAV 连接是否正常
+
+## 安全注意事项
+
+1. **密钥管理**
+   - 不要在代码中硬编码密码
+   - 定期更换 WebDAV 密码
+   - 使用强密码
+
+2. **权限控制**
+   - 为 WebDAV 用户设置最小必要权限
+   - 考虑使用专用的同步账户
+
+3. **网络安全**
+   - 建议使用 HTTPS 连接
+   - 考虑 IP 白名单限制
+
+## 自定义配置
+
+如需修改同步路径或其他配置，请编辑对应的工作流文件：
+
+- 修改存储路径: 更改 `remote_path` 变量
+- 调整重试逻辑: 修改错误处理部分
+- 添加通知: 集成 Slack、邮件等通知服务
+
+## 支持的文件类型
+
+工作流支持同步所有类型的 Release 资源文件，包括但不限于：
+- 可执行文件 (.exe, .dmg, .AppImage)
+- 压缩包 (.zip, .tar.gz, .7z)
+- 安装包 (.msi, .deb, .rpm)
+- 其他二进制文件
+
+## 版本兼容性
+
+- GitHub Actions: 支持最新版本
+- alist: 支持 WebDAV 协议的版本
+- 操作系统: Ubuntu Latest (工作流运行环境)

package.json

@@ -1,6 +1,6 @@
 {
   "name": "ceru-music",
-  "version": "1.1.9",
+  "version": "1.2.4",
   "description": "一款简洁优雅的音乐播放器",
   "main": "./out/main/index.js",
   "author": "sqj,wldss,star",

scripts/auth-test.js

@@ -0,0 +1,55 @@
+const axios = require('axios');
+
+const ALIST_BASE_URL = 'http://47.96.72.224:5244';
+const ALIST_USERNAME = 'ceruupdate';
+const ALIST_PASSWORD = '123456';
+
+async function test() {
+  // 认证
+  const auth = await axios.post(`${ALIST_BASE_URL}/api/auth/login`, {
+    username: ALIST_USERNAME,
+    password: ALIST_PASSWORD
+  });
+  
+  const token = auth.data.data.token;
+  console.log('Token received');
+
+  // 测试直接 token 格式
+  try {
+    const list = await axios.post(`${ALIST_BASE_URL}/api/fs/list`, {
+      path: '/',
+      password: '',
+      page: 1,
+      per_page: 30,
+      refresh: false
+    }, {
+      headers: { 'Authorization': token }
+    });
+    
+    console.log('Direct token works:', list.data.code === 200);
+    if (list.data.code === 200) {
+      console.log('Files:', list.data.data.content.map(f => f.name));
+    }
+  } catch (e) {
+    console.log('Direct token failed');
+  }
+
+  // 测试 Bearer 格式
+  try {
+    const list2 = await axios.post(`${ALIST_BASE_URL}/api/fs/list`, {
+      path: '/',
+      password: '',
+      page: 1,
+      per_page: 30,
+      refresh: false
+    }, {
+      headers: { 'Authorization': `Bearer ${token}` }
+    });
+    
+    console.log('Bearer format works:', list2.data.code === 200);
+  } catch (e) {
+    console.log('Bearer format failed');
+  }
+}
+
+test().catch(console.error);

scripts/test-alist.js

@@ -0,0 +1,131 @@
+const axios = require('axios');
+
+// Alist API 配置
+const ALIST_BASE_URL = 'http://47.96.72.224:5244';
+const ALIST_USERNAME = 'ceruupdate';
+const ALIST_PASSWORD = '123456';
+
+async function testAlistConnection() {
+  console.log('Testing Alist connection...');
+  
+  try {
+    // 0. 首先测试服务器是否可访问
+    console.log('0. Testing server accessibility...');
+    const pingResponse = await axios.get(`${ALIST_BASE_URL}/ping`, {
+      timeout: 5000
+    });
+    console.log('Server ping successful:', pingResponse.status);
+
+    // 1. 测试认证
+    console.log('1. Testing authentication...');
+    console.log(`Trying to authenticate with username: ${ALIST_USERNAME}`);
+    
+    const authResponse = await axios.post(`${ALIST_BASE_URL}/api/auth/login`, {
+      username: ALIST_USERNAME,
+      password: ALIST_PASSWORD
+    }, {
+      timeout: 10000,
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+
+    console.log('Auth response:', authResponse.data);
+
+    if (authResponse.data.code !== 200) {
+      // 尝试获取公共访问权限
+      console.log('Authentication failed, trying public access...');
+      
+      // 尝试不使用认证直接访问文件列表
+      const publicListResponse = await axios.post(`${ALIST_BASE_URL}/api/fs/list`, {
+        path: '/',
+        password: '',
+        page: 1,
+        per_page: 30,
+        refresh: false
+      }, {
+        timeout: 10000,
+        headers: {
+          'Content-Type': 'application/json'
+        }
+      });
+      
+      console.log('Public access response:', publicListResponse.data);
+      
+      if (publicListResponse.data.code === 200) {
+        console.log('✓ Public access successful');
+        return; // 如果公共访问成功，就不需要认证
+      }
+      
+      throw new Error(`Authentication failed: ${authResponse.data.message}`);
+    }
+
+    const token = authResponse.data.data.token;
+    console.log('✓ Authentication successful');
+
+    // 2. 测试文件列表
+    console.log('2. Testing file listing...');
+    const listResponse = await axios.post(`${ALIST_BASE_URL}/api/fs/list`, {
+      path: '/',
+      password: '',
+      page: 1,
+      per_page: 30,
+      refresh: false
+    }, {
+      timeout: 10000,
+      headers: {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json'
+      }
+    });
+
+    console.log('List response:', listResponse.data);
+    
+    if (listResponse.data.code === 200) {
+      console.log('✓ File listing successful');
+      console.log('Available directories/files:');
+      listResponse.data.data.content.forEach(item => {
+        console.log(`  - ${item.name} (${item.is_dir ? 'directory' : 'file'})`);
+      });
+    }
+
+    // 3. 测试获取特定文件信息（如果存在版本目录）
+    console.log('3. Testing file info retrieval...');
+    try {
+      const fileInfoResponse = await axios.post(`${ALIST_BASE_URL}/api/fs/get`, {
+        path: '/v1.0.0'  // 测试版本目录
+      }, {
+        timeout: 10000,
+        headers: {
+          'Authorization': token,
+          'Content-Type': 'application/json'
+        }
+      });
+
+      console.log('File info response:', fileInfoResponse.data);
+      
+      if (fileInfoResponse.data.code === 200) {
+        console.log('✓ File info retrieval successful');
+      }
+    } catch (error) {
+      console.log('ℹ Version directory /v1.0.0 not found (this is expected if no updates are available)');
+    }
+
+    console.log('\n✅ Alist connection test completed successfully!');
+    
+  } catch (error) {
+    console.error('❌ Alist connection test failed:', error.message);
+    
+    if (error.response) {
+      console.error('Response status:', error.response.status);
+      console.error('Response data:', error.response.data);
+    } else if (error.request) {
+      console.error('No response received. Check if the Alist server is running and accessible.');
+    }
+    
+    process.exit(1);
+  }
+}
+
+// 运行测试
+testAlistConnection();

src/main/autoUpdate.ts

@@ -20,6 +20,101 @@ interface UpdateInfo {
 const UPDATE_SERVER = 'https://update.ceru.shiqianjiang.cn';
 const UPDATE_API_URL = `${UPDATE_SERVER}/update/${process.platform}/${app.getVersion()}`;
 
+// Alist API 配置
+const ALIST_BASE_URL = 'https://alist.shiqianjiang.cn'; // 请替换为实际的 alist 域名
+const ALIST_USERNAME = 'ceruupdate';
+const ALIST_PASSWORD = '123456';
+
+// Alist 认证 token
+let alistToken: string | null = null;
+
+// 获取 Alist 认证 token
+async function getAlistToken(): Promise<string> {
+  if (alistToken) {
+    return alistToken;
+  }
+
+  try {
+    console.log('Authenticating with Alist...');
+    const response = await axios.post(`${ALIST_BASE_URL}/api/auth/login`, {
+      username: ALIST_USERNAME,
+      password: ALIST_PASSWORD
+    }, {
+      timeout: 10000,
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+
+    console.log('Alist auth response:', response.data);
+
+    if (response.data.code === 200) {
+      alistToken = response.data.data.token;
+      console.log('Alist authentication successful');
+      return alistToken!; // 我们已经确认 token 存在
+    } else {
+      throw new Error(`Alist authentication failed: ${response.data.message || 'Unknown error'}`);
+    }
+  } catch (error: any) {
+    console.error('Alist authentication error:', error);
+    if (error.response) {
+      throw new Error(`Failed to authenticate with Alist: HTTP ${error.response.status} - ${error.response.data?.message || error.response.statusText}`);
+    } else {
+      throw new Error(`Failed to authenticate with Alist: ${error.message}`);
+    }
+  }
+}
+
+// 获取 Alist 文件下载链接
+async function getAlistDownloadUrl(version: string, fileName: string): Promise<string> {
+  const token = await getAlistToken();
+  const filePath = `/${version}/${fileName}`;
+
+  try {
+    console.log(`Getting file info for: ${filePath}`);
+    const response = await axios.post(`${ALIST_BASE_URL}/api/fs/get`, {
+      path: filePath
+    }, {
+      timeout: 10000,
+      headers: {
+        'Authorization': token,
+        'Content-Type': 'application/json'
+      }
+    });
+
+    console.log('Alist file info response:', response.data);
+
+    if (response.data.code === 200) {
+      const fileInfo = response.data.data;
+      
+      // 检查文件是否存在且有下载链接
+      if (fileInfo && fileInfo.raw_url) {
+        console.log('Using raw_url for download:', fileInfo.raw_url);
+        return fileInfo.raw_url;
+      } else if (fileInfo && fileInfo.sign) {
+        // 使用签名构建下载链接
+        const downloadUrl = `${ALIST_BASE_URL}/d${filePath}?sign=${fileInfo.sign}`;
+        console.log('Using signed download URL:', downloadUrl);
+        return downloadUrl;
+      } else {
+        // 尝试直接下载链接（无签名）
+        const directUrl = `${ALIST_BASE_URL}/d${filePath}`;
+        console.log('Using direct download URL:', directUrl);
+        return directUrl;
+      }
+    } else {
+      throw new Error(`Failed to get file info: ${response.data.message || 'Unknown error'}`);
+    }
+  } catch (error: any) {
+    console.error('Alist file info error:', error);
+    if (error.response) {
+      throw new Error(`Failed to get download URL from Alist: HTTP ${error.response.status} - ${error.response.data?.message || error.response.statusText}`);
+    } else {
+      throw new Error(`Failed to get download URL from Alist: ${error.message}`);
+    }
+  }
+}
+
 // 初始化自动更新器
 export function initAutoUpdater(window: BrowserWindow) {
   mainWindow = window;
@@ -128,8 +223,8 @@ export async function downloadUpdate() {
 }
 
 // 下载文件
-async function downloadFile(url: string): Promise<string> {
+async function downloadFile(originalUrl: string): Promise<string> {
-  const fileName = path.basename(url);
+  const fileName = path.basename(originalUrl);
   const downloadPath = path.join(app.getPath('temp'), fileName);
 
   // 进度节流变量
@@ -139,9 +234,24 @@ async function downloadFile(url: string): Promise<string> {
   const PROGRESS_THRESHOLD = 1; // 进度变化超过1%才发送
 
   try {
+    let downloadUrl = originalUrl;
+    
+    try {
+      // 从当前更新信息中提取版本号
+      const version = currentUpdateInfo?.name || app.getVersion();
+      
+      // 尝试使用 alist API 获取下载链接
+      downloadUrl = await getAlistDownloadUrl(version, fileName);
+      console.log('Using Alist download URL:', downloadUrl);
+    } catch (alistError) {
+      console.warn('Alist download failed, falling back to original URL:', alistError);
+      console.log('Using original download URL:', originalUrl);
+      downloadUrl = originalUrl;
+    }
+
     const response = await axios({
       method: 'GET',
-      url: url,
+      url: downloadUrl,
       responseType: 'stream',
       timeout: 30000, // 30秒超时
       onDownloadProgress: (progressEvent) => {

src/main/index.ts

@@ -40,6 +40,7 @@ function createTray(): void {
       label: '播放/暂停',
       click: () => {
         // 这里可以添加播放控制逻辑
+        console.log('music-control')
         mainWindow?.webContents.send('music-control')
       }
     },
@@ -75,7 +76,7 @@ function createWindow(): void {
   mainWindow = new BrowserWindow({
     width: 1100,
     height: 750,
-    minWidth: 970,
+    minWidth: 1100,
     minHeight: 670,
     show: false,
     center: true,

src/preload/index.d.ts

@@ -8,7 +8,7 @@ interface CustomAPI {
   close: () => void
   setMiniMode: (isMini: boolean) => void
   toggleFullscreen: () => void
-  onMusicCtrl: (callback: (event: Event, args: any) => void) => void
+  onMusicCtrl: (callback: (event: Event, args: any) => void) => () => void
 
   music: {
     request: (api: string, args: any) => Promise<any>

src/preload/index.ts

@@ -21,8 +21,11 @@ const api = {
     ipcRenderer.send('window-mini-mode', isMini)
   },
   toggleFullscreen: () => ipcRenderer.send('window-toggle-fullscreen'),
-  onMusicCtrl: (callback: (event: Electron.IpcRendererEvent, ...args: any[]) => void) =>
+  onMusicCtrl: (callback: (event: Electron.IpcRendererEvent, ...args: any[]) => void) => {
-    ipcRenderer.on('music-control', callback),
+    const handler = (event: Electron.IpcRendererEvent) => callback(event)
+    ipcRenderer.on('music-control', handler)
+    return () => ipcRenderer.removeListener('music-control', handler)
+  },
 
   music: {
     request: (api: string, args: any) => ipcRenderer.invoke('service-music-request', api, args),

src/renderer/components.d.ts

@@ -9,6 +9,7 @@ export {}
 declare module 'vue' {
   export interface GlobalComponents {
     AIFloatBallSettings: typeof import('./src/components/Settings/AIFloatBallSettings.vue')['default']
+    AudioVisualizer: typeof import('./src/components/Play/AudioVisualizer.vue')['default']
     FloatBall: typeof import('./src/components/AI/FloatBall.vue')['default']
     FullPlay: typeof import('./src/components/Play/FullPlay.vue')['default']
     GlobalAudio: typeof import('./src/components/Play/GlobalAudio.vue')['default']
@@ -21,8 +22,26 @@ declare module 'vue' {
     SearchComponent: typeof import('./src/components/Search/SearchComponent.vue')['default']
     ShaderBackground: typeof import('./src/components/Play/ShaderBackground.vue')['default']
     SongVirtualList: typeof import('./src/components/Music/SongVirtualList.vue')['default']
+    TAlert: typeof import('tdesign-vue-next')['Alert']
+    TAside: typeof import('tdesign-vue-next')['Aside']
+    TBadge: typeof import('tdesign-vue-next')['Badge']
+    TButton: typeof import('tdesign-vue-next')['Button']
+    TCard: typeof import('tdesign-vue-next')['Card']
+    TContent: typeof import('tdesign-vue-next')['Content']
+    TDialog: typeof import('tdesign-vue-next')['Dialog']
+    TDropdown: typeof import('tdesign-vue-next')['Dropdown']
     ThemeSelector: typeof import('./src/components/ThemeSelector.vue')['default']
+    TIcon: typeof import('tdesign-vue-next')['Icon']
+    TImage: typeof import('tdesign-vue-next')['Image']
+    TInput: typeof import('tdesign-vue-next')['Input']
     TitleBarControls: typeof import('./src/components/TitleBarControls.vue')['default']
+    TLayout: typeof import('tdesign-vue-next')['Layout']
+    TLoading: typeof import('tdesign-vue-next')['Loading']
+    TRadioButton: typeof import('tdesign-vue-next')['RadioButton']
+    TRadioGroup: typeof import('tdesign-vue-next')['RadioGroup']
+    TSlider: typeof import('tdesign-vue-next')['Slider']
+    TSwitch: typeof import('tdesign-vue-next')['Switch']
+    TTooltip: typeof import('tdesign-vue-next')['Tooltip']
     UpdateExample: typeof import('./src/components/UpdateExample.vue')['default']
     UpdateProgress: typeof import('./src/components/UpdateProgress.vue')['default']
     UpdateSettings: typeof import('./src/components/Settings/UpdateSettings.vue')['default']

src/renderer/index.html

@@ -2,7 +2,7 @@
 <html>
   <head lang="zh-CN">
     <meta charset="UTF-8" />
-    <title>Electron</title>
+    <title>澜音 Music</title>
     <!-- https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP -->
     <!-- <meta
       http-equiv="Content-Security-Policy"

src/renderer/src/assets/base.css

@@ -1,8 +1,12 @@
 @import './icon_font/iconfont.css';
 :root {
-  --play-bottom-height: max(min(10vh, 86px), 70px);
+  --play-bottom-height: max(min(10vh, 80px), 70px);
+}
+@font-face {
+  font-family: 'lyricfont';
+  src: url('./lyricfont.ttf');
+  font-weight: 500;
 }
-
 *,
 *::before,
 *::after {

src/renderer/src/components/Play/AudioVisualizer.vue

@@ -0,0 +1,326 @@
+<script lang="ts" setup>
+import { ref, onMounted, onBeforeUnmount, watch, nextTick } from 'vue'
+import { ControlAudioStore } from '@renderer/store/ControlAudio'
+import { storeToRefs } from 'pinia'
+import audioManager from '@renderer/utils/audioManager'
+
+interface Props {
+  show?: boolean
+  height?: number
+  barCount?: number
+  color?: string
+  backgroundColor?: string
+}
+
+// 定义事件
+const emit = defineEmits<{
+  lowFreqUpdate: [volume: number]
+}>()
+
+const props = withDefaults(defineProps<Props>(), {
+  show: true,
+  height: 80,
+  barCount: 64,
+  color: 'rgba(255, 255, 255, 0.8)',
+  backgroundColor: 'transparent'
+})
+
+const canvasRef = ref<HTMLCanvasElement>()
+const animationId = ref<number>()
+const analyser = ref<AnalyserNode>()
+const dataArray = ref<Uint8Array>()
+const resizeObserver = ref<ResizeObserver>()
+const componentId = ref<string>(`visualizer-${Date.now()}-${Math.random()}`)
+
+const controlAudio = ControlAudioStore()
+const { Audio } = storeToRefs(controlAudio)
+
+// 初始化音频分析器
+const initAudioAnalyser = () => {
+  if (!Audio.value.audio) return
+
+  try {
+    // 计算所需的 fftSize - 必须是 2 的幂次方
+    const minSize = props.barCount * 2
+    let fftSize = 32
+    while (fftSize < minSize) {
+      fftSize *= 2
+    }
+    fftSize = Math.min(fftSize, 2048) // 限制最大值
+
+    // 使用音频管理器创建分析器
+    const createdAnalyser = audioManager.createAnalyser(Audio.value.audio, componentId.value, fftSize)
+    analyser.value = createdAnalyser || undefined
+    
+    if (analyser.value) {
+      // 创建数据数组，明确指定 ArrayBuffer 类型
+      const bufferLength = analyser.value.frequencyBinCount
+      dataArray.value = new Uint8Array(new ArrayBuffer(bufferLength))
+      console.log('音频分析器初始化成功')
+    } else {
+      console.warn('无法创建音频分析器，使用模拟数据')
+      // 创建一个默认大小的数据数组用于模拟数据
+      const bufferLength = fftSize / 2
+      dataArray.value = new Uint8Array(new ArrayBuffer(bufferLength))
+    }
+    
+  } catch (error) {
+    console.error('音频分析器初始化失败:', error)
+    // 创建一个默认大小的数据数组用于模拟数据
+    dataArray.value = new Uint8Array(new ArrayBuffer(256))
+  }
+}
+
+// 绘制可视化
+const draw = () => {
+  if (!canvasRef.value || !analyser.value || !dataArray.value) return
+
+  const canvas = canvasRef.value
+  const ctx = canvas.getContext('2d')
+  if (!ctx) return
+
+  // 获取频域数据或生成模拟数据
+  if (analyser.value && dataArray.value) {
+    // 有真实音频分析器，获取真实数据
+    analyser.value.getByteFrequencyData(dataArray.value as Uint8Array<ArrayBuffer>)
+  } else {
+    // 没有音频分析器，生成模拟数据
+    const time = Date.now() * 0.001
+    for (let i = 0; i < dataArray.value.length; i++) {
+      // 生成基于时间的模拟频谱数据
+      const frequency = i / dataArray.value.length
+      const amplitude = Math.sin(time * 2 + frequency * 10) * 0.5 + 0.5
+      const bass = Math.sin(time * 4) * 0.3 + 0.7 // 低频变化
+      dataArray.value[i] = Math.floor(amplitude * bass * 255 * (1 - frequency * 0.7))
+    }
+  }
+
+  // 计算低频音量 (80hz-120hz 范围)
+  // 假设采样率为 44100Hz，fftSize 为 256，则每个频率 bin 约为 172Hz
+  // 80-120Hz 大约对应前 1-2 个 bin
+  const lowFreqStart = 0
+  const lowFreqEnd = Math.min(3, dataArray.value.length) // 取前几个低频 bin
+  let lowFreqSum = 0
+  for (let i = lowFreqStart; i < lowFreqEnd; i++) {
+    lowFreqSum += dataArray.value[i]
+  }
+  const lowFreqVolume = (lowFreqSum / (lowFreqEnd - lowFreqStart)) / 255
+  
+  // 发送低频音量给父组件
+  emit('lowFreqUpdate', lowFreqVolume)
+
+  // 完全清空画布
+  ctx.clearRect(0, 0, canvas.width, canvas.height)
+  
+  // 如果有背景色，再填充背景
+  if (props.backgroundColor !== 'transparent') {
+    ctx.fillStyle = props.backgroundColor
+    ctx.fillRect(0, 0, canvas.width, canvas.height)
+  }
+
+  // 使用容器的实际尺寸进行计算，因为 ctx 已经缩放过了
+  const container = canvas.parentElement
+  if (!container) return
+  
+  const containerRect = container.getBoundingClientRect()
+  const canvasWidth = containerRect.width
+  const canvasHeight = props.height
+  
+  // 计算对称柱状图参数
+  const halfBarCount = Math.floor(props.barCount / 2)
+  const barWidth = (canvasWidth / 2) / halfBarCount
+  const maxBarHeight = canvasHeight * 0.9
+  const centerX = canvasWidth / 2
+
+  // 绘制左右对称的频谱柱状图
+  for (let i = 0; i < halfBarCount; i++) {
+    // 增强低频响应，让可视化更敏感
+    let barHeight = (dataArray.value[i] / 255) * maxBarHeight
+    
+    // 对数据进行增强处理，让变化更明显
+    barHeight = Math.pow(barHeight / maxBarHeight, 0.6) * maxBarHeight
+    
+    const y = canvasHeight - barHeight
+
+    // 创建渐变色
+    const gradient = ctx.createLinearGradient(0, canvasHeight, 0, y)
+    gradient.addColorStop(0, props.color)
+    gradient.addColorStop(1, props.color.replace(/[\d\.]+\)$/g, '0.3)'))
+
+    ctx.fillStyle = gradient
+    
+    // 绘制左侧柱状图（从中心向左）
+    const leftX = centerX - (i + 1) * barWidth
+    ctx.fillRect(leftX, y, barWidth, barHeight)
+    
+    // 绘制右侧柱状图（从中心向右）
+    const rightX = centerX + i * barWidth
+    ctx.fillRect(rightX, y, barWidth, barHeight)
+  }
+
+  // 继续动画
+  if (props.show && Audio.value.isPlay) {
+    animationId.value = requestAnimationFrame(draw)
+  }
+}
+
+// 开始可视化
+const startVisualization = () => {
+  if (!props.show || !Audio.value.isPlay) return
+  
+  if (!analyser.value) {
+    initAudioAnalyser()
+  }
+  
+  draw()
+}
+
+// 停止可视化
+const stopVisualization = () => {
+  try {
+    if (animationId.value) {
+      cancelAnimationFrame(animationId.value)
+      animationId.value = undefined
+    }
+  } catch (error) {
+    console.warn('停止动画帧时出错:', error)
+  }
+}
+
+// 监听播放状态变化
+watch(() => Audio.value.isPlay, (isPlaying) => {
+  if (isPlaying && props.show) {
+    startVisualization()
+  } else {
+    stopVisualization()
+  }
+})
+
+// 监听显示状态变化
+watch(() => props.show, (show) => {
+  if (show && Audio.value.isPlay) {
+    startVisualization()
+  } else {
+    stopVisualization()
+  }
+})
+
+
+// 设置画布尺寸的函数
+const resizeCanvas = () => {
+  if (!canvasRef.value) return
+  
+  const canvas = canvasRef.value
+  const container = canvas.parentElement
+  if (!container) return
+  
+  // 获取容器的实际尺寸
+  const containerRect = container.getBoundingClientRect()
+  const dpr = window.devicePixelRatio || 1
+  
+  // 设置 canvas 的实际尺寸
+  canvas.width = containerRect.width * dpr
+  canvas.height = props.height * dpr
+  
+  // 设置 CSS 尺寸
+  canvas.style.width = containerRect.width + 'px'
+  canvas.style.height = props.height + 'px'
+  
+  const ctx = canvas.getContext('2d')
+  if (ctx) {
+    // 重置变换矩阵并重新缩放
+    ctx.setTransform(1, 0, 0, 1, 0, 0)
+    ctx.scale(dpr, dpr)
+  }
+  
+  console.log('Canvas resized:', containerRect.width, 'x', props.height)
+}
+
+// 组件挂载
+onMounted(() => {
+  if (canvasRef.value) {
+    resizeCanvas()
+    
+    // 使用 ResizeObserver 监听容器尺寸变化
+    resizeObserver.value = new ResizeObserver((entries) => {
+      for (const _entry of entries) {
+        // 使用 nextTick 确保 DOM 更新完成
+        nextTick(() => {
+          resizeCanvas()
+        })
+      }
+    })
+    
+    // 观察 canvas 元素的父容器
+    const container = canvasRef.value.parentElement
+    if (container) {
+      resizeObserver.value.observe(container)
+    }
+  }
+  
+  if (Audio.value.audio && props.show && Audio.value.isPlay) {
+    initAudioAnalyser()
+    startVisualization()
+  }
+})
+
+// 组件卸载
+onBeforeUnmount(() => {
+  console.log('AudioVisualizer 组件开始卸载')
+  
+  // 停止可视化动画
+  stopVisualization()
+  
+  // 清理音频上下文和相关资源
+  try {
+    // 只断开分析器连接，不断开共享的音频源
+    if (analyser.value) {
+      analyser.value.disconnect()
+      analyser.value = undefined
+    }
+    
+
+  } catch (error) {
+    console.warn('清理音频资源时出错:', error)
+  }
+  
+  // 断开 ResizeObserver
+  try {
+    if (resizeObserver.value) {
+      resizeObserver.value.disconnect()
+      resizeObserver.value = undefined
+    }
+  } catch (error) {
+    console.warn('断开 ResizeObserver 时出错:', error)
+  }
+  
+  // 清理数据数组
+  dataArray.value = undefined
+  
+  console.log('AudioVisualizer 组件卸载完成')
+})
+</script>
+
+<template>
+  <div class="audio-visualizer" :style="{ height: `${height}px` }">
+    <canvas
+      ref="canvasRef"
+      class="visualizer-canvas"
+      :style="{ height: `${height}px` }"
+    />
+  </div>
+</template>
+
+<style lang="scss" scoped>
+.audio-visualizer {
+  width: 100%;
+  position: relative;
+  overflow: hidden;
+  
+  .visualizer-canvas {
+    width: 100%;
+    display: block;
+    border-radius: 4px;
+  }
+}
+</style>

src/renderer/src/components/Play/FullPlay.vue

@@ -1,6 +1,7 @@
 <!-- eslint-disable vue/require-toggle-inside-transition -->
 <script lang="ts" setup>
 import TitleBarControls from '../TitleBarControls.vue'
+import AudioVisualizer from './AudioVisualizer.vue'
 // import ShaderBackground from './ShaderBackground.vue'
 import {
   BackgroundRender,
@@ -23,13 +24,15 @@ interface Props {
   show?: boolean
   coverImage?: string
   songId?: string | null
-  songInfo: SongList | { songmid: number | null }
+  songInfo: SongList | { songmid: number | null },
+  mainColor:string
 }
 
 const props = withDefaults(defineProps<Props>(), {
   show: false,
   coverImage: '@assets/images/Default.jpg',
-  songId: ''
+  songId: '',
+  mainColor: '#fff'
 })
 // 定义事件
 const emit = defineEmits(['toggle-fullscreen'])
@@ -76,7 +79,8 @@ const state = reactive({
   albumUrl: props.coverImage,
   albumIsVideo: false,
   currentTime: 0,
-  lyricLines: [] as LyricLine[]
+  lyricLines: [] as LyricLine[],
+  lowFreqVolume: 1.0
 })
 
 // 监听歌曲ID变化，获取歌词
@@ -242,93 +246,77 @@ watch(
     state.currentTime = Math.round(newTime * 1000)
   }
 )
+
+// 处理低频音量更新
+const handleLowFreqUpdate = (volume: number) => {
+  state.lowFreqVolume = volume
+}
 </script>
 
 <template>
   <div class="full-play" :class="{ active: props.show, 'use-black-text': useBlackText }">
     <!-- <ShaderBackground :cover-image="actualCoverImage" /> -->
-    <BackgroundRender
+    <BackgroundRender ref="bgRef" :album="actualCoverImage" :album-is-video="false" :fps="30" :flow-speed="4"
-      ref="bgRef"
+     :has-lyric="state.lyricLines.length > 10"
-      :album="actualCoverImage"
+      style="position: absolute; top: 0; left: 0; width: 100%; height: 100%; z-index: -1" />
-      :album-is-video="false"
-      :fps="30"
-      :flow-speed="4"
-      :low-freq-volume="1"
-      :has-lyric="state.lyricLines.length > 10"
-      style="position: absolute; top: 0; left: 0; width: 100%; height: 100%; z-index: -1"
-    />
     <!-- 全屏按钮 -->
-    <button
+    <button class="fullscreen-btn" :class="{ 'black-text': useBlackText }" @click="toggleFullscreen">
-      class="fullscreen-btn"
-      :class="{ 'black-text': useBlackText }"
-      @click="toggleFullscreen"
-    >
       <Fullscreen1Icon v-if="!isFullscreen" class="icon" />
       <FullscreenExit1Icon v-else class="icon" />
     </button>
-    <button
+    <button class="putawayscreen-btn" :class="{ 'black-text': useBlackText }" @click="emit('toggle-fullscreen')">
-      class="putawayscreen-btn"
-      :class="{ 'black-text': useBlackText }"
-      @click="emit('toggle-fullscreen')"
-    >
       <ChevronDownIcon class="icon" />
     </button>
     <Transition name="fade-nav">
-      <TitleBarControls
+      <TitleBarControls v-if="props.show" class="top" style="-webkit-app-region: drag"
-        v-if="props.show"
+        :color="useBlackText ? 'black' : 'white'" />
-        class="top"
-        style="-webkit-app-region: drag"
-        :color="useBlackText ? 'black' : 'white'"
-      />
     </Transition>
     <div class="playbox">
-      <!-- 播放控件内容
-      <div v-if="props.show" class="song-info">
-        <h1>当前播放</h1>
-        <p>这里将显示歌曲信息</p>
-      </div> -->
       <div class="left" :style="state.lyricLines.length <= 0 && 'width:100vw'">
-        <div
+        <div class="cd-container" 
-          class="box"
+          :class="{ playing: Audio.isPlay }"
-          :style="
+          :style="!Audio.isPlay
-            !Audio.isPlay
+            ? 'animation-play-state: paused;'
-              ? 'animation-play-state: paused;'
+            : '' +
-              : '' +
+            (state.lyricLines.length <= 0
-                (state.lyricLines.length <= 0
+              ? 'width:70vh;height:70vh; transition: width 0.3s ease, height 0.3s ease; transition-delay: 0.8s;'
-                  ? 'width:70vh;height:70vh; transition: width 0.3s ease, height 0.3s ease; transition-delay: 0.8s;'
+              : '')
-                  : '')
+          ">
-          "
+          <!-- 黑胶唱片 -->
-        >
+          <div class="vinyl-record"></div>
-          <t-image
+          <!-- 唱片标签 -->
-            :src="coverImage"
+          <div class="vinyl-label">
-            :style="
+            <t-image :src="coverImage" shape="circle" class="cover" />
-              state.lyricLines.length > 0
+            <div class="label-shine"></div>
-                ? 'width: min(20vw, 380px); height: min(20vw, 380px)'
+          </div>
-                : 'width: 45vh; height: 45vh;transition: width 0.3s ease, height 0.3s ease; transition-delay: 1s;'
+          <!-- 中心孔 -->
-            "
+          <div class="center-hole"></div>
-            shape="circle"
+
-            class="cover"
-          />
         </div>
       </div>
       <div v-show="state.lyricLines.length > 0" class="right">
-        <LyricPlayer
+        <LyricPlayer ref="lyricPlayerRef" :lyric-lines="props.show ? state.lyricLines : []"
-          ref="lyricPlayerRef"
+          :current-time="state.currentTime"  class="lyric-player" @line-click="
-          :lyric-lines="props.show ? state.lyricLines : []"
-          :current-time="state.currentTime"
-          :align-position="0.38"
-          style="mix-blend-mode: plus-lighter"
-          class="lyric-player"
-          @line-click="
             (e) => {
               if (Audio.audio) Audio.audio.currentTime = e.line.getLine().startTime / 1000
             }
           "
-        >
+          
+          >
           <template #bottom-line> Test Bottom Line </template>
         </LyricPlayer>
       </div>
     </div>
+    <!-- 音频可视化组件 -->
+    <div class="audio-visualizer-container" v-if="props.show&&coverImage">
+      <AudioVisualizer 
+        :show="props.show && Audio.isPlay" 
+        :height="70" 
+        :bar-count="80"
+        :color='mainColor'
+        @low-freq-update="handleLowFreqUpdate"
+      />
+    </div>
   </div>
 </template>
 
@@ -429,16 +417,15 @@ watch(
   .playbox {
     width: 100%;
     height: 100%;
-    // background-color: rgba(0, 0, 0, 0.256);
+    background-color: rgba(0, 0, 0, 0.256);
+    drop-filter: blur(10px);
+    padding: 0 10vw;
+    -webkit-drop-filter: blur(10px);
+    overflow: hidden;
     display: flex;
     position: relative;
 
-    :deep(.lyric-player) {
+
-      --amll-lyric-player-font-size: max(2vw, 29px);
-      box-sizing: border-box;
-      width: 100%;
-      height: 100%;
-    }
 
     .left {
       width: 40%;
@@ -454,33 +441,253 @@ watch(
       justify-content: center;
       align-items: center;
       margin: 0 0 var(--play-bottom-height) 0;
+      perspective: 1000px;
 
-      .box {
+      .cd-container {
         width: min(30vw, 700px);
         height: min(30vw, 700px);
-        background-color: #000000;
+        position: relative;
         display: flex;
         align-items: center;
         justify-content: center;
-        border-radius: 1000%;
+        animation: rotateRecord 33s linear infinite;
-        animation: rotateRecord 10s linear infinite;
+        transition: filter .3s ease;
+        filter: drop-shadow(0 15px 35px rgba(0, 0, 0, 0.6));
 
-        :deep(.cover) img {
+        &:hover {
-          user-select: none;
+          filter: drop-shadow(0 20px 45px rgba(0, 0, 0, 0.7));
-          -webkit-user-drag: none;
+        }
+
+        /* 黑胶唱片主体 */
+        .vinyl-record {
+          width: 100%;
+          height: 100%;
+          position: relative;
+          border-radius: 50%;
+          background: 
+            radial-gradient(circle at 50% 50%, #1a1a1a 0%, #0d0d0d 100%);
+          display: flex;
+          align-items: center;
+          justify-content: center;
+          overflow: hidden;
+          
+          /* 唱片纹理轨道 */
+          &::before {
+            content: '';
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            border-radius: 50%;
+            background: 
+              repeating-conic-gradient(
+                from 0deg,
+                transparent 0deg,
+                rgba(255, 255, 255, 0.02) 0.5deg,
+                transparent 1deg,
+                rgba(255, 255, 255, 0.01) 1.5deg,
+                transparent 2deg
+              ),
+              repeating-radial-gradient(
+                circle at 50% 50%,
+                transparent 0px,
+                rgba(255, 255, 255, 0.03) 1px,
+                transparent 2px,
+                transparent 8px
+              );
+            z-index: 1;
+          }
+
+          /* 唱片光泽效果 */
+          &::after {
+            content: '';
+            position: absolute;
+            top: 10%;
+            left: 10%;
+            width: 30%;
+            height: 30%;
+            background: 
+              radial-gradient(ellipse at 30% 30%, 
+                rgba(255, 255, 255, 0.15) 0%, 
+                rgba(255, 255, 255, 0.05) 40%, 
+                transparent 70%
+              );
+            border-radius: 50%;
+            z-index: 2;
+            animation: vinylShine 6s ease-in-out infinite;
+          }
+        }
+
+        /* 唱片标签区域 */
+        .vinyl-label {
+          position: absolute;
+          width: 60%;
+          height: 60%;
+          background: 
+            radial-gradient(circle at 50% 50%, 
+              rgba(40, 40, 40, 0.95) 0%, 
+              rgba(25, 25, 25, 0.98) 70%, 
+              rgba(15, 15, 15, 1) 100%
+            );
+          border-radius: 50%;
+          display: flex;
+          align-items: center;
+          justify-content: center;
+          z-index: 3;
+          box-shadow: 
+            inset 0 0 20px rgba(0, 0, 0, 0.8),
+            inset 0 0 0 1px rgba(255, 255, 255, 0.05),
+            0 0 10px rgba(0, 0, 0, 0.5);
+
+          :deep(.cover) {
+            position: relative;
+            z-index: 4;
+            border-radius: 50%;
+            overflow: hidden;
+            box-shadow: 
+              0 0 20px rgba(0, 0, 0, 0.4),
+              inset 0 0 0 2px rgba(255, 255, 255, 0.1);
+            width: 95% !important;
+            height: 95% !important;
+            aspect-ratio: 1 / 1;
+
+            img {
+              user-select: none;
+              -webkit-user-drag: none;
+              border-radius: 50%;
+              filter: brightness(0.85) contrast(1.15) saturate(1.1);
+              width: 100% !important;
+              height: 100% !important;
+              object-fit: cover;
+            }
+          }
+
+          /* 标签光泽 */
+          .label-shine {
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            background: 
+              radial-gradient(ellipse at 25% 25%, 
+                rgba(255, 255, 255, 0.1) 0%, 
+                transparent 50%
+              );
+            border-radius: 50%;
+            z-index: 5;
+            pointer-events: none;
+            animation: labelShine 8s ease-in-out infinite;
+          }
+        }
+
+        /* 中心孔 */
+        .center-hole {
+          position: absolute;
+          width: 8%;
+          height: 8%;
+          background: 
+            radial-gradient(circle, 
+              #000 0%, 
+              #111 30%, 
+              #222 70%, 
+              #333 100%
+            );
+          border-radius: 50%;
+          z-index: 10;
+          box-shadow: 
+            inset 0 0 8px rgba(0, 0, 0, 0.9),
+            0 0 3px rgba(0, 0, 0, 0.8);
         }
       }
     }
 
     .right {
+      :deep(.lyric-player) {
+        font-family: lyricfont;
+        --amll-lyric-player-font-size: min(2.6vw, 32px);
+
+        // bottom: max(2vw, 29px);
+
+        height: 120%;
+        transform: translateY(-10%);
+        &>div{
+          padding-bottom: 0;
+          overflow: hidden;
+          transform: translateY(-20px);
+        }
+      }
+      
       padding: 0 20px;
-      padding-top: 90px;
+      
+      margin: 80px 0 calc(var(--play-bottom-height)) 0;
+      overflow: hidden;
+
     }
   }
+
+  .audio-visualizer-container {
+    position: absolute;
+    bottom: calc(var(--play-bottom-height) - 10px);
+    z-index: 9999;
+    left: 0;
+    right: 0;
+    height: 60px;
+    // background: linear-gradient(to top, rgba(0, 0, 0, 0.3), transparent);
+    filter: blur(6px);
+    // max-width: 1000px;
+    // -webkit-backdrop-filter: blur(10px);
+    // border-top: 1px solid rgba(255, 255, 255, 0.1);
+    z-index: 5;
+    // padding: 0 20px;
+    display: flex;
+    align-items: center;
+    
+  }
 }
 
 @keyframes rotateRecord {
-  to {
+  0% {
+    transform: rotate(0deg);
+  }
+  100% {
+    transform: rotate(360deg);
+  }
+}
+
+@keyframes vinylShine {
+  0% {
+    opacity: 0.1;
+    transform: rotate(0deg) scale(1);
+  }
+  50% {
+    opacity: 0.2;
+    transform: rotate(180deg) scale(1.1);
+  }
+  100% {
+    opacity: 0.1;
+    transform: rotate(360deg) scale(1);
+  }
+}
+
+@keyframes labelShine {
+  0% {
+    opacity: 0.05;
+    transform: rotate(0deg);
+  }
+  25% {
+    opacity: 0.15;
+  }
+  50% {
+    opacity: 0.1;
+    transform: rotate(180deg);
+  }
+  75% {
+    opacity: 0.15;
+  }
+  100% {
+    opacity: 0.05;
     transform: rotate(360deg);
   }
 }

src/renderer/src/components/Play/PlayMusic.vue

@@ -34,7 +34,7 @@ const { setCurrentTime, start, stop, setVolume, setUrl } = controlAudio
 const showFullPlay = ref(false)
 document.addEventListener('keydown', KeyEvent)
 // 处理最小化右键的事件
-window.api.onMusicCtrl(() => {
+const removeMusicCtrlListener = window.api.onMusicCtrl(() => {
   togglePlayPause()
 })
 let timer: any = null
@@ -172,7 +172,7 @@ const playSong = async (song: SongList) => {
         // 同时更新播放列表中对应歌曲的URL
         const playlistIndex = list.value.findIndex((item) => item.songmid === song.songmid)
         if (playlistIndex !== -1) {
-          ;(list.value[playlistIndex] as any).url = urlToPlay
+          ; (list.value[playlistIndex] as any).url = urlToPlay
         }
       } catch (error) {
         throw error
@@ -377,13 +377,10 @@ const playNext = async () => {
         if (Audio.value.audio) {
           Audio.value.audio.currentTime = 0
         }
-
         // 如果当前正在播放，继续播放；如果暂停，保持暂停
-        if (Audio.value.isPlay) {
+        const startResult = start()
-          const startResult = start()
+        if (startResult && typeof startResult.then === 'function') {
-          if (startResult && typeof startResult.then === 'function') {
+          await startResult
-            await startResult
-          }
         }
         return
       }
@@ -412,7 +409,7 @@ const playNext = async () => {
 
 // 定期保存当前播放位置
 let savePositionInterval: number | null = null
-let unEnded: () => any = () => {}
+let unEnded: () => any = () => { }
 // 初始化播放器
 onMounted(async () => {
   console.log('加载')
@@ -422,6 +419,7 @@ onMounted(async () => {
   // 监听音频结束事件，根据播放模式播放下一首
   unEnded = controlAudio.subscribe('ended', () => {
     window.requestAnimationFrame(() => {
+      console.log('播放结束')
       playNext()
     })
   })
@@ -473,6 +471,9 @@ onUnmounted(() => {
   if (savePositionInterval !== null) {
     clearInterval(savePositionInterval)
   }
+  if (removeMusicCtrlListener) {
+    removeMusicCtrlListener()
+  }
   unEnded()
 })
 
@@ -532,6 +533,7 @@ watch(
 const toggleFullPlay = () => {
   if (!songInfo.value.songmid) return
   showFullPlay.value = !showFullPlay.value
+
 }
 
 // 进度条相关
@@ -709,6 +711,16 @@ watch(
   },
   { deep: true, immediate: true }
 )
+
+const bg = ref('#ffffff46')
+watch(showFullPlay,(val)=>{
+  if(val){
+    console.log('背景hei')
+    bg.value = '#00000000'
+  }else{
+    bg.value = '#ffffff46'
+  }
+})
 // onMounted(setColor)
 </script>
 
@@ -716,12 +728,8 @@ watch(
   <div class="player-container" @click.stop="toggleFullPlay">
     <!-- 进度条 -->
     <div class="progress-bar-container">
-      <div
+      <div ref="progressRef" class="progress-bar" @mousedown="handleProgressDragStart($event)"
-        ref="progressRef"
+        @click.stop="handleProgressClick">
-        class="progress-bar"
-        @mousedown="handleProgressDragStart($event)"
-        @click.stop="handleProgressClick"
-      >
         <div class="progress-background"></div>
         <div class="progress-filled" :style="{ width: `${progressPercentage}%` }"></div>
         <div class="progress-handle" :style="{ left: `${progressPercentage}%` }"></div>
@@ -764,22 +772,13 @@ watch(
         <div class="extra-controls">
           <!-- 播放模式按钮 -->
           <t-tooltip :content="playModeTip">
-            <t-button
+            <t-button class="control-btn" shape="circle" variant="text" @click.stop="updatePlayMode">
-              class="control-btn"
-              shape="circle"
-              variant="text"
-              @click.stop="updatePlayMode"
-            >
               <i :class="playModeIconClass + ' ' + 'PlayMode'" style="width: 1.5em"></i>
             </t-button>
           </t-tooltip>
 
           <!-- 音量控制 -->
-          <div
+          <div class="volume-control" @mouseenter="showVolumeSlider = true" @mouseleave="showVolumeSlider = false">
-            class="volume-control"
-            @mouseenter="showVolumeSlider = true"
-            @mouseleave="showVolumeSlider = false"
-          >
             <button class="control-btn">
               <shengyin style="width: 1.5em; height: 1.5em" />
             </button>
@@ -788,12 +787,8 @@ watch(
             <transition name="volume-popup">
               <div v-show="showVolumeSlider" class="volume-slider-container" @click.stop>
                 <div class="volume-slider">
-                  <div
+                  <div ref="volumeBarRef" class="volume-bar" @click="handleVolumeClick"
-                    ref="volumeBarRef"
+                    @mousedown="handleVolumeDragStart">
-                    class="volume-bar"
-                    @click="handleVolumeClick"
-                    @mousedown="handleVolumeDragStart"
-                  >
                     <div class="volume-background"></div>
                     <div class="volume-filled" :style="{ height: `${volumeValue}%` }"></div>
                     <div class="volume-handle" :style="{ bottom: `${volumeValue}%` }"></div>
@@ -807,12 +802,7 @@ watch(
           <!-- 播放列表按钮 -->
           <t-tooltip content="播放列表">
             <t-badge :count="list.length" :maxCount="99" color="#aaa">
-              <t-button
+              <t-button class="control-btn" shape="circle" variant="text" @click.stop="togglePlaylist">
-                class="control-btn"
-                shape="circle"
-                variant="text"
-                @click.stop="togglePlaylist"
-              >
                 <liebiao style="width: 1.5em; height: 1.5em" />
               </t-button>
             </t-badge>
@@ -822,24 +812,14 @@ watch(
     </div>
   </div>
   <div class="fullbox">
-    <FullPlay
+    <FullPlay :song-id="songInfo.songmid ? songInfo.songmid.toString() : null" :show="showFullPlay"
-      :song-id="songInfo.songmid ? songInfo.songmid.toString() : null"
+      :cover-image="songInfo.img" @toggle-fullscreen="toggleFullPlay" :song-info="songInfo" :main-color="maincolor" />
-      :show="showFullPlay"
-      :cover-image="songInfo.img"
-      @toggle-fullscreen="toggleFullPlay"
-      :song-info="songInfo"
-    />
   </div>
 
   <!-- 播放列表 -->
   <div v-show="showPlaylist" class="cover" @click="showPlaylist = false"></div>
   <transition name="playlist-drawer">
-    <div
+    <div v-show="showPlaylist" class="playlist-container" :class="{ 'full-screen-mode': showFullPlay }" @click.stop>
-      v-show="showPlaylist"
-      class="playlist-container"
-      :class="{ 'full-screen-mode': showFullPlay }"
-      @click.stop
-    >
       <div class="playlist-header">
         <div class="playlist-title">播放列表 ({{ list.length }})</div>
         <button class="playlist-close" @click.stop="showPlaylist = false">
@@ -853,13 +833,8 @@ watch(
           <p>请添加歌曲到播放列表，也可在设置中导入歌曲列表</p>
         </div>
         <div v-else class="playlist-songs">
-          <div
+          <div v-for="song in list" :key="song.songmid" class="playlist-song"
-            v-for="song in list"
+            :class="{ active: song.songmid === currentSongId }" @click="playSong(song)">
-            :key="song.songmid"
-            class="playlist-song"
-            :class="{ active: song.songmid === currentSongId }"
-            @click="playSong(song)"
-          >
             <div class="song-info">
               <div class="song-name">{{ song.name }}</div>
               <div class="song-artist">{{ song.singer }}</div>
@@ -905,7 +880,8 @@ watch(
   bottom: 0;
   left: 0;
   right: 0;
-  background: #ffffff31;
+  transition: background .3s;
+  background: v-bind(bg);
   // border-top: 1px solid #e5e7eb;
   backdrop-filter: blur(1000px);
   z-index: 1000;
@@ -939,7 +915,7 @@ watch(
       left: 0;
       right: 0;
       height: 100%;
-      background: #ffffff71;
+      background: transparent;
     }
 
     .progress-filled {
@@ -991,6 +967,7 @@ watch(
   align-items: center;
   min-width: 0;
   flex: 1;
+  padding-top: 2px;
 
   .album-cover {
     width: 50px;

src/renderer/src/utils/audioManager.ts

@@ -0,0 +1,116 @@
+// 全局音频管理器，用于管理音频源和分析器
+class AudioManager {
+  private static instance: AudioManager
+  private audioSources = new WeakMap<HTMLAudioElement, MediaElementAudioSourceNode>()
+  private audioContexts = new WeakMap<HTMLAudioElement, AudioContext>()
+  private analysers = new Map<string, AnalyserNode>()
+
+  static getInstance(): AudioManager {
+    if (!AudioManager.instance) {
+      AudioManager.instance = new AudioManager()
+    }
+    return AudioManager.instance
+  }
+
+  // 获取或创建音频源
+  getOrCreateAudioSource(audioElement: HTMLAudioElement): { source: MediaElementAudioSourceNode; context: AudioContext } | null {
+    try {
+      // 检查是否已经有音频源
+      let source = this.audioSources.get(audioElement)
+      let context = this.audioContexts.get(audioElement)
+
+      if (!source || !context || context.state === 'closed') {
+        // 创建新的音频上下文和源
+        context = new (window.AudioContext || (window as any).webkitAudioContext)()
+        source = context.createMediaElementSource(audioElement)
+        
+        // 连接到输出，确保音频能正常播放
+        source.connect(context.destination)
+        
+        // 存储引用
+        this.audioSources.set(audioElement, source)
+        this.audioContexts.set(audioElement, context)
+        
+        console.log('AudioManager: 创建新的音频源和上下文')
+      }
+
+      return { source, context }
+    } catch (error) {
+      console.error('AudioManager: 创建音频源失败:', error)
+      return null
+    }
+  }
+
+  // 创建分析器
+  createAnalyser(audioElement: HTMLAudioElement, id: string, fftSize: number = 256): AnalyserNode | null {
+    const audioData = this.getOrCreateAudioSource(audioElement)
+    if (!audioData) return null
+
+    const { source, context } = audioData
+
+    try {
+      // 创建分析器
+      const analyser = context.createAnalyser()
+      analyser.fftSize = fftSize
+      analyser.smoothingTimeConstant = 0.9
+
+      // 创建增益节点作为中介，避免直接断开主音频链
+      const gainNode = context.createGain()
+      gainNode.gain.value = 1.0
+
+      // 连接：source -> gainNode -> analyser
+      //                     -> destination (保持音频播放)
+      source.disconnect() // 先断开所有连接
+      source.connect(gainNode)
+      gainNode.connect(context.destination) // 确保音频继续播放
+      gainNode.connect(analyser) // 连接到分析器
+
+      // 存储分析器引用
+      this.analysers.set(id, analyser)
+
+      console.log('AudioManager: 创建分析器成功')
+      return analyser
+    } catch (error) {
+      console.error('AudioManager: 创建分析器失败:', error)
+      return null
+    }
+  }
+
+  // 移除分析器
+  removeAnalyser(id: string): void {
+    const analyser = this.analysers.get(id)
+    if (analyser) {
+      try {
+        analyser.disconnect()
+        this.analysers.delete(id)
+        console.log('AudioManager: 移除分析器成功')
+      } catch (error) {
+        console.warn('AudioManager: 移除分析器时出错:', error)
+      }
+    }
+  }
+
+  // 清理音频元素的所有资源
+  cleanupAudioElement(audioElement: HTMLAudioElement): void {
+    try {
+      const context = this.audioContexts.get(audioElement)
+      if (context && context.state !== 'closed') {
+        context.close()
+      }
+      
+      this.audioSources.delete(audioElement)
+      this.audioContexts.delete(audioElement)
+      
+      console.log('AudioManager: 清理音频元素资源')
+    } catch (error) {
+      console.warn('AudioManager: 清理资源时出错:', error)
+    }
+  }
+
+  // 获取分析器
+  getAnalyser(id: string): AnalyserNode | undefined {
+    return this.analysers.get(id)
+  }
+}
+
+export default AudioManager.getInstance()

src/renderer/src/utils/contrastColor.ts

@@ -1,4 +1,92 @@
-import { extractDominantColor } from './colorExtractor'
+import DefaultCover from '@renderer/assets/images/Default.jpg'
+import CoverImage from '@renderer/assets/images/cover.png'
+
+/**
+ * 直接从图片分析平均亮度，不依赖颜色提取器
+ * @param imageSrc 图片路径
+ * @returns 返回平均亮度值 (0-1)
+ */
+async function getImageAverageLuminance(imageSrc: string): Promise<number> {
+  return new Promise((resolve, reject) => {
+    // 处理相对路径
+    let actualSrc = imageSrc
+    if (
+      imageSrc.includes('@assets/images/Default.jpg') ||
+      imageSrc.includes('@renderer/assets/images/Default.jpg')
+    ) {
+      actualSrc = DefaultCover
+    } else if (
+      imageSrc.includes('@assets/images/cover.png') ||
+      imageSrc.includes('@renderer/assets/images/cover.png')
+    ) {
+      actualSrc = CoverImage
+    }
+
+    // 如果仍然是相对路径，使用默认亮度
+    if (actualSrc.startsWith('@')) {
+      console.warn('无法解析相对路径，使用默认亮度')
+      resolve(0.5) // 中等亮度
+      return
+    }
+
+    const img = new Image()
+    img.crossOrigin = 'Anonymous'
+
+    img.onload = () => {
+      try {
+        const canvas = document.createElement('canvas')
+        const ctx = canvas.getContext('2d')
+        if (!ctx) {
+          reject(new Error('无法创建canvas上下文'))
+          return
+        }
+
+        // 使用较小的采样尺寸提高性能
+        const size = 50
+        canvas.width = size
+        canvas.height = size
+
+        ctx.drawImage(img, 0, 0, size, size)
+        const imageData = ctx.getImageData(0, 0, size, size).data
+
+        let totalLuminance = 0
+        let pixelCount = 0
+
+        // 计算所有非透明像素的平均亮度
+        for (let i = 0; i < imageData.length; i += 4) {
+          // 忽略透明像素
+          if (imageData[i + 3] < 128) continue
+
+          const r = imageData[i] / 255
+          const g = imageData[i + 1] / 255
+          const b = imageData[i + 2] / 255
+
+          // 使用WCAG 2.0相对亮度公式
+          const R = r <= 0.03928 ? r / 12.92 : Math.pow((r + 0.055) / 1.055, 2.4)
+          const G = g <= 0.03928 ? g / 12.92 : Math.pow((g + 0.055) / 1.055, 2.4)
+          const B = b <= 0.03928 ? b / 12.92 : Math.pow((b + 0.055) / 1.055, 2.4)
+
+          const luminance = 0.2126 * R + 0.7152 * G + 0.0722 * B
+          totalLuminance += luminance
+          pixelCount++
+        }
+
+        const averageLuminance = pixelCount > 0 ? totalLuminance / pixelCount : 0.5
+        resolve(averageLuminance)
+      } catch (error) {
+        console.error('分析图片亮度失败:', error)
+        resolve(0.5) // 默认中等亮度
+      }
+    }
+
+    img.onerror = () => {
+      console.error('图片加载失败:', actualSrc)
+      resolve(0.5) // 默认中等亮度
+    }
+
+    img.src = actualSrc
+  })
+}
 
 /**
  * 判断图片应该使用黑色还是白色作为对比色
@@ -7,46 +95,24 @@ import { extractDominantColor } from './colorExtractor'
  */
 export async function shouldUseBlackText(imageSrc: string): Promise<boolean> {
   try {
-    // 提取主要颜色
+    // 直接分析图片的平均亮度
-    const dominantColor = await extractDominantColor(imageSrc)
+    const averageLuminance = await getImageAverageLuminance(imageSrc)
-
-    // 使用更准确的相对亮度计算公式 (sRGB相对亮度)
-    // 先将RGB值标准化到0-1范围
-    const r = dominantColor.r / 255
-    const g = dominantColor.g / 255
-    const b = dominantColor.b / 255
-
-    // 应用sRGB转换
-    const R = r <= 0.03928 ? r / 12.92 : Math.pow((r + 0.055) / 1.055, 2.4)
-    const G = g <= 0.03928 ? g / 12.92 : Math.pow((g + 0.055) / 1.055, 2.4)
-    const B = b <= 0.03928 ? b / 12.92 : Math.pow((b + 0.055) / 1.055, 2.4)
-
-    // 计算相对亮度 (WCAG 2.0公式)
-    const luminance = 0.2126 * R + 0.7152 * G + 0.0722 * B
-
-    // 计算与黑色和白色的对比度
-    // 对比度计算公式: (L1 + 0.05) / (L2 + 0.05)，其中L1是较亮的颜色，L2是较暗的颜色
-    const contrastWithBlack = (luminance + 0.05) / 0.05
-    const contrastWithWhite = 1.05 / (luminance + 0.05)
 
     console.log(
-      `颜色: RGB(${dominantColor.r},${dominantColor.g},${dominantColor.b}), ` +
+      `图片: ${imageSrc}, ` +
-        `亮度: ${luminance.toFixed(3)}, ` +
+        `平均亮度: ${averageLuminance.toFixed(3)} ` +
-        `与黑色对比度: ${contrastWithBlack.toFixed(2)}, ` +
+        `(考虑半透明黑色背景覆盖效果)`
-        `与白色对比度: ${contrastWithWhite.toFixed(2)}`
     )
 
-    // 不仅考虑亮度，还要考虑对比度
+    // 考虑到图片会受到rgba(0, 0, 0, 0.256)背景覆盖，实际显示会更暗
-    // 如果与黑色的对比度更高，说明背景较亮，应该使用黑色文字
+    // 大幅提高阈值，让白色文字在更多情况下被选择
-    // 如果与白色的对比度更高，说明背景较暗，应该使用白色文字
+    // 只有非常明亮的图片才使用黑色文字
-    // 但对于中等亮度的颜色，我们需要更精细的判断
+    
-
+    const shouldUseBlack = averageLuminance >= 0.6
-    // 对于中等亮度的颜色(0.3-0.6)，我们更倾向于使用黑色文本，因为黑色文本通常更易读
+    
-    if (luminance > 0.3) {
+    console.log(`决定使用${shouldUseBlack ? '黑色' : '白色'}文字`)
-      return true // 使用黑色文本
+    
-    } else {
+    return shouldUseBlack
-      return false // 使用白色文本
-    }
   } catch (error) {
     console.error('计算对比色失败:', error)
     // 默认返回白色作为安全选择
@@ -75,24 +141,11 @@ export async function getBestContrastTextColorWithOpacity(
   opacity: number = 1
 ): Promise<string> {
   try {
-    // 提取主要颜色
+    // 使用相同的亮度分析逻辑
-    const dominantColor = await extractDominantColor(imageSrc)
+    const averageLuminance = await getImageAverageLuminance(imageSrc)
 
-    // 使用更准确的相对亮度计算公式 (sRGB相对亮度)
+    // 使用与shouldUseBlackText相同的逻辑
-    const r = dominantColor.r / 255
+    if (averageLuminance >= 0.6) {
-    const g = dominantColor.g / 255
-    const b = dominantColor.b / 255
-
-    // 应用sRGB转换
-    const R = r <= 0.03928 ? r / 12.92 : Math.pow((r + 0.055) / 1.055, 2.4)
-    const G = g <= 0.03928 ? g / 12.92 : Math.pow((g + 0.055) / 1.055, 2.4)
-    const B = b <= 0.03928 ? b / 12.92 : Math.pow((b + 0.055) / 1.055, 2.4)
-
-    // 计算相对亮度
-    const luminance = 0.2126 * R + 0.7152 * G + 0.0722 * B
-
-    // 根据亮度决定文本颜色，使用更低的阈值
-    if (luminance > 0.3) {
       // 背景较亮，使用黑色文本
       return `rgba(0, 0, 0, ${opacity})`
     } else {

src/renderer/src/views/home/index.vue

@@ -182,7 +182,7 @@ const handleKeyDown = () => {
 
 .sidebar {
   width: 15rem;
-  background-color: #fff;
+  background-image: linear-gradient(to bottom,var(--td-brand-color-4) -140vh, #ffffff 30vh);
   border-right: 0.0625rem solid #e5e7eb;
   flex-shrink: 0;
 
@@ -270,7 +270,8 @@ const handleKeyDown = () => {
 
 .content {
   padding: 0;
-  background: #f6f6f6;
+  background-image: linear-gradient(to bottom,var(--td-brand-color-4) -110vh, #ffffff 15vh);
+
   display: flex;
   flex: 1;
   flex-direction: column;
@@ -309,12 +310,16 @@ const handleKeyDown = () => {
         -webkit-app-region: no-drag;
         display: flex;
         align-items: center;
+        transition: width 0.3s;
         padding: 0 0.5rem;
-        width: 18.75rem;
+        width: min(18.75rem,400px);
         margin-right: 0.5rem;
         border-radius: 1.25rem !important;
         background-color: #fff;
         overflow: hidden;
+        &:has(input:focus){
+          width: max(18.75rem,400px);
+        }
       }
 
       :deep(.t-input) {

website/script.js

@@ -11,15 +11,163 @@ function scrollToFeatures() {
     });
 }
 
-// GitHub repository configuration
+// Alist API configuration
+const ALIST_BASE_URL = 'https://alist.shiqianjiang.cn';
+const ALIST_USERNAME = 'ceruupdate';
+const ALIST_PASSWORD = '123456';
+
+// GitHub repository configuration (for fallback)
 const GITHUB_REPO = 'timeshiftsauce/CeruMusic';
 const GITHUB_API_URL = `https://api.github.com/repos/${GITHUB_REPO}/releases/latest`;
 
 // Cache for release data
 let releaseData = null;
 let releaseDataTimestamp = null;
+let alistToken = null;
 const CACHE_DURATION = 5 * 60 * 1000; // 5 minutes
 
+// Alist authentication
+async function getAlistToken() {
+    if (alistToken) {
+        return alistToken;
+    }
+
+    try {
+        const response = await fetch(`${ALIST_BASE_URL}/api/auth/login`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                username: ALIST_USERNAME,
+                password: ALIST_PASSWORD
+            })
+        });
+
+        const data = await response.json();
+        
+        if (data.code === 200) {
+            alistToken = data.data.token;
+            return alistToken;
+        } else {
+            throw new Error(`Alist authentication failed: ${data.message}`);
+        }
+    } catch (error) {
+        console.error('Alist authentication error:', error);
+        throw error;
+    }
+}
+
+// Get available versions from Alist
+async function getAlistVersions() {
+    try {
+        const token = await getAlistToken();
+        
+        const response = await fetch(`${ALIST_BASE_URL}/api/fs/list`, {
+            method: 'POST',
+            headers: {
+                'Authorization': token,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                path: '/',
+                password: '',
+                page: 1,
+                per_page: 100,
+                refresh: false
+            })
+        });
+
+        const data = await response.json();
+        
+        if (data.code === 200) {
+            // Filter directories that look like version numbers
+            const versions = data.data.content
+                .filter(item => item.is_dir && /^v?\d+\.\d+\.\d+/.test(item.name))
+                .sort((a, b) => b.name.localeCompare(a.name)); // Sort by version desc
+            
+            return versions;
+        } else {
+            throw new Error(`Failed to get versions: ${data.message}`);
+        }
+    } catch (error) {
+        console.error('Failed to get Alist versions:', error);
+        return [];
+    }
+}
+
+// Get files in a specific version directory
+async function getAlistVersionFiles(version) {
+    try {
+        const token = await getAlistToken();
+        
+        const response = await fetch(`${ALIST_BASE_URL}/api/fs/list`, {
+            method: 'POST',
+            headers: {
+                'Authorization': token,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                path: `/${version}`,
+                password: '',
+                page: 1,
+                per_page: 100,
+                refresh: false
+            })
+        });
+
+        const data = await response.json();
+        
+        if (data.code === 200) {
+            return data.data.content.filter(item => !item.is_dir);
+        } else {
+            throw new Error(`Failed to get version files: ${data.message}`);
+        }
+    } catch (error) {
+        console.error('Failed to get version files:', error);
+        return [];
+    }
+}
+
+// Get direct download URL from Alist
+async function getAlistDownloadUrl(version, fileName) {
+    try {
+        const token = await getAlistToken();
+        const filePath = `/${version}/${fileName}`;
+        
+        const response = await fetch(`${ALIST_BASE_URL}/api/fs/get`, {
+            method: 'POST',
+            headers: {
+                'Authorization': token,
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify({
+                path: filePath
+            })
+        });
+
+        const data = await response.json();
+        
+        if (data.code === 200) {
+            const fileInfo = data.data;
+            
+            // Try different URL formats
+            if (fileInfo.raw_url) {
+                return fileInfo.raw_url;
+            } else if (fileInfo.sign) {
+                return `${ALIST_BASE_URL}/d${filePath}?sign=${fileInfo.sign}`;
+            } else {
+                return `${ALIST_BASE_URL}/d${filePath}`;
+            }
+        } else {
+            throw new Error(`Failed to get download URL: ${data.message}`);
+        }
+    } catch (error) {
+        console.error('Failed to get Alist download URL:', error);
+        throw error;
+    }
+}
+
 // Download functionality
 async function downloadApp(platform) {
     const button = event.target;
@@ -35,38 +183,53 @@ async function downloadApp(platform) {
     button.disabled = true;
     
     try {
-        // Get latest release data
+        // Try Alist first
-        const release = await getLatestRelease();
+        const versions = await getAlistVersions();
         
-        if (!release) {
+        if (versions.length > 0) {
-            throw new Error('无法获取最新版本信息');
+            const latestVersion = versions[0];
+            const files = await getAlistVersionFiles(latestVersion.name);
+            
+            // Find the appropriate file for the platform
+            const fileName = findFileForPlatform(files, platform);
+            
+            if (fileName) {
+                const downloadUrl = await getAlistDownloadUrl(latestVersion.name, fileName);
+                
+                // Show success notification
+                showNotification(`正在下载 ${getPlatformName(platform)} 版本 ${latestVersion.name}...`, 'success');
+                
+                // Start download
+                window.open(downloadUrl, '_blank');
+                
+                // Track download
+                trackDownload(platform, latestVersion.name);
+                
+                return; // Success, exit function
+            }
         }
         
-        // Find the appropriate download asset
+        // Fallback to GitHub if Alist fails
-        const downloadUrl = findDownloadAsset(release.assets, platform);
+        console.log('Alist download failed, trying GitHub fallback...');
-        
+        await downloadFromGitHub(platform);
-        if (!downloadUrl) {
-            throw new Error(`暂无 ${getPlatformName(platform)} 版本下载`);
-        }
-        
-        // Show success notification
-        showNotification(`正在下载 ${getPlatformName(platform)} 版本 v${release.tag_name}...`, 'success');
-        
-        // Start download
-        window.open('https://gh.bugdey.us.kg/'+downloadUrl, '_blank');
-        
-        // Track download
-        trackDownload(platform, release.tag_name);
         
     } catch (error) {
         console.error('Download error:', error);
-        showNotification(`下载失败: ${error.message}`, 'error');
         
-        // Fallback to GitHub releases page
+        // Try GitHub fallback
-        setTimeout(() => {
+        try {
-            showNotification('正在跳转到GitHub下载页面...', 'info');
+            console.log('Trying GitHub fallback...');
-            window.open(`https://gh.bugdey.us.kg/https://github.com/${GITHUB_REPO}/releases/latest`, '_blank');
+            await downloadFromGitHub(platform);
-        }, 2000);
+        } catch (fallbackError) {
+            console.error('GitHub fallback also failed:', fallbackError);
+            showNotification(`下载失败: ${error.message}`, 'error');
+            
+            // Final fallback to GitHub releases page
+            setTimeout(() => {
+                showNotification('正在跳转到GitHub下载页面...', 'info');
+                window.open(`https://github.com/${GITHUB_REPO}/releases/latest`, '_blank');
+            }, 2000);
+        }
     } finally {
         // Restore button state
         setTimeout(() => {
@@ -76,6 +239,30 @@ async function downloadApp(platform) {
     }
 }
 
+// GitHub fallback function
+async function downloadFromGitHub(platform) {
+    const release = await getLatestRelease();
+    
+    if (!release) {
+        throw new Error('无法获取最新版本信息');
+    }
+    
+    const downloadUrl = findDownloadAsset(release.assets, platform);
+    
+    if (!downloadUrl) {
+        throw new Error(`暂无 ${getPlatformName(platform)} 版本下载`);
+    }
+    
+    // Show success notification
+    showNotification(`正在下载 ${getPlatformName(platform)} 版本 v${release.tag_name}...`, 'success');
+    
+    // Start download
+    window.open(downloadUrl, '_blank');
+    
+    // Track download
+    trackDownload(platform, release.tag_name);
+}
+
 // Get latest release from GitHub API
 async function getLatestRelease() {
     // Check cache first
@@ -104,6 +291,64 @@ async function getLatestRelease() {
     }
 }
 
+// Find appropriate file for platform from Alist files
+function findFileForPlatform(files, platform) {
+    if (!files || !Array.isArray(files)) {
+        return null;
+    }
+    
+    // Define file patterns for each platform
+    const patterns = {
+        windows: [
+            /\\.exe$/i,
+            /windows.*\\.zip$/i,
+            /win32.*\\.zip$/i,
+            /win.*x64.*\\.zip$/i
+        ],
+        macos: [
+            /\\.dmg$/i,
+            /darwin.*\\.zip$/i,
+            /macos.*\\.zip$/i,
+            /mac.*\\.zip$/i,
+            /osx.*\\.zip$/i
+        ],
+        linux: [
+            /\\.AppImage$/i,
+            /linux.*\\.zip$/i,
+            /linux.*\\.tar\\.gz$/i,
+            /\\.deb$/i,
+            /\\.rpm$/i
+        ]
+    };
+    
+    const platformPatterns = patterns[platform] || [];
+    
+    // Try to find exact match
+    for (const pattern of platformPatterns) {
+        const file = files.find(file => pattern.test(file.name));
+        if (file) {
+            return file.name;
+        }
+    }
+    
+    // Fallback: look for any file that might match the platform
+    const fallbackPatterns = {
+        windows: /win|exe/i,
+        macos: /mac|darwin|dmg/i,
+        linux: /linux|appimage|deb|rpm/i
+    };
+    
+    const fallbackPattern = fallbackPatterns[platform];
+    if (fallbackPattern) {
+        const file = files.find(file => fallbackPattern.test(file.name));
+        if (file) {
+            return file.name;
+        }
+    }
+    
+    return null;
+}
+
 // Find appropriate download asset based on platform
 function findDownloadAsset(assets, platform) {
     if (!assets || !Array.isArray(assets)) {
@@ -460,6 +705,36 @@ window.addEventListener('error', (e) => {
 // Update version information on page
 async function updateVersionInfo() {
     try {
+        // Try to get version info from Alist first
+        const versions = await getAlistVersions();
+        
+        if (versions.length > 0) {
+            const latestVersion = versions[0];
+            const versionElement = document.querySelector('.version');
+            const versionInfoElement = document.querySelector('.version-info p');
+            
+            if (versionElement) {
+                versionElement.textContent = latestVersion.name;
+            }
+            
+            if (versionInfoElement) {
+                const modifyDate = new Date(latestVersion.modified);
+                const formattedDate = modifyDate.toLocaleDateString('zh-CN', {
+                    year: 'numeric',
+                    month: 'long'
+                });
+                versionInfoElement.innerHTML = `当前版本: <span class="version">${latestVersion.name}</span> | 更新时间: ${formattedDate}`;
+            }
+            
+            // Update download button text with file info from Alist
+            const files = await getAlistVersionFiles(latestVersion.name);
+            updateDownloadButtonsWithAlistFiles(files);
+            
+            return; // Success, exit function
+        }
+        
+        // Fallback to GitHub if Alist fails
+        console.log('Alist version info failed, trying GitHub fallback...');
         const release = await getLatestRelease();
         if (release) {
             const versionElement = document.querySelector('.version');
@@ -486,6 +761,29 @@ async function updateVersionInfo() {
     }
 }
 
+// Update download buttons with Alist file information
+function updateDownloadButtonsWithAlistFiles(files) {
+    if (!files || !Array.isArray(files)) return;
+    
+    const downloadCards = document.querySelectorAll('.download-card');
+    const platforms = ['windows', 'macos', 'linux'];
+    
+    downloadCards.forEach((card, index) => {
+        const platform = platforms[index];
+        const fileName = findFileForPlatform(files, platform);
+        
+        if (fileName) {
+            const file = files.find(f => f.name === fileName);
+            const button = card.querySelector('.btn-download');
+            const sizeText = formatFileSize(file.size);
+            const originalText = button.innerHTML;
+            
+            // Add file size info
+            button.innerHTML = originalText.replace(/下载 \..*?$/, `下载 .${getFileExtension(fileName)} (${sizeText})`);
+        }
+    });
+}
+
 // Update download buttons with asset information
 function updateDownloadButtonsWithAssets(assets) {
     if (!assets || !Array.isArray(assets)) return;