docs: update beta download links

release: 2.0.0-beta.2
fix(http): infer extension for opaque URLs (#1495 )
2026-11-10 10:30:28 +00:00 · 2026-09-11 08:36:01 +08:00 · 2026-09-11 08:20:45 +08:00 · 2026-09-11 08:01:32 +08:00 · 2026-09-11 08:00:03 +08:00 · 2026-09-10 23:51:16 +08:00
1032 changed files with 131363 additions and 14469 deletions
@@ -0,0 +1,16 @@
+.git
+
+*.data
+*.log
+
+node_modules
+**/node_modules
+
+Dockerfile
+.dockerignore
+
+.github
+_docs
+_examples
+bin
+ui
@@ -0,0 +1 @@
+* @monkeyWie
@@ -12,4 +12,4 @@
 #custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
 # github: monkeyWie
 ko_fi: gopeed
-custom: https://docs.gopeed.com/donate.html
+custom: https://gopeed.com/docs/donate
@@ -1,43 +1,189 @@
-name-template: 'v$NEXT_PATCH_VERSION 🌈'
-tag-template: 'v$NEXT_PATCH_VERSION'
+name-template: "v$NEXT_PATCH_VERSION 🌈"
+tag-template: "v$NEXT_PATCH_VERSION"
 categories:
-  - title: '🆕 Features'
+  - title: "🆕 Features"
    labels:
-      - 'feat'
-      - 'feature'
-      - 'enhancement'
-  - title: '🐛 Bug Fixes'
+      - "feat"
+      - "feature"
+      - "enhancement"
+  - title: "🐛 Bug Fixes"
    labels:
-      - 'fix'
-      - 'bugfix'
-      - 'bug'
-  - title: '🧪 Tests'
-    label: 'test'
-  - title: '🧰 Maintenance'
-    label: 'chore'
-  - title: '📖 Document'
-    label: 'doc'
-  - title: '🚀 CI/CD'
-    label: 'ci'
-  - title: '🌎 Internationalization'
-    label: 'translation'
-change-template: '- $TITLE @$AUTHOR (#$NUMBER)'
+      - "fix"
+      - "bugfix"
+      - "bug"
+  - title: "🔧 Performance Improvements"
+    labels:
+      - "perf"
+  - title: "🧪 Tests"
+    label: "test"
+  - title: "🧰 Maintenance"
+    label: "chore"
+  - title: "📖 Document"
+    label: "docs"
+  - title: "🚀 CI/CD"
+    label: "ci"
+  - title: "🌎 Internationalization"
+    label: "translation"
+change-template: "- $TITLE @$AUTHOR (#$NUMBER)"
 version-resolver:
  major:
    labels:
-      - 'major'
+      - "major"
  minor:
    labels:
-      - 'minor'
+      - "minor"
  patch:
    labels:
-      - 'patch'
+      - "patch"
  default: patch
 template: |
-  # Changes
+  <table>
+    <tbody>
+      <tr>
+        <td rowspan="4">🪟 Windows</td>
+        <td rowspan="2"><code>EXE</code></td>
+        <td>amd64</td>
+        <td><a href="https://gopeed.com/api/download?tpl=Gopeed-v$NEXT_PATCH_VERSION-windows-amd64.zip">📥</a></td>
+      </tr>
+      <tr>
+        <td>arm64</td>
+        <td><a href="https://gopeed.com/api/download?tpl=Gopeed-v$NEXT_PATCH_VERSION-windows-arm64.zip">📥</a></td>
+      </tr>
+      <tr>
+        <td rowspan="2"><code>Portable</code></td>
+        <td>amd64</td>
+        <td><a href="https://gopeed.com/api/download?tpl=Gopeed-v$NEXT_PATCH_VERSION-windows-amd64-portable.zip">📥</a></td>
+      </tr>
+      <tr>
+        <td>arm64</td>
+        <td><a href="https://gopeed.com/api/download?tpl=Gopeed-v$NEXT_PATCH_VERSION-windows-arm64-portable.zip">📥</a></td>
+      </tr>
+      <tr>
+        <td rowspan="3">🍎 MacOS</td>
+        <td rowspan="3"><code>DMG</code></td>
+        <td>universal</td>
+        <td><a href="https://gopeed.com/api/download?tpl=Gopeed-v$NEXT_PATCH_VERSION-macos.dmg">📥</a></td>
+      </tr>
+      <tr>
+        <td>amd64</td>
+        <td><a href="https://gopeed.com/api/download?tpl=Gopeed-v$NEXT_PATCH_VERSION-macos-amd64.dmg">📥</a></td>
+      </tr>
+      <tr>
+        <td>arm64</td>
+        <td><a href="https://gopeed.com/api/download?tpl=Gopeed-v$NEXT_PATCH_VERSION-macos-arm64.dmg">📥</a></td>
+      </tr>
+      <tr>
+        <td rowspan="6">🐧 Linux</td>
+        <td><code>Flathub</code></td>
+        <td>amd64</td>
+        <td><a href="https://flathub.org/apps/com.gopeed.Gopeed">📥</a></td>
+      </tr>
+      <tr>
+        <td><code>SNAP</code></td>
+        <td>amd64</td>
+        <td><a href="https://snapcraft.io/gopeed">📥</a></td>
+      </tr>
+      <tr>
+        <td rowspan="2"><code>DEB</code></td>
+        <td>amd64</td>
+        <td><a href="https://gopeed.com/api/download?tpl=Gopeed-v$NEXT_PATCH_VERSION-linux-amd64.deb">📥</a></td>
+      </tr>
+      <tr>
+        <td>arm64</td>
+        <td><a href="https://gopeed.com/api/download?tpl=Gopeed-v$NEXT_PATCH_VERSION-linux-arm64.deb">📥</a></td>
+      </tr>
+      <tr>
+        <td rowspan="2"><code>AppImage</code></td>
+        <td>amd64</td>
+        <td><a href="https://gopeed.com/api/download?tpl=Gopeed-v$NEXT_PATCH_VERSION-linux-amd64.AppImage">📥</a></td>
+      </tr>
+      <tr>
+        <td>arm64</td>
+        <td><a href="https://gopeed.com/api/download?tpl=Gopeed-v$NEXT_PATCH_VERSION-linux-arm64.AppImage">📥</a></td>
+      </tr>
+      <tr>
+        <td rowspan="4">🤖 Android</td>
+        <td rowspan="4"><code>APK</code></td>
+        <td>universal</td>
+        <td><a href="https://gopeed.com/api/download?tpl=Gopeed-v$NEXT_PATCH_VERSION-android.apk">📥</a></td>
+      </tr>
+      <tr>
+        <td>armeabi-v7a</td>
+        <td><a href="https://gopeed.com/api/download?tpl=Gopeed-v$NEXT_PATCH_VERSION-android-armeabi-v7a.apk">📥</a></td>
+      </tr>
+      <tr>
+        <td>arm64-v8a</td>
+        <td><a href="https://gopeed.com/api/download?tpl=Gopeed-v$NEXT_PATCH_VERSION-android-arm64-v8a.apk">📥</a></td>
+      </tr>
+      <tr>
+        <td>x86_64</td>
+        <td><a href="https://gopeed.com/api/download?tpl=Gopeed-v$NEXT_PATCH_VERSION-android-x86_64.apk">📥</a></td>
+      </tr>
+      <tr>
+        <td>📱 iOS</td>
+        <td><code>IPA</code></td>
+        <td>universal</td>
+        <td><a href="https://gopeed.com/api/download?tpl=Gopeed-v$NEXT_PATCH_VERSION-ios.ipa">📥</a></td>
+      </tr>
+      <tr>
+        <td>🐳 Docker</td>
+        <td>-</td>
+        <td>universal</td>
+        <td><a href="https://hub.docker.com/r/liwei2633/gopeed">📥</a></td>
+      </tr>
+      <tr>
+        <td rowspan="2">💾 Qnap</td>
+        <td rowspan="2"><code>QPKG</code></td>
+        <td>amd64</td>
+        <td><a href="https://gopeed.com/api/download?tpl=gopeed-v$NEXT_PATCH_VERSION-qnap-amd64.qpkg">📥</a></td>
+      </tr>
+      <tr>
+        <td>arm64</td>
+        <td><a href="https://gopeed.com/api/download?tpl=gopeed-v$NEXT_PATCH_VERSION-qnap-arm64.qpkg">📥</a></td>
+      </tr>
+      <tr>
+        <td rowspan="8">🌐 Web</td>
+        <td rowspan="3"><code>Windows</code></td>
+        <td>amd64</td>
+        <td><a href="https://gopeed.com/api/download?tpl=gopeed-web-v$NEXT_PATCH_VERSION-windows-amd64.zip">📥</a></td>
+      </tr>
+      <tr>
+        <td>arm64</td>
+        <td><a href="https://gopeed.com/api/download?tpl=gopeed-web-v$NEXT_PATCH_VERSION-windows-arm64.zip">📥</a></td>
+      </tr>
+      <tr>
+        <td>386</td>
+        <td><a href="https://gopeed.com/api/download?tpl=gopeed-web-v$NEXT_PATCH_VERSION-windows-386.zip">📥</a></td>
+      </tr>
+      <tr>
+        <td rowspan="2"><code>MacOS</code></td>
+        <td>amd64</td>
+        <td><a href="https://gopeed.com/api/download?tpl=gopeed-web-v$NEXT_PATCH_VERSION-macos-amd64.zip">📥</a></td>
+      </tr>
+      <tr>
+        <td>arm64</td>
+        <td><a href="https://gopeed.com/api/download?tpl=gopeed-web-v$NEXT_PATCH_VERSION-macos-arm64.zip">📥</a></td>
+      </tr>
+      <tr>
+        <td rowspan="3"><code>Linux</code></td>
+        <td>amd64</td>
+        <td><a href="https://gopeed.com/api/download?tpl=gopeed-web-v$NEXT_PATCH_VERSION-linux-amd64.zip">📥</a></td>
+      </tr>
+      <tr>
+        <td>arm64</td>
+        <td><a href="https://gopeed.com/api/download?tpl=gopeed-web-v$NEXT_PATCH_VERSION-linux-arm64.zip">📥</a></td>
+      </tr>
+      <tr>
+        <td>386</td>
+        <td><a href="https://gopeed.com/api/download?tpl=gopeed-web-v$NEXT_PATCH_VERSION-linux-386.zip">📥</a></td>
+      </tr>
+    </tbody>
+  </table>
+
+  # Release notes

  $CHANGES
-  
+
  # 更新日志

-  $CHANGES
+  $CHANGES
@@ -4,17 +4,19 @@ on:
  workflow_dispatch:
    inputs:
      platform:
-        description: 'Build platform'
+        description: "Build platform"
        required: true
-        default: 'all'
-      channel:
-        description: 'Snap channel'
+        default: "all"
+      test:
+        description: "Test mode"
        required: true
-        default: 'stable'
+        default: "false"

 env:
-  GO_VERSION: "1.19"
-  FLUTTER_VERSION: "3.16.1"
+  GO_VERSION: "1.25.4"
+  FLUTTER_VERSION: "3.41.6"
+  GA4_MEASUREMENT_ID: ${{ secrets.GA4_MEASUREMENT_ID }}
+  GA4_API_SECRET: ${{ secrets.GA4_API_SECRET }}

 permissions:
  contents: write
@@ -23,57 +25,113 @@ jobs:
  get-release:
    runs-on: ubuntu-latest
    outputs:
-      tag_name: ${{ steps.get-release.outputs.tag_name }}
+      version: ${{ steps.get-release.outputs.version }}
      upload_url: ${{ steps.get-release.outputs.upload_url }}

    steps:
-      - uses: monkeyWie/get-latest-release@v1
+      - uses: monkeyWie/get-latest-release@v2.1
        id: get-release
        with:
          myToken: ${{ github.token }}

  build-windows:
    if: ${{ github.event.inputs.platform == 'all' || github.event.inputs.platform == 'windows' }}
-    runs-on: windows-latest
-    needs: [ get-release ]
+    needs: [get-release]
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - arch: arm64
+            os: windows-11-arm
+            llvm_ver: "20251202" # Only ARM64
+            flutter_channel: "main"
+            flutter_version: "7e1c8868"
+          - arch: amd64
+            os: windows-2022
+    runs-on: ${{ matrix.os }}
+
    steps:
      - uses: actions/checkout@v3
-      - uses: actions/setup-go@v4
+      - name: Enable long paths for flutter main branch checks
+        run: |
+          git config --global core.longpaths true
+
+      # Install LLVM environment only on ARM64
+      - name: Install llvm-mingw-ucrt-aarch64 (ARM64 only)
+        if: matrix.arch == 'arm64'
+        run: |
+          $ver = "${{ matrix.llvm_ver }}"
+          $url = "https://github.com/mstorsjo/llvm-mingw/releases/download/$ver/llvm-mingw-$ver-ucrt-aarch64.zip"
+          $zip = "$env:RUNNER_TEMP\\llvm.zip"
+          $extract = "$env:RUNNER_TEMP\\extract"
+          $target = "C:\\clangarm64"
+
+          curl -L $url -o $zip
+          rm -r -fo $extract,$target -ea Ignore
+          mkdir $extract | Out-Null
+
+          tar -xf $zip -C $extract
+          mv (Get-ChildItem $extract)[0].FullName $target
+
+          $b = "$target\\bin"
+          "CC=$b\\clang.exe"        >> $env:GITHUB_ENV
+          "CXX=$b\\clang++.exe"     >> $env:GITHUB_ENV
+          "CLANGARM64_BIN=$b"       >> $env:GITHUB_ENV
+          "CGO_ENABLED=1"           >> $env:GITHUB_ENV
+          "CLANGARM64_ROOT=$target" >> $env:GITHUB_ENV
+          $b >> $env:GITHUB_PATH
+
+      - uses: actions/setup-go@v5
        with:
-          go-version: "1.20"
+          go-version: ${{ env.GO_VERSION }}
      - uses: subosito/flutter-action@v2
        with:
-          flutter-version: ${{ env.FLUTTER_VERSION }}
+          channel: ${{ matrix.flutter_channel || 'stable' }}
+          flutter-version: ${{ matrix.flutter_version || env.FLUTTER_VERSION }}
      - name: Build
        env:
-          VERSION: ${{ needs.get-release.outputs.tag_name }}
+          VERSION: ${{ needs.get-release.outputs.version }}
+          GOARCH: ${{ matrix.arch }}
        run: |
-          Invoke-WebRequest -Uri "https://github.com/jrsoftware/issrc/raw/main/Files/Languages/Unofficial/ChineseSimplified.isl" -OutFile "ChineseSimplified.isl"
+          Invoke-WebRequest -Uri "https://github.com/jrsoftware/issrc/raw/main/Files/Languages/ChineseSimplified.isl" -OutFile "ChineseSimplified.isl"
          mv ChineseSimplified.isl "C:\Program Files (x86)\Inno Setup 6\Languages\"

-          go build -tags nosqlite -ldflags="-w -s" -buildmode=c-shared -o ui/flutter/windows/libgopeed.dll github.com/GopeedLab/gopeed/bind/desktop
+          go build -tags nosqlite -ldflags="-w -s -X github.com/GopeedLab/gopeed/pkg/base.Version=$env:VERSION" -buildmode=c-shared -o ui/flutter/windows/libgopeed.dll github.com/GopeedLab/gopeed/bind/desktop
+          go build -ldflags="-w -s" -o ui/flutter/assets/exec/host.exe github.com/GopeedLab/gopeed/cmd/host
+          go build -ldflags="-w -s" -o ui/flutter/assets/exec/updater.exe github.com/GopeedLab/gopeed/cmd/updater
          cd ui/flutter
-          flutter build windows
-          $mingw = "C:\Program Files\Git\mingw64\bin"
+          $TAG = "v$env:VERSION"
+          flutter build windows --dart-define="UPDATE_CHANNEL=windowsPortable" --dart-define="GA4_MEASUREMENT_ID=${{ env.GA4_MEASUREMENT_ID }}" --dart-define="GA4_API_SECRET=${{ env.GA4_API_SECRET }}"
          $system = "C:\Windows\System32"
-          $release = "build\windows\x64\runner\Release\"
-          cp $mingw\libstdc++-6.dll $release
-          cp $mingw\libgcc_s_seh-1.dll $release
+          if ("${{ matrix.arch }}" -eq "amd64") {
+              # for amd64
+              $release = "build\windows\x64\runner\Release\"
+              $mingw = "C:\Program Files\Git\mingw64\bin"
+              cp $mingw\libstdc++-6.dll $release
+              cp $mingw\libgcc_s_seh-1.dll $release
+          } else {
+              # for ARM64
+              $release = "build\windows\arm64\runner\Release\"
+              $mingw = "$env:CLANGARM64_ROOT\aarch64-w64-mingw32\bin"
+              cp $mingw\libc++.dll $release
+              cp $mingw\libunwind.dll $release
+          }
          cp $mingw\libwinpthread-1.dll $release
          cp $system\msvcp140.dll $release
          cp $system\vcruntime140.dll $release
          cp $system\vcruntime140_1.dll $release

          New-Item -Path build\windows\Output -ItemType Directory
-          Compress-Archive -Path "$release*" -DestinationPath "build\windows\Output\Gopeed-$env:VERSION-windows-amd64-portable.zip"
+          Compress-Archive -Path "$release*" -DestinationPath "build\windows\Output\Gopeed-$TAG-windows-${{ matrix.arch }}-portable.zip"

+          flutter build windows --dart-define="UPDATE_CHANNEL=windowsInstaller" --dart-define="GA4_MEASUREMENT_ID=${{ env.GA4_MEASUREMENT_ID }}" --dart-define="GA4_API_SECRET=${{ env.GA4_API_SECRET }}"
          cd build/windows
          echo @"
          ; Script generated by the Inno Setup Script Wizard.
          ; SEE THE DOCUMENTATION FOR DETAILS ON CREATING INNO SETUP SCRIPT FILES!

          #define MyAppName "Gopeed"
-          #define MyAppVersion "$($env:VERSION.substring(1))"
+          #define MyAppVersion "$env:VERSION"
          #define MyAppPublisher "monkeyWie"
          #define MyAppURL "https://gopeed.com"
          #define MyAppExeName "gopeed.exe"
@@ -96,11 +154,13 @@ jobs:
          PrivilegesRequired=lowest
          OutputBaseFilename=gopeed
          SetupIconFile=..\..\assets\icon\icon.ico
+          UninstallDisplayIcon={app}\{#MyAppExeName}
          Compression=lzma
          SolidCompression=yes
          WizardStyle=modern
          LanguageDetectionMethod=uilanguage
          ShowLanguageDialog=yes
+          CloseApplications=force

          [Languages]
          Name: "english"; MessagesFile: "compiler:Default.isl"
@@ -110,7 +170,7 @@ jobs:
          Name: "desktopicon"; Description: "{cm:CreateDesktopIcon}"; GroupDescription: "{cm:AdditionalIcons}"; Flags: unchecked

          [Files]
-          Source: ".\x64\runner\Release\*"; DestDir: "{app}"; Flags: ignoreversion recursesubdirs
+          Source: ".\${{ matrix.arch == 'amd64' && 'x64' || 'arm64' }}\runner\Release\*"; DestDir: "{app}"; Flags: ignoreversion recursesubdirs;
          ; NOTE: Don't use "Flags: ignoreversion" on any shared system files

          [UninstallDelete]
@@ -124,40 +184,47 @@ jobs:
          Filename: "{app}\{#MyAppExeName}"; Description: "{cm:LaunchProgram,{#StringChange(MyAppName, '&', '&&')}}"; Flags: nowait postinstall skipifsilent
          "@ > setup.iss
          iscc.exe setup.iss
-          mv "Output\gopeed.exe" "Output\Gopeed-$env:VERSION-windows-amd64.exe"
-          Compress-Archive -Path "Output\Gopeed-$env:VERSION-windows-amd64.exe" -DestinationPath "Output\Gopeed-$env:VERSION-windows-amd64.zip"
-          Remove-Item -Path "Output\Gopeed-$env:VERSION-windows-amd64.exe"
+          mv "Output\gopeed.exe" "Output\Gopeed-$TAG-windows-${{ matrix.arch }}.exe"
+          Compress-Archive -Path "Output\Gopeed-$TAG-windows-${{ matrix.arch }}.exe" -DestinationPath "Output\Gopeed-$TAG-windows-${{ matrix.arch }}.zip"
      - name: Upload
-        uses: shogo82148/actions-upload-release-asset@v1
+        uses: shogo82148/actions-upload-release-asset@v1.9.2
        with:
          upload_url: ${{ needs.get-release.outputs.upload_url }}
          asset_path: ui/flutter/build/windows/Output/*
          overwrite: true
-  build-macos-arm64-lib:
+  build-macos-amd64-lib:
    if: ${{ github.event.inputs.platform == 'all' || github.event.inputs.platform == 'macos' }}
-    runs-on: ubuntu-latest
-    needs: [ get-release ]
+    runs-on: macos-15-intel
+    needs: [get-release]
    steps:
      - uses: actions/checkout@v3
-      - uses: actions/setup-go@v4
+      - uses: actions/setup-go@v5
        with:
          go-version: ${{ env.GO_VERSION }}
      - name: Build
+        env:
+          VERSION: ${{ needs.get-release.outputs.version }}
        run: |
-          go install src.techknowlogick.com/xgo@latest
-          xgo -go go-$GO_VERSION.x --targets=darwin/arm64 -tags="nosqlite" -ldflags="-w -s" -buildmode=c-shared -pkg=bind/desktop -out=libgopeed .
-          mv libgopeed-*.dylib libgopeed.dylib
-      - uses: actions/upload-artifact@v3
+          go build -tags nosqlite -ldflags="-w -s -X github.com/GopeedLab/gopeed/pkg/base.Version=$VERSION" -buildmode=c-shared -o libgopeed.dylib github.com/GopeedLab/gopeed/bind/desktop
+          go build -ldflags="-w -s" github.com/GopeedLab/gopeed/cmd/host
+          go build -ldflags="-w -s" github.com/GopeedLab/gopeed/cmd/updater
+      - uses: actions/upload-artifact@v4
        with:
-          name: macos-arm64-lib
-          path: libgopeed.dylib
+          name: macos-amd64-lib
+          path: |
+            libgopeed.dylib
+            host
+            updater
  build-macos:
    if: ${{ github.event.inputs.platform == 'all' || github.event.inputs.platform == 'macos' }}
    runs-on: macos-latest
-    needs: [ get-release, build-macos-arm64-lib ]
+    strategy:
+      matrix:
+        channel: [arm64, amd64, universal]
+    needs: [get-release, build-macos-amd64-lib]
    steps:
      - uses: actions/checkout@v3
-      - uses: actions/setup-go@v4
+      - uses: actions/setup-go@v5
        with:
          go-version: ${{ env.GO_VERSION }}
      - uses: actions/setup-node@v3
@@ -168,29 +235,51 @@ jobs:
          flutter-version: ${{ env.FLUTTER_VERSION }}
      - name: Install appdmg
        run: |
-          python3 -m pip install setuptools
+          python3 -m pip install setuptools --break-system-packages
          npm install -g appdmg
-      - uses: actions/download-artifact@v3
+      - uses: actions/download-artifact@v4
        with:
-          name: macos-arm64-lib
-          path: ui/flutter/lib-arm64
-      - name: Build
-        env:
-          VERSION: ${{ needs.get-release.outputs.tag_name }}
+          name: macos-amd64-lib
+          path: ui/flutter/lib-amd64
+      - if: ${{ matrix.channel == 'arm64' }}
+        name: Build Arm64 Libraries
        run: |
-          PROJECT_DIR=$(pwd)
+          go build -tags nosqlite -ldflags="-w -s -X github.com/GopeedLab/gopeed/pkg/base.Version=$VERSION" -buildmode=c-shared -o ui/flutter/macos/Frameworks/libgopeed.dylib github.com/GopeedLab/gopeed/bind/desktop
+          go build -ldflags="-w -s" -o ui/flutter/assets/exec/host github.com/GopeedLab/gopeed/cmd/host
+          go build -ldflags="-w -s" -o ui/flutter/assets/exec/updater github.com/GopeedLab/gopeed/cmd/updater
+      - if: ${{ matrix.channel == 'amd64' }}
+        name: Build Amd64 Libraries
+        run: |
+          mkdir -p ui/flutter/macos/Frameworks
+
+          cp ui/flutter/lib-amd64/libgopeed.dylib ui/flutter/macos/Frameworks/libgopeed.dylib
+          cp ui/flutter/lib-amd64/host ui/flutter/assets/exec/host
+          cp ui/flutter/lib-amd64/updater ui/flutter/assets/exec/updater
+      - if: ${{ matrix.channel == 'universal' }}
+        name: Build Universal Libraries
+        run: |
+          mkdir -p ui/flutter/macos/Frameworks
+
+          # arm64 lib
+          go build -tags nosqlite -ldflags="-w -s -X github.com/GopeedLab/gopeed/pkg/base.Version=$VERSION" -buildmode=c-shared -o ui/flutter/.temp/libgopeed.dylib.arm64 github.com/GopeedLab/gopeed/bind/desktop
+          go build -ldflags="-w -s" -o ui/flutter/.temp/host.arm64 github.com/GopeedLab/gopeed/cmd/host
+          go build -ldflags="-w -s" -o ui/flutter/.temp/updater.arm64 github.com/GopeedLab/gopeed/cmd/updater

          # amd64 lib
-          go build -tags nosqlite -ldflags="-w -s" -buildmode=c-shared -o ui/flutter/lib-amd64/libgopeed.dylib github.com/GopeedLab/gopeed/bind/desktop
-          # universal binary
-          mkdir -p ui/flutter/macos/Frameworks
-          cp ui/flutter/lib-amd64/libgopeed.dylib ui/flutter/macos/Frameworks/amd64-lib
-          cp ui/flutter/lib-arm64/libgopeed.dylib ui/flutter/macos/Frameworks/arm64-lib
-          cd ui/flutter/macos/Frameworks
-          lipo -create -output libgopeed.dylib amd64-lib arm64-lib
+          cp ui/flutter/lib-amd64/libgopeed.dylib ui/flutter/.temp/libgopeed.dylib.amd64
+          cp ui/flutter/lib-amd64/host ui/flutter/.temp/host.amd64
+          cp ui/flutter/lib-amd64/updater ui/flutter/.temp/updater.amd64

-          cd $PROJECT_DIR/ui/flutter
-          flutter build macos
+          # universal lib
+          lipo -create -output ui/flutter/macos/Frameworks/libgopeed.dylib ui/flutter/.temp/libgopeed.dylib.arm64 ui/flutter/.temp/libgopeed.dylib.amd64
+          lipo -create -output ui/flutter/assets/exec/host ui/flutter/.temp/host.arm64 ui/flutter/.temp/host.amd64
+          lipo -create -output ui/flutter/assets/exec/updater ui/flutter/.temp/updater.arm64 ui/flutter/.temp/updater.amd64
+      - name: Build
+        env:
+          VERSION: ${{ needs.get-release.outputs.version }}
+        run: |
+          cd ui/flutter
+          flutter build macos --dart-define="UPDATE_CHANNEL=macosDmg" --dart-define="GA4_MEASUREMENT_ID=${{ env.GA4_MEASUREMENT_ID }}" --dart-define="GA4_API_SECRET=${{ env.GA4_API_SECRET }}"
          cd build/macos/Build/Products/Release
          cat>appdmg.json<<EOF
          {
@@ -203,7 +292,14 @@ jobs:
          }
          EOF
          mkdir dist
-          appdmg appdmg.json dist/Gopeed-$VERSION-macos.dmg
+          appdmg appdmg.json dist/Gopeed-v$VERSION-macos.dmg
+
+          if [[ "${{ matrix.channel }}" == "arm64" ]]; then
+            mv dist/Gopeed-v$VERSION-macos.dmg dist/Gopeed-v$VERSION-macos-arm64.dmg
+          fi
+          if [[ "${{ matrix.channel }}" == "amd64" ]]; then
+            mv dist/Gopeed-v$VERSION-macos.dmg dist/Gopeed-v$VERSION-macos-amd64.dmg
+          fi
      - name: Upload
        uses: shogo82148/actions-upload-release-asset@v1
        with:
@@ -212,230 +308,267 @@ jobs:
          overwrite: true
  build-linux:
    if: ${{ github.event.inputs.platform == 'all' || github.event.inputs.platform == 'linux' }}
-    runs-on: ubuntu-20.04
-    needs: [ get-release ]
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-22.04, ubuntu-22.04-arm]
+    needs: [get-release]
    steps:
      - uses: actions/checkout@v3
-      - uses: actions/setup-go@v4
+      - uses: actions/setup-go@v5
        with:
          go-version: ${{ env.GO_VERSION }}
      - uses: subosito/flutter-action@v2
        with:
          flutter-version: ${{ env.FLUTTER_VERSION }}
+          channel: master
      - run: |
-          sudo apt-get update -y
-          sudo apt-get install -y ninja-build libgtk-3-dev libappindicator3-dev
+          sudo apt update -y
+          sudo apt install -y ninja-build libgtk-3-dev libwebkit2gtk-4.1-dev libayatana-appindicator3-1 libayatana-appindicator3-dev rpm patchelf libfuse2 locate libkeybinder-3.0-dev
+          arch=$(uname -m)
+          wget -O appimagetool "https://github.com/AppImage/appimagetool/releases/download/continuous/appimagetool-${arch}.AppImage"
+          chmod +x appimagetool
+          sudo mv appimagetool /usr/local/bin/
      - name: Build
        env:
-          VERSION: ${{ needs.get-release.outputs.tag_name }}
+          VERSION: ${{ needs.get-release.outputs.version }}
        run: |
-          go build -tags nosqlite -ldflags="-w -s" -buildmode=c-shared -o ui/flutter/linux/bundle/lib/libgopeed.so github.com/GopeedLab/gopeed/bind/desktop
+          go build -tags nosqlite -ldflags="-w -s -X github.com/GopeedLab/gopeed/pkg/base.Version=$VERSION" -buildmode=c-shared -o ui/flutter/linux/bundle/lib/libgopeed.so github.com/GopeedLab/gopeed/bind/desktop
+          go build -ldflags="-w -s" -o ui/flutter/assets/exec/host github.com/GopeedLab/gopeed/cmd/host
+          go build -ldflags="-w -s" -o ui/flutter/assets/exec/updater github.com/GopeedLab/gopeed/cmd/updater
+
          cd ui/flutter
-          flutter build linux
-          mkdir -p build/dist
-          
-          # Build portable
-          tar -C build/linux/x64/release/bundle -czaf build/dist/Gopeed-$VERSION-linux-amd64-portable.tar.gz ./
-          
-          # Build deb package
-          mkdir -p debian/gopeed/opt/gopeed
-          mkdir -p debian/gopeed/usr/share/applications
-          mkdir -p debian/gopeed/usr/share/icons/hicolor/scalable/apps
-          mkdir -p debian/gopeed/DEBIAN

-          cp -r build/linux/x64/release/bundle/* debian/gopeed/opt/gopeed/
-          cp assets/icon/icon.svg debian/gopeed/usr/share/icons/hicolor/scalable/apps/com.gopeed.Gopeed.svg
-          
-          cat>debian/gopeed/DEBIAN/postinst<<EOF
-          #!/bin/bash
-          ln -sf /opt/gopeed/gopeed /usr/bin/gopeed
+          RPM_ARCH=$(uname -m)
+          mkdir -p linux/packaging/rpm
+          cat << EOF > linux/packaging/rpm/make_config.yaml
+          display_name: Gopeed
+          icon: assets/icon/icon.svg
+          summary: High speed downloader.
+          description: A high speed downloader that supports all platforms.
+          group: Applications/Internet
+          license: GPL-3.0
+          url: https://github.com/GopeedLab/gopeed
+          vendor: GopeedLab
+          maintainer: GopeedLab <[email protected]>
+          build_arch: $RPM_ARCH
          EOF

-          cat>debian/gopeed/DEBIAN/postrm<<EOF
-          #!/bin/bash
-          rm -rf /usr/bin/gopeed
+          cat << EOF > distribute_options.yaml
+          output: dist/
+          releases:
+            - name: linux
+              jobs:
+                - name: appimage
+                  package:
+                    platform: linux
+                    target: appimage
+                    build_args:
+                      dart-define:
+                        UPDATE_CHANNEL: linuxAppImage
+                        GA4_MEASUREMENT_ID: ${{ env.GA4_MEASUREMENT_ID }}
+                        GA4_API_SECRET: ${{ env.GA4_API_SECRET }}
+                - name: deb
+                  package:
+                    platform: linux
+                    target: deb
+                    build_args:
+                      dart-define:
+                        UPDATE_CHANNEL: linuxDeb
+                        GA4_MEASUREMENT_ID: ${{ env.GA4_MEASUREMENT_ID }}
+                        GA4_API_SECRET: ${{ env.GA4_API_SECRET }}
+                - name: rpm
+                  package:
+                    platform: linux
+                    target: rpm
+                    build_args:
+                      dart-define:
+                        UPDATE_CHANNEL: linuxRpm
+                        GA4_MEASUREMENT_ID: ${{ env.GA4_MEASUREMENT_ID }}
+                        GA4_API_SECRET: ${{ env.GA4_API_SECRET }}
          EOF
+          dart pub global activate -sgit https://github.com/GopeedLab/flutter_distributor.git --git-path packages/flutter_distributor
+          flutter_distributor release --name linux
+          cd dist/*

-          chmod 0755 debian/gopeed/DEBIAN/postinst
-          chmod 0755 debian/gopeed/DEBIAN/postrm
-
-          cat>debian/gopeed/DEBIAN/control<<EOF
-          Package: gopeed
-          Version: ${VERSION:1}
-          Architecture: amd64
-          Essential: no
-          Priority: optional
-          Depends: 
-          Maintainer: monkeyWie
-          Description: High speed downloader that supports all platforms.
-          EOF
-
-          cp linux/assets/com.gopeed.Gopeed.desktop debian/gopeed/usr/share/applications/gopeed.desktop
-
-          dpkg-deb --build debian/gopeed
-          mv debian/gopeed.deb build/dist/Gopeed-$VERSION-linux-amd64.deb
-          
-          # Build AppImage
-          sudo apt-get -y install libfuse2
-          wget -O appimage-builder https://github.com/AppImageCrafters/appimage-builder/releases/download/v1.1.0/appimage-builder-1.1.0-x86_64.AppImage
-          chmod +x appimage-builder
-          mkdir AppDir
-          cp -r build/linux/x64/release/bundle/* AppDir
-          mkdir -p AppDir/usr/share/icons/hicolor/scalable/apps/
-          cp assets/icon/icon.svg AppDir/usr/share/icons/hicolor/scalable/apps/gopeed.svg
-          cat>AppImageBuilder.yml<<EOF
-          version: 1
-          AppDir:
-            path: ${PWD}/AppDir
-            app_info:
-              id: com.gopeed.gopeed
-              name: Gopeed
-              icon: gopeed
-              version: ${VERSION:1}
-              exec: gopeed
-              exec_args: \$@
-            apt:
-              arch: amd64
-              allow_unauthenticated: true
-              sources:
-                - sourceline: deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ jammy main restricted
-                    universe multiverse
-                - sourceline: deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ jammy-updates main
-                    restricted universe multiverse
-                - sourceline: deb https://mirrors.tuna.tsinghua.edu.cn/ubuntu/ jammy-backports
-                    main restricted universe multiverse
-                - sourceline: deb http://security.ubuntu.com/ubuntu/ jammy-security main restricted
-                    universe multiverse
-              include: []
-            files:
-              include: []
-              exclude:
-                - usr/share/man
-                - usr/share/doc/*/README.*
-                - usr/share/doc/*/changelog.*
-                - usr/share/doc/*/NEWS.*
-                - usr/share/doc/*/TODO.*
-            test:
-              fedora-30:
-                image: appimagecrafters/tests-env:fedora-30
-                command: ./AppRun
-              debian-stable:
-                image: appimagecrafters/tests-env:debian-stable
-                command: ./AppRun
-              archlinux-latest:
-                image: appimagecrafters/tests-env:archlinux-latest
-                command: ./AppRun
-              centos-7:
-                image: appimagecrafters/tests-env:centos-7
-                command: ./AppRun
-              ubuntu-xenial:
-                image: appimagecrafters/tests-env:ubuntu-xenial
-                command: ./AppRun
-          AppImage:
-            arch: x86_64
-            update-information: guess
-          EOF
-          ./appimage-builder --skip-tests --recipe AppImageBuilder.yml
-          mv Gopeed-*-x86_64.AppImage build/dist/Gopeed-$VERSION-linux-amd64.AppImage
+          ARCH="amd64"
+          if [[ "${{ matrix.os }}" == *-arm ]]; then
+            ARCH="arm64"
+          fi

+          mv gopeed-*-linux.AppImage Gopeed-v${VERSION}-linux-${ARCH}.AppImage
+          mv gopeed-*-linux.deb Gopeed-v${VERSION}-linux-${ARCH}.deb
+          mv gopeed-*-linux.rpm Gopeed-v${VERSION}-linux-${ARCH}.rpm
      - name: Upload
        uses: shogo82148/actions-upload-release-asset@v1
        with:
          upload_url: ${{ needs.get-release.outputs.upload_url }}
-          asset_path: ui/flutter/build/dist/*
+          asset_path: ui/flutter/dist/*/*
          overwrite: true
  build-snap:
    if: ${{ github.event.inputs.platform == 'all' || github.event.inputs.platform == 'snap' }}
-    runs-on: ubuntu-latest
-    needs: [ get-release ]
+    runs-on: ubuntu-24.04
+    needs: [get-release]
    steps:
      - uses: actions/checkout@v3
-      - uses: actions/setup-go@v4
+      - uses: actions/setup-go@v5
        with:
          go-version: ${{ env.GO_VERSION }}
-      - uses: subosito/flutter-action@v2
-        with:
-          flutter-version: ${{ env.FLUTTER_VERSION }}
+      - name: Install Snap host build dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y --no-install-recommends pkg-config libgtk-3-dev libwebkit2gtk-4.1-dev
      - name: Setup LXD
        uses: canonical/[email protected]
        with:
          channel: latest/stable
      - name: Build
        env:
-          VERSION: ${{ needs.get-release.outputs.tag_name }}
+          VERSION: ${{ needs.get-release.outputs.version }}
        run: |
-          go build -tags nosqlite -ldflags="-w -s" -buildmode=c-shared -o ui/flutter/linux/bundle/lib/libgopeed.so github.com/GopeedLab/gopeed/bind/desktop
+          go build -tags nosqlite -ldflags="-w -s -X github.com/GopeedLab/gopeed/pkg/base.Version=$VERSION" -buildmode=c-shared -o ui/flutter/linux/bundle/lib/libgopeed.so github.com/GopeedLab/gopeed/bind/desktop
+          go build -ldflags="-w -s" -o ui/flutter/assets/exec/host github.com/GopeedLab/gopeed/cmd/host
+          go build -ldflags="-w -s" -o ui/flutter/assets/exec/updater github.com/GopeedLab/gopeed/cmd/updater
          cd ui/flutter
-          
+
          sudo snap install snapcraft --classic
          mkdir -p snap/gui
          cp assets/icon/icon.svg snap/gui/gopeed.svg
-          
+
          cat>snap/snapcraft.yaml<<EOF
          name: gopeed
-          version: ${VERSION:1}
+          version: $VERSION
          summary: A modern download manager
          description: High speed downloader that supports all platforms.
-          
+
          confinement: strict
-          base: core22
+          base: core24
          grade: stable
-          
-          architectures:
-            - build-on: amd64
+
+          platforms:
+            amd64:
+              build-on: amd64
              build-for: amd64
-          
+
          slots:
            dbus-gopeed:
              interface: dbus
              bus: session
              name: com.gopeed.gopeed
-          
+
          apps:
            gopeed:
-              command: gopeed
+              command-chain:
+                - bin/gpu-2404-wrapper
+              command: bin/gopeed
              extensions: [gnome]
+              common-id: com.gopeed.Gopeed
              plugs:
                - network
-              slots:
-                - dbus-gopeed
+                - home
          parts:
-            gopeed:
-              source: .
-              plugin: flutter
-              stage-packages:
+            flutter-git:
+              source: https://github.com/flutter/flutter.git
+              source-tag: $FLUTTER_VERSION
+              source-depth: 1
+              plugin: nil
+              override-build: |
+                mkdir -p \$CRAFT_PART_INSTALL/usr/bin
+                mkdir -p \$CRAFT_PART_INSTALL/usr/libexec
+                cp -r \$CRAFT_PART_SRC \$CRAFT_PART_INSTALL/usr/libexec/flutter
+                ln -s \$CRAFT_PART_INSTALL/usr/libexec/flutter/bin/flutter \$CRAFT_PART_INSTALL/usr/bin/flutter
+                ln -s \$SNAPCRAFT_PART_INSTALL/usr/libexec/flutter/bin/dart \$SNAPCRAFT_PART_INSTALL/usr/bin/dart
+                \$CRAFT_PART_INSTALL/usr/bin/flutter doctor
+              build-packages:
+                - clang
+                - llvm-18
+                - lld
+                - cmake
+                - curl
                - libgtk-3-dev
+                - libwebkit2gtk-4.1-dev
+                - libkeybinder-3.0-dev
+                - ninja-build
+                - unzip
+                - xz-utils
+                - zip
+              override-prime: ''
+            zenity:
+              plugin: nil
+              stage-packages:
+                - zenity
+            gopeed:
+              after: [flutter-git,zenity]
+              source: .
+              plugin: nil
+              stage-packages:
+                - libwebkit2gtk-4.1-0
+                - libgtk-3-dev
+                - libkeybinder-3.0-dev
                - libappindicator3-dev
-              flutter-target: lib/main.dart
+              override-build: |
+                # work around pub get stack overflow # https://github.com/dart-lang/sdk/issues/51068#issuecomment-1396588253
+                set +e
+                dart pub get
+                set -eux
+                llvm_bin_dir="\$(dirname "\$(readlink -f "\$(command -v clang)")")"
+                test -x "\$llvm_bin_dir/llvm-ar"
+                test -x "\$llvm_bin_dir/ld.lld"
+                flutter build linux --dart-define="UPDATE_CHANNEL=linuxSnap" --dart-define="GA4_MEASUREMENT_ID=$GA4_MEASUREMENT_ID" --dart-define="GA4_API_SECRET=$GA4_API_SECRET"
+                mkdir -p \$CRAFT_PART_INSTALL/bin/
+                cp -r build/linux/*/release/bundle/* \$CRAFT_PART_INSTALL/bin/
+            gpu-2404:
+              after: [gopeed]
+              source: https://github.com/canonical/gpu-snap.git
+              plugin: dump
+              override-prime: |
+                craftctl default
+                \${CRAFT_PART_SRC}/bin/gpu-2404-cleanup mesa-2404
+              prime:
+                - bin/gpu-2404-wrapper
+
+          plugs:
+            gpu-2404:
+              interface: content
+              target: \$SNAP/gpu-2404
+              default-provider: mesa-2404
+
+          layout:
+            /usr/share/libdrm:
+              bind: \$SNAP/gpu-2404/libdrm
+            /usr/share/drirc.d:
+              symlink: \$SNAP/gpu-2404/drirc.d
+            /usr/share/X11/XErrorDB:
+              symlink: \$SNAP/gpu-2404/X11/XErrorDB
          EOF
-          
+
          cp linux/assets/com.gopeed.Gopeed.desktop snap/gui/gopeed.desktop
          sed -i 's/Icon=com.gopeed.Gopeed/Icon=\${SNAP}\/meta\/gui\/gopeed.svg/g' snap/gui/gopeed.desktop
-          
+
          snapcraft --use-lxd

          # Snapcraft login
          export SNAPCRAFT_STORE_CREDENTIALS=${{ secrets.SNAP_STORE_LOGIN }}
-          snapcraft upload --release=${{ github.event.inputs.channel }} gopeed_${VERSION:1}_amd64.snap
+          snapcraft upload --release=${{ github.event.inputs.test == 'true' && 'edge' || 'stable' }} gopeed_${VERSION}_amd64.snap
  build-android:
    if: ${{ github.event.inputs.platform == 'all' || github.event.inputs.platform == 'android' }}
    runs-on: ubuntu-latest
-    needs: [ get-release ]
+    needs: [get-release]
    steps:
      - uses: actions/checkout@v3
-      - uses: actions/setup-go@v4
+      - uses: actions/setup-go@v5
        with:
          go-version: ${{ env.GO_VERSION }}
      - uses: actions/setup-java@v3
        with:
          distribution: "zulu"
-          java-version: "11"
+          java-version: "17"
      - uses: subosito/flutter-action@v2
        with:
          flutter-version: ${{ env.FLUTTER_VERSION }}
      - name: Build
        env:
-          VERSION: ${{ needs.get-release.outputs.tag_name }}
+          VERSION: ${{ needs.get-release.outputs.version }}
          APK_KEYSTORE: ${{ secrets.APK_KEYSTORE }}
          APK_KEY_PASSWORD: ${{ secrets.APK_KEY_PASSWORD }}
          APK_STORE_PASSWORD: ${{ secrets.APK_STORE_PASSWORD }}
@@ -443,12 +576,16 @@ jobs:
          go install golang.org/x/mobile/cmd/gomobile@latest
          go get golang.org/x/mobile/bind
          gomobile init
-          gomobile bind -tags nosqlite -ldflags="-w -s" -o ui/flutter/android/app/libs/libgopeed.aar -target=android -androidapi 19 -javapkg=com.gopeed github.com/GopeedLab/gopeed/bind/mobile
+          gomobile bind -tags nosqlite -ldflags="-w -s -checklinkname=0 -X github.com/GopeedLab/gopeed/pkg/base.Version=$VERSION" -o ui/flutter/android/app/libs/libgopeed.aar -target=android -androidapi 21 -javapkg=com.gopeed github.com/GopeedLab/gopeed/bind/mobile
          cd ui/flutter
          echo $APK_KEYSTORE | base64 -di > android/app/upload-keystore.jks
-          flutter build apk
+          flutter build apk --dart-define="UPDATE_CHANNEL=androidApk" --dart-define="GA4_MEASUREMENT_ID=${{ env.GA4_MEASUREMENT_ID }}" --dart-define="GA4_API_SECRET=${{ env.GA4_API_SECRET }}"
+          flutter build apk --split-per-abi --dart-define="UPDATE_CHANNEL=androidApk" --dart-define="GA4_MEASUREMENT_ID=${{ env.GA4_MEASUREMENT_ID }}" --dart-define="GA4_API_SECRET=${{ env.GA4_API_SECRET }}"
          mkdir dist
-          cp build/app/outputs/flutter-apk/app-release.apk dist/Gopeed-$VERSION-android.apk
+          cp build/app/outputs/flutter-apk/app-release.apk dist/Gopeed-v$VERSION-android.apk
+          cp build/app/outputs/flutter-apk/app-armeabi-v7a-release.apk dist/Gopeed-v$VERSION-android-armeabi-v7a.apk
+          cp build/app/outputs/flutter-apk/app-arm64-v8a-release.apk dist/Gopeed-v$VERSION-android-arm64-v8a.apk
+          cp build/app/outputs/flutter-apk/app-x86_64-release.apk dist/Gopeed-v$VERSION-android-x86_64.apk
      - name: Upload
        uses: shogo82148/actions-upload-release-asset@v1
        with:
@@ -457,11 +594,11 @@ jobs:
          overwrite: true
  build-ios:
    if: ${{ github.event.inputs.platform == 'all' || github.event.inputs.platform == 'ios' }}
-    runs-on: macos-latest
-    needs: [ get-release ]
+    runs-on: macos-26
+    needs: [get-release]
    steps:
      - uses: actions/checkout@v3
-      - uses: actions/setup-go@v4
+      - uses: actions/setup-go@v5
        with:
          go-version: ${{ env.GO_VERSION }}
      - uses: subosito/flutter-action@v2
@@ -469,19 +606,19 @@ jobs:
          flutter-version: ${{ env.FLUTTER_VERSION }}
      - name: Build
        env:
-          VERSION: ${{ needs.get-release.outputs.tag_name }}
+          VERSION: ${{ needs.get-release.outputs.version }}
        run: |
          go install golang.org/x/mobile/cmd/gomobile@latest
          go get golang.org/x/mobile/bind
          gomobile init
-          gomobile bind -tags nosqlite -ldflags="-w -s" -o ui/flutter/ios/Frameworks/Libgopeed.xcframework -target=ios github.com/GopeedLab/gopeed/bind/mobile
+          gomobile bind -tags nosqlite -ldflags="-w -s -X github.com/GopeedLab/gopeed/pkg/base.Version=$VERSION" -o ui/flutter/ios/Frameworks/Libgopeed.xcframework -target=ios github.com/GopeedLab/gopeed/bind/mobile
          cd ui/flutter
-          flutter build ios --no-codesign
+          flutter build ios --no-codesign --dart-define="UPDATE_CHANNEL=iosIpa" --dart-define="GA4_MEASUREMENT_ID=${{ env.GA4_MEASUREMENT_ID }}" --dart-define="GA4_API_SECRET=${{ env.GA4_API_SECRET }}"
          mkdir Payload
          cp -r build/ios/iphoneos/Runner.app Payload
          zip -r -y Payload.zip Payload/Runner.app
          mkdir dist
-          mv Payload.zip dist/Gopeed-$VERSION-ios.ipa
+          mv Payload.zip dist/Gopeed-v$VERSION-ios.ipa
      - name: Upload
        uses: shogo82148/actions-upload-release-asset@v1
        with:
@@ -489,12 +626,12 @@ jobs:
          asset_path: ui/flutter/dist/*
          overwrite: true
  build-web:
-    if: ${{ github.event.inputs.platform == 'all' || github.event.inputs.platform == 'web' }}
+    if: ${{ github.event.inputs.platform == 'all' || github.event.inputs.platform == 'web' || github.event.inputs.platform == 'qnap' }}
    runs-on: ubuntu-latest
-    needs: [ get-release ]
+    needs: [get-release]
    steps:
      - uses: actions/checkout@v3
-      - uses: actions/setup-go@v4
+      - uses: actions/setup-go@v5
        with:
          go-version: ${{ env.GO_VERSION }}
      - uses: subosito/flutter-action@v2
@@ -502,13 +639,15 @@ jobs:
          flutter-version: ${{ env.FLUTTER_VERSION }}
      - name: Build
        env:
-          VERSION: ${{ needs.get-release.outputs.tag_name }}
+          VERSION: ${{ needs.get-release.outputs.version }}
        run: |
          cd ui/flutter
-          flutter build web --web-renderer html
+          flutter build web --no-web-resources-cdn --dart-define="GA4_MEASUREMENT_ID=${{ env.GA4_MEASUREMENT_ID }}" --dart-define="GA4_API_SECRET=${{ env.GA4_API_SECRET }}"
+          dart ../../.github/workflows/scripts/flutter_local_font.dart
          cd ../../
          cp -r ui/flutter/build/web cmd/web/dist
          mkdir -p dist/zip
+
          goos_arr=(windows darwin linux)
          goarch_arr=(386 amd64 arm64)
          export CGO_ENABLED=0
@@ -518,9 +657,9 @@ jobs:
              if [ $goos = "darwin" ]; then
                goos_name="macos"
              fi
-              name=gopeed-web-$VERSION-$goos_name-$goarch
+              name=gopeed-web-v$VERSION-$goos_name-$goarch
              dir="dist/$name/"
-              (GOOS=$goos GOARCH=$goarch go build -tags nosqlite,web -ldflags="-s -w" -o $dir github.com/GopeedLab/gopeed/cmd/web \
+              (GOOS=$goos GOARCH=$goarch go build -tags nosqlite,web -ldflags="-s -w -X github.com/GopeedLab/gopeed/pkg/base.Version=$VERSION" -o $dir github.com/GopeedLab/gopeed/cmd/web \
              && cd $dir \
              && file=$(ls -AU | head -1) \
              && mkdir $name \
@@ -530,21 +669,86 @@ jobs:
              || true
            done
          done
+      - uses: actions/upload-artifact@v4
+        with:
+          name: web-dist
+          path: dist/zip/
      - name: Upload
        uses: shogo82148/actions-upload-release-asset@v1
        with:
          upload_url: ${{ needs.get-release.outputs.upload_url }}
          asset_path: dist/zip/*
          overwrite: true
+  build-qnap:
+    if: ${{ github.event.inputs.platform == 'all' || github.event.inputs.platform == 'qnap' }}
+    runs-on: ubuntu-latest
+    needs: [get-release, build-web]
+    steps:
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.8.18"
+      - uses: actions/download-artifact@v4
+        with:
+          name: web-dist
+          path: dist/zip/
+      - name: Build
+        env:
+          VERSION: ${{ needs.get-release.outputs.version }}
+        run: |
+          sudo apt update -y
+          qdk_version=2.5.3
+          qdk_package="qdk_${qdk_version}_amd64.deb"
+          curl --fail --location --retry 3 --retry-all-errors \
+            --output "${qdk_package}" \
+            "https://github.com/qnap-dev/QDK/releases/download/v${qdk_version}/${qdk_package}"
+          echo "17b3841b7d4590a4ee025844ba583304b5e3c497d9fa8934d5175131d3908022  ${qdk_package}" | sha256sum --check --strict
+          sudo apt-get install -y "./${qdk_package}"
+          command -v qbuild
+
+          wget -O Gopeed.template.tar.gz "https://github.com/GopeedLab/QpkgBuild/raw/refs/heads/master/template/Gopeed.template.tar.gz"
+          tar -zxf Gopeed.template.tar.gz
+          [[ -d Gopeed ]] || exit 1
+
+          goos=linux
+          goarch_arr=(amd64 arm64)
+          for goarch in "${goarch_arr[@]}"; do
+            qarch=x86_64
+            [[ "${goarch}" == "arm64" ]] && qarch=arm_64
+            name=gopeed-web-v${VERSION}-${goos}-${goarch}
+            unzip dist/zip/${name}.zip -d dist/${name}
+            cp dist/${name}/${name}/* Gopeed/${qarch}/
+          done
+          cd Gopeed
+          sed -i -e 's/__QPKG_VER__/${VERSION}/g' qpkg.cfg
+          qbuild || exit 1
+
+          mkdir -p ../dist/qnap
+          goos=qnap
+          for goarch in "${goarch_arr[@]}"; do
+            qarch=x86_64
+            [[ "${goarch}" == "arm64" ]] && qarch=arm_64
+            sname=Gopeed_${VERSION}_${qarch}.qpkg
+            dname=gopeed-v${VERSION}-${goos}-${goarch}.qpkg
+            [[ -f build/${sname} ]] && cp -ra build/${sname} ../dist/qnap/${dname}
+          done
+      - name: Upload
+        uses: shogo82148/actions-upload-release-asset@v1
+        with:
+          upload_url: ${{ needs.get-release.outputs.upload_url }}
+          asset_path: dist/qnap/*
+          overwrite: true
  build-docker:
    if: ${{ github.event.inputs.platform == 'all' || github.event.inputs.platform == 'docker' }}
    runs-on: ubuntu-latest
-    needs: [ get-release ]
+    needs: [get-release]
    steps:
      - name: Remove unnecessary files
        run: |
          sudo rm -rf /usr/share/dotnet
          sudo rm -rf "$AGENT_TOOLSDIRECTORY"
+      - uses: subosito/flutter-action@v2
+        with:
+          flutter-version: ${{ env.FLUTTER_VERSION }}
      - uses: actions/checkout@v3
      - name: Set up QEMU
        uses: docker/setup-qemu-action@v2
@@ -555,18 +759,29 @@ jobs:
        with:
          username: liwei2633
          password: ${{ secrets.DOCKER_PASSWORD }}
+      - name: Build flutter web
+        run: |
+          cd ui/flutter
+          flutter build web --no-web-resources-cdn --dart-define="UPDATE_CHANNEL=docker" --dart-define="GA4_MEASUREMENT_ID=${{ env.GA4_MEASUREMENT_ID }}" --dart-define="GA4_API_SECRET=${{ env.GA4_API_SECRET }}"
+          dart ../../.github/workflows/scripts/flutter_local_font.dart
+          cd ../../
+          rm -rf cmd/web/dist
+          cp -r ui/flutter/build/web cmd/web/dist
      - name: Build and push
        uses: docker/build-push-action@v2
        env:
-          VERSION: ${{ needs.get-release.outputs.tag_name }}
+          VERSION: ${{ needs.get-release.outputs.version }}
        with:
-          push: true
+          context: .
+          push: ${{ github.event.inputs.test == 'true' && 'false' || 'true' }}
+          build-args: |
+            VERSION=${{ env.VERSION }}
+            IN_DOCKER=true
          platforms: |
            linux/386
            linux/amd64
            linux/arm64
-            linux/arm/v6
            linux/arm/v7
          tags: |
            liwei2633/gopeed:latest
-            liwei2633/gopeed:${{ env.VERSION }}
+            liwei2633/gopeed:v${{ env.VERSION }}
@@ -0,0 +1,50 @@
+name: l10n
+
+on:
+  pull_request:
+    branches:
+      - main
+    paths:
+      - "ui/flutter/lib/l10n/**"
+      - "ui/flutter/l10n.yaml"
+      - ".github/workflows/scripts/check_l10n.dart"
+      - ".github/workflows/l10n.yml"
+  push:
+    branches:
+      - main
+    paths:
+      - "ui/flutter/lib/l10n/**"
+      - "ui/flutter/l10n.yaml"
+      - ".github/workflows/scripts/check_l10n.dart"
+      - ".github/workflows/l10n.yml"
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: l10n-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
+env:
+  FLUTTER_VERSION: "3.41.6"
+
+jobs:
+  validate:
+    name: Validate Flutter translations
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ui/flutter
+    steps:
+      - uses: actions/checkout@v4
+      - uses: subosito/flutter-action@v2
+        with:
+          flutter-version: ${{ env.FLUTTER_VERSION }}
+      - run: flutter pub get
+      - name: Validate ARB catalogs
+        run: dart run ../../.github/workflows/scripts/check_l10n.dart
+      - name: Generate localizations
+        run: flutter gen-l10n
+      - name: Analyze generated localization integration
+        run: flutter analyze
@@ -17,7 +17,7 @@ on:
      - "Dockerfile"

 env:
-  GO_VERSION: "1.19"
+  GO_VERSION: "1.25.4"

 permissions:
  contents: write
@@ -31,7 +31,7 @@ jobs:

    steps:
      - uses: actions/checkout@v3
-      - uses: actions/setup-go@v4
+      - uses: actions/setup-go@v5
        with:
          go-version: ${{ env.GO_VERSION }}
      - uses: release-drafter/release-drafter@v5
@@ -0,0 +1,107 @@
+// Validate Flutter ARB translation catalogs before localization code generation.
+//
+// Usage (from ui/flutter):
+//   dart run ../../.github/workflows/scripts/check_l10n.dart
+//
+// What it checks:
+// - Every ARB file uses the repository's canonical two-space JSON formatting.
+// - Every app_<locale>.arb file declares the matching @@locale value.
+// - Message values are not empty (warning only).
+// - Every locale has the same message keys as app_en.arb (warning only).
+// - Every translation preserves the placeholder variables used by app_en.arb
+//   (warning only).
+//
+// Notes:
+// - This script does not judge translation quality.
+// - It does not generate localization code or fully parse ICU MessageFormat.
+//   `flutter gen-l10n` runs immediately afterwards in CI to validate ICU syntax
+//   and generate app_localizations*.dart.
+// - The script exits with a failure only for malformed JSON, invalid ARB
+//   formatting, or a mismatched @@locale value. Translation completeness is
+//   reported as warnings; generation and analysis remain the compile-time gate.
+
+import 'dart:convert';
+import 'dart:io';
+
+/// Runs repository-specific checks that `flutter gen-l10n` does not enforce.
+void main() {
+  final directory = Directory('lib/l10n');
+  final templateFile = File('${directory.path}/app_en.arb');
+  final template = _readArb(templateFile);
+  final templateKeys = _messageKeys(template);
+  var failed = false;
+
+  for (final file in directory.listSync().whereType<File>().where(
+    (file) => file.path.endsWith('.arb'),
+  )) {
+    final messages = _readArb(file);
+    if (!_hasCanonicalFormat(file, messages)) {
+      stderr.writeln(
+        '${file.path}: ARB formatting is not canonical (use two-space JSON indentation and a trailing newline)',
+      );
+      failed = true;
+    }
+    final expectedLocale = file.uri.pathSegments.last
+        .replaceFirst('app_', '')
+        .replaceFirst('.arb', '');
+    if (messages['@@locale'] != expectedLocale) {
+      stderr.writeln('${file.path}: @@locale must be $expectedLocale');
+      failed = true;
+    }
+    final keys = _messageKeys(messages);
+    final empty =
+        keys.where((key) => (messages[key] as String).trim().isEmpty).toList()
+          ..sort();
+    if (empty.isNotEmpty) {
+      _warning('${file.path}: empty messages $empty');
+    }
+    if (file.path == templateFile.path) continue;
+    final missing = templateKeys.difference(keys);
+    final extra = keys.difference(templateKeys);
+    if (missing.isNotEmpty || extra.isNotEmpty) {
+      _warning(
+        '${file.path}: missing ${missing.toList()..sort()}, extra ${extra.toList()..sort()}',
+      );
+    }
+
+    for (final key in templateKeys.intersection(keys)) {
+      final expected = _placeholders(template[key] as String);
+      final actual = _placeholders(messages[key] as String);
+      if (!_sameSet(expected, actual)) {
+        _warning(
+          '${file.path}: $key placeholders $actual do not match $expected',
+        );
+      }
+    }
+  }
+
+  if (failed) exitCode = 1;
+}
+
+/// Reads one ARB file as its top-level JSON object.
+Map<String, Object?> _readArb(File file) =>
+    jsonDecode(file.readAsStringSync()) as Map<String, Object?>;
+
+/// Checks the exact JSON layout so whitespace-only formatting drift fails CI.
+bool _hasCanonicalFormat(File file, Map<String, Object?> arb) {
+  const encoder = JsonEncoder.withIndent('  ');
+  return file.readAsStringSync() == '${encoder.convert(arb)}\n';
+}
+
+/// Returns user-facing message keys and excludes ARB metadata keys (`@`/`@@`).
+Set<String> _messageKeys(Map<String, Object?> arb) =>
+    arb.keys.where((key) => !key.startsWith('@')).toSet();
+
+/// Extracts both simple placeholders (`{name}`) and ICU selector variables.
+///
+/// For example, this returns `count` from
+/// `{count, plural, =1{1 file} other{{count} files}}`.
+Set<String> _placeholders(String message) => RegExp(
+  r'\{([A-Za-z_][A-Za-z0-9_]*)(?=\s*(?:\}|,\s*(?:plural|select|selectordinal)\s*,))',
+).allMatches(message).map((match) => match.group(1)!).toSet();
+
+/// Compares sets without depending on iteration order.
+bool _sameSet(Set<String> left, Set<String> right) =>
+    left.length == right.length && left.containsAll(right);
+
+void _warning(String message) => stderr.writeln('warning: $message');
@@ -0,0 +1,413 @@
+// Localize external Google Fonts (fonts.gstatic.com) references in Flutter Web build output.
+//
+// Usage (post-build):
+//   # Run AFTER: flutter build web --no-web-resources-cdn
+//   dart ../../.github/workflows/scripts/flutter_local_font.dart
+//
+// What it does:
+// In main.dart.js:
+//    - Find any referenced resources under: https://fonts.gstatic.com/s/
+//      (including the common pattern where Flutter concatenates the base URL with a relative path)
+//    - Download them into: build/web/assets/gstatic/<path>
+//    - Rewrite "https://fonts.gstatic.com/s/" -> "assets/gstatic/" so runtime loads locally
+//    - Only download font subsets needed by supported locales (parsed from lib/l10n/*.arb)
+//
+// Notes:
+// - This script DOES NOT call `flutter build web`. It only patches the output.
+// - This is a best-effort post-process. Always verify in browser devtools.
+
+import 'dart:async';
+import 'dart:io';
+
+/// Get font families required for a specific locale based on language/script.
+/// Uses language code prefix to automatically detect the script system.
+/// Returns empty set if base fonts (Latin/Cyrillic/Greek) are sufficient.
+Set<String> _getFontFamiliesForLocale(String locale) {
+  final normalizedLocale = locale.toLowerCase().replaceAll('-', '_');
+  final lang = normalizedLocale.split('_').first;
+
+  // CJK languages - need specific large font files
+  if (lang == 'zh') {
+    // Simplified vs Traditional Chinese
+    if (normalizedLocale.contains('_tw') ||
+        normalizedLocale.contains('_hk') ||
+        normalizedLocale.contains('_mo')) {
+      return {'notosanstc', 'notosanshk'}; // Traditional Chinese (TW, HK, MO)
+    }
+    return {'notosanssc'}; // Simplified Chinese, including generic zh
+  }
+  if (lang == 'ja') return {'notosansjp'}; // Japanese
+  if (lang == 'ko') return {'notosanskr'}; // Korean
+
+  // Arabic script languages
+  if (lang == 'ar') return {'notosansarabic'}; // Arabic
+  if (lang == 'fa') return {'notosansarabic'}; // Persian/Farsi
+  if (lang == 'ur') return {'notosansarabic'}; // Urdu
+  if (lang == 'ps') return {'notosansarabic'}; // Pashto
+  if (lang == 'ku') return {'notosansarabic'}; // Kurdish (Arabic script)
+
+  // Hebrew script
+  if (lang == 'he' || lang == 'yi') return {'notosanshebrew'};
+
+  // South Asian scripts
+  if (lang == 'hi' || lang == 'mr' || lang == 'ne' || lang == 'sa') {
+    return {'notosansdevanagari'}; // Hindi, Marathi, Nepali, Sanskrit
+  }
+  if (lang == 'bn' || lang == 'as')
+    return {'notosansbengali'}; // Bengali, Assamese
+  if (lang == 'ta')
+    return {'notosanstamil', 'notosanstamilsupplement'}; // Tamil
+  if (lang == 'te') return {'notosanstelugu'}; // Telugu
+  if (lang == 'kn') return {'notosanskannada'}; // Kannada
+  if (lang == 'ml') return {'notosansmalayalam'}; // Malayalam
+  if (lang == 'gu') return {'notosansgujarati'}; // Gujarati
+  if (lang == 'pa') return {'notosansgurmukhi'}; // Punjabi (Gurmukhi)
+  if (lang == 'or') return {'notosansoriya'}; // Odia/Oriya
+  if (lang == 'si') return {'notosanssinhala'}; // Sinhala
+
+  // Southeast Asian scripts
+  if (lang == 'th') return {'notosansthai'}; // Thai
+  if (lang == 'lo') return {'notosanslao'}; // Lao
+  if (lang == 'my') return {'notosansmyanmar'}; // Myanmar/Burmese
+  if (lang == 'km') return {'notosanskhmer'}; // Khmer/Cambodian
+  if (lang == 'jv') return {'notosansjavanese'}; // Javanese
+
+  // Other scripts
+  if (lang == 'ka') return {'notosansgeorgian'}; // Georgian
+  if (lang == 'hy') return {'notosansarmenian'}; // Armenian
+  if (lang == 'am' || lang == 'ti')
+    return {'notosansethiopic'}; // Amharic, Tigrinya
+  if (lang == 'mn') return {'notosansmongolian'}; // Mongolian
+
+  // Latin/Cyrillic/Greek based languages - base notosans is sufficient
+  // Includes: English, German, French, Spanish, Italian, Portuguese,
+  // Russian, Ukrainian, Polish, Turkish, Vietnamese, Greek, etc.
+  return {};
+}
+
+/// Base font families that are always included regardless of locale.
+/// These provide core functionality and are relatively small.
+const _baseFontFamilies = <String>{
+  'notosans', // Base Latin/Cyrillic/Greek/Vietnamese
+  'roboto', // Material Design default font
+  'notosanssymbols', // Common symbols
+  'notosanssymbols2', // Additional symbols
+  'notosansmath', // Math symbols
+  'notomusic', // Music notation symbols
+  // Note: notocoloremoji (~24MB) and notoemoji (~860KB) are excluded
+  // to reduce bundle size. Add them back if emoji support is needed.
+};
+
+/// Parse supported locales from Flutter gen-l10n ARB filenames.
+/// Filenames follow app_<locale>.arb, for example app_zh_CN.arb or app_en.arb.
+Set<String> _parseSupportedLocales(Directory l10nDirectory) {
+  final locales = <String>{};
+
+  if (!l10nDirectory.existsSync()) {
+    _fail('Localization directory not found: ${l10nDirectory.path}');
+  }
+
+  final arbName = RegExp(r'^app_(.+)\.arb$');
+  for (final entity in l10nDirectory.listSync()) {
+    if (entity is! File) continue;
+    final filename = entity.uri.pathSegments.last;
+    final locale = arbName.firstMatch(filename)?.group(1);
+    if (locale != null && locale.isNotEmpty) locales.add(locale);
+  }
+
+  if (locales.isEmpty) {
+    _fail('No app_<locale>.arb files found in ${l10nDirectory.path}');
+  }
+
+  return locales;
+}
+
+/// Get required font families for the given locales.
+/// Returns a set of font family names that should be included.
+/// Automatically detects required fonts based on language code prefix.
+Set<String> _getRequiredFontFamilies(Set<String> locales) {
+  final families = <String>{..._baseFontFamilies};
+  for (final locale in locales) {
+    final localeFamilies = _getFontFamiliesForLocale(locale);
+    families.addAll(localeFamilies);
+  }
+  return families;
+}
+
+/// Check if a font file path should be included based on required font families.
+/// Font paths have the format: "fontfamily/version/filename.ext"
+/// Example: "notosanssc/v36/xxx.ttf" -> font family is "notosanssc"
+bool _fontMatchesRequiredFamilies(
+  String fontPath,
+  Set<String> requiredFamilies,
+) {
+  // Extract font family from path (first segment before '/')
+  final slashIndex = fontPath.indexOf('/');
+  if (slashIndex == -1) {
+    // No slash found, include by default (unusual path format)
+    return true;
+  }
+
+  final fontFamily = fontPath.substring(0, slashIndex).toLowerCase();
+  return requiredFamilies.contains(fontFamily);
+}
+
+Future<void> main(List<String> args) async {
+  try {
+    // This script is intentionally argument-free for CI convenience.
+    // It assumes it is executed from the Flutter project directory (ui/flutter),
+    // but will also try to locate pubspec.yaml by walking up.
+    final flutterDir = _findFlutterProjectRoot(Directory.current);
+
+    // Parse supported locales from Flutter gen-l10n ARB files.
+    final l10nDirectory = Directory(_join(flutterDir.path, 'lib', 'l10n'));
+    final supportedLocales = _parseSupportedLocales(l10nDirectory);
+    stdout.writeln('Supported locales: ${supportedLocales.join(', ')}');
+
+    // Get required font families based on supported locales
+    final requiredFamilies = _getRequiredFontFamilies(supportedLocales);
+    stdout.writeln('Required font families: ${requiredFamilies.join(', ')}');
+
+    final webDir = Directory(_join(flutterDir.path, 'build', 'web'));
+    if (!webDir.existsSync()) {
+      _fail(
+        'Web build directory not found: ${webDir.path}\n'
+        'Did you run: flutter build web --no-web-resources-cdn ?',
+      );
+    }
+
+    final mainJs = File(_join(webDir.path, 'main.dart.js'));
+    if (!mainJs.existsSync()) {
+      _fail('main.dart.js not found at: ${mainJs.path}');
+    }
+
+    final gstaticRoot = Directory(_join(webDir.path, 'assets', 'gstatic'));
+    if (!gstaticRoot.existsSync()) gstaticRoot.createSync(recursive: true);
+
+    const gstaticSPrefix = 'https://fonts.gstatic.com/s/';
+    final original = mainJs.readAsStringSync();
+
+    // Relative font asset paths which Flutter's loader typically concatenates with:
+    //   https://fonts.gstatic.com/s/
+    // Keep this as a best-effort heuristic to cover the common concatenation pattern.
+    // Some gstatic assets include extra dot segments like: notocoloremoji/v32/Yq6P-KqIXTD0t4D9z1ESnKM3-HpFabsE4tq3luCC7p-aXxcn.0.woff2
+    // Allow dots in the path, while still restricting to font-like extensions.
+    final relAssetRegex = RegExp(
+      r"""["']([a-zA-Z0-9/_\.-]+\.(?:woff2|woff|ttf|otf|eot|svg))["']""",
+      caseSensitive: false,
+    );
+    final relAssetsUnderS = <String>{};
+    for (final m in relAssetRegex.allMatches(original)) {
+      final p = m.group(1);
+      if (p == null || p.isEmpty) continue;
+      if (p.contains('://') || p.startsWith('data:')) continue;
+      if (p.startsWith('/') ||
+          p.startsWith('assets/') ||
+          p.startsWith('packages/'))
+        continue;
+      if (p.contains('..')) continue;
+      relAssetsUnderS.add(p);
+    }
+
+    if (relAssetsUnderS.isEmpty) {
+      _fail('No fonts.gstatic.com assets found in main.dart.js.');
+    }
+
+    // Build a download plan: dest relative path (under assets/gstatic/) -> URL.
+    // Filter fonts based on required font families to reduce package size.
+    final downloads = <String, Uri>{};
+    final skippedFonts = <String, Set<String>>{};
+
+    for (final rel in relAssetsUnderS) {
+      if (_fontMatchesRequiredFamilies(rel, requiredFamilies)) {
+        downloads[rel] = Uri.parse('$gstaticSPrefix$rel');
+      } else {
+        // Track skipped fonts and their paths for fallback generation
+        final slashIndex = rel.indexOf('/');
+        final family = slashIndex > 0 ? rel.substring(0, slashIndex) : rel;
+        skippedFonts.putIfAbsent(family, () => <String>{}).add(rel);
+      }
+    }
+
+    if (skippedFonts.isNotEmpty) {
+      stdout.writeln(
+        'Skipped ${skippedFonts.length} font families not required by supported locales:',
+      );
+      stdout.writeln('  ${skippedFonts.keys.join(', ')}');
+    }
+
+    if (downloads.isNotEmpty) {
+      stdout.writeln(
+        'Found ${downloads.length} fonts.gstatic.com assets to download...',
+      );
+
+      // Reuse a single HttpClient to avoid creating hundreds of short-lived
+      // connections (can be flaky on some environments).
+      final httpClient = HttpClient()
+        ..connectionTimeout = const Duration(seconds: 30)
+        ..idleTimeout = const Duration(seconds: 30)
+        ..maxConnectionsPerHost = 6;
+      try {
+        for (final entry in downloads.entries) {
+          final relPath = entry.key;
+          final url = entry.value;
+          final destPath = relPath.replaceAll('/', Platform.pathSeparator);
+          final dest = File(_join(gstaticRoot.path, destPath));
+          await _downloadIfMissing(httpClient, url, dest);
+        }
+      } finally {
+        httpClient.close(force: true);
+      }
+    }
+
+    // Generate empty fallback font files for skipped fonts to prevent infinite loading
+    // Empty files will cause browsers to fail fast instead of retrying indefinitely
+    if (skippedFonts.isNotEmpty) {
+      var fallbackCount = 0;
+      for (final entry in skippedFonts.entries) {
+        for (final relPath in entry.value) {
+          final destPath = relPath.replaceAll('/', Platform.pathSeparator);
+          final dest = File(_join(gstaticRoot.path, destPath));
+          if (!dest.existsSync()) {
+            dest.parent.createSync(recursive: true);
+            // Create an empty file - browsers will recognize it as invalid and skip
+            dest.writeAsBytesSync([]);
+            fallbackCount++;
+          }
+        }
+      }
+      if (fallbackCount > 0) {
+        stdout.writeln(
+          'Generated $fallbackCount empty fallback font files to prevent infinite loading',
+        );
+      }
+    }
+
+    // Rewrite remote prefix so requests become:
+    //   <origin>/assets/gstatic/<...>.woff2
+    final replacedGstatic = original.replaceAll(
+      gstaticSPrefix,
+      'assets/gstatic/',
+    );
+
+    if (replacedGstatic == original && downloads.isEmpty) {
+      stdout.writeln(
+        'No changes applied (no fonts.gstatic.com references found).',
+      );
+      exitCode = 0;
+      return;
+    }
+
+    mainJs.writeAsStringSync(replacedGstatic);
+
+    stdout.writeln('Patched: ${mainJs.path}');
+    if (downloads.isNotEmpty) {
+      stdout.writeln(
+        ' - downloaded ${downloads.length} files into: ${gstaticRoot.path}',
+      );
+    }
+    stdout.writeln(' - fonts.gstatic.com rewritten -> assets/gstatic/');
+  } catch (e, st) {
+    stderr.writeln('ERROR: $e');
+    stderr.writeln(st);
+    exitCode = 1;
+  }
+}
+
+Future<void> _downloadIfMissing(HttpClient client, Uri url, File dest) async {
+  if (dest.existsSync() && dest.lengthSync() > 0) return;
+
+  dest.parent.createSync(recursive: true);
+
+  // Network can be flaky in CI. Retry a few times on transient errors.
+  const maxAttempts = 4;
+
+  for (var attempt = 1; attempt <= maxAttempts; attempt++) {
+    final tmp = File('${dest.path}.tmp');
+    try {
+      try {
+        final req = await client.getUrl(url);
+
+        final resp = await req.close().timeout(const Duration(seconds: 60));
+        if (resp.statusCode != 200) {
+          // 404 is not transient in practice - fail fast with a clear message.
+          if (resp.statusCode == 404) {
+            _fail('Missing gstatic asset (404): $url');
+          }
+          throw HttpException('HTTP ${resp.statusCode}', uri: url);
+        }
+
+        // Stream to temp file first, then rename to avoid leaving partial files.
+        if (tmp.existsSync()) tmp.deleteSync();
+        final sink = tmp.openWrite();
+        await resp.pipe(sink).timeout(const Duration(seconds: 120));
+
+        if (!tmp.existsSync() || tmp.lengthSync() == 0) {
+          throw const FormatException('Downloaded asset is empty');
+        }
+        if (dest.existsSync()) dest.deleteSync();
+        tmp.renameSync(dest.path);
+        return;
+      } finally {
+        // no-op: HttpClient lifecycle managed by the caller
+      }
+    } on TimeoutException {
+      if (tmp.existsSync()) tmp.deleteSync();
+      if (attempt == maxAttempts) {
+        _fail('Timeout downloading asset: $url');
+      }
+    } on SocketException catch (e) {
+      if (tmp.existsSync()) tmp.deleteSync();
+      if (attempt == maxAttempts) {
+        _fail('Socket error downloading asset: $url ($e)');
+      }
+    } on HttpException catch (e) {
+      if (tmp.existsSync()) tmp.deleteSync();
+      if (attempt == maxAttempts) {
+        _fail('HTTP error downloading asset: $url ($e)');
+      }
+    } on FileSystemException catch (e) {
+      if (tmp.existsSync()) tmp.deleteSync();
+      _fail('File write error downloading asset: $url ($e)');
+    } catch (e) {
+      if (tmp.existsSync()) tmp.deleteSync();
+      if (attempt == maxAttempts) {
+        _fail('Unexpected error downloading asset: $url ($e)');
+      }
+    }
+
+    // Backoff before retrying.
+    final backoffSeconds = 1 << (attempt - 1);
+    stdout.writeln(
+      'Retrying (${attempt + 1}/$maxAttempts) for: $url (wait ${backoffSeconds}s)',
+    );
+    await Future.delayed(Duration(seconds: backoffSeconds));
+  }
+}
+
+Directory _findFlutterProjectRoot(Directory start) {
+  var dir = start;
+  for (var i = 0; i < 10; i++) {
+    final pubspec = File(_join(dir.path, 'pubspec.yaml'));
+    if (pubspec.existsSync()) return dir;
+    final parent = dir.parent;
+    if (parent.path == dir.path) break;
+    dir = parent;
+  }
+  // Fallback: use current directory, error messages will explain what is missing.
+  return start;
+}
+
+Never _fail(String msg) {
+  throw FormatException(msg);
+}
+
+String _join(String a, [String? b, String? c, String? d]) {
+  final parts = <String>[
+    a,
+    if (b != null) b,
+    if (c != null) c,
+    if (d != null) d,
+  ];
+  return parts.join(Platform.pathSeparator);
+}
@@ -25,10 +25,11 @@ on:
      - ".github/workflows/test.yml"
      - "go.mod"
      - "go.sum"
+  workflow_dispatch:

 env:
-  GO_VERSION: "1.19"
-  FLUTTER_VERSION: "3.16.1"
+  GO_VERSION: "1.25.4"
+  FLUTTER_VERSION: "3.41.6"

 jobs:
  #  lint:
@@ -49,32 +50,237 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
-      - uses: actions/setup-go@v4
+      - uses: actions/setup-go@v5
        with:
          go-version: ${{ env.GO_VERSION }}
+      - name: Install webview dependencies
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y libgtk-3-dev libwebkit2gtk-4.1-dev xvfb
      - name: Run Unit tests.
-        run: go test $(go list ./... | grep -v /cmd/ | grep -v /bind/ ) -v -covermode=count -coverprofile=coverage.txt
-      - uses: codecov/codecov-action@v3
+        run: |
+          # Get packages for testing and coverage (including cmd/web for flags_test.go)
+          PACKAGES=$(go list ./... | awk '!/\/bind\// && (!/\/cmd\// || /\/cmd\/web$/)')
+          env CGO_ENABLED=1 xvfb-run -a go test -tags webview -v -coverpkg=$(echo "$PACKAGES" | paste -sd "," -) -covermode=count -coverprofile=coverage.txt $PACKAGES
+          # Filter out main.go from coverage report to avoid lowering coverage percentage
+          grep -v "main.go" coverage.txt > coverage_filtered.txt || true
+          mv coverage_filtered.txt coverage.txt
+      - uses: codecov/codecov-action@v4
        with:
          files: ./coverage.txt
-  build:
-    name: Build check
-    runs-on: ubuntu-latest
-    #    needs: [lint, test]
-    needs: [test]
+          token: ${{ secrets.CODECOV_UPLOAD_TOKEN }}
+  test-webview-integration:
+    name: Test webview integration (${{ matrix.name }})
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: Windows
+            os: windows-latest
+          - name: macOS
+            os: macos-latest
+    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v3
-      - uses: actions/setup-go@v4
+      - uses: actions/setup-go@v5
+        with:
+          go-version: ${{ env.GO_VERSION }}
+      - uses: subosito/flutter-action@v2
+        if: runner.os == 'macOS'
+        with:
+          flutter-version: ${{ env.FLUTTER_VERSION }}
+      - name: Test webview
+        if: runner.os == 'Windows'
+        run: go test -tags webview -v -count=1 -timeout 300s ./internal/webview/goprovider/
+        env:
+          CGO_ENABLED: 1
+      - name: Test webview
+        if: runner.os == 'macOS'
+        shell: bash
+        run: |
+          set -euo pipefail
+          SOCKET_PATH="$HOME/Library/Application Support/com.gopeed.gopeed/gopeed_webview.sock"
+          LOG_PATH="$RUNNER_TEMP/gopeed-webview-rpc.log"
+          rm -f "$SOCKET_PATH"
+
+          go build -tags nosqlite -ldflags="-w -s" -buildmode=c-shared -o ui/flutter/macos/Frameworks/libgopeed.dylib github.com/GopeedLab/gopeed/bind/desktop
+
+          cd ui/flutter
+          flutter pub get
+          flutter run --machine -d macos >"$LOG_PATH" 2>&1 &
+          FLUTTER_PID=$!
+          cd ../..
+
+          cleanup() {
+            kill "$FLUTTER_PID" >/dev/null 2>&1 || true
+          }
+          trap cleanup EXIT
+
+          FLUTTER_STARTED=false
+          for _ in $(seq 1 600); do
+            if grep -Eq '"event"[[:space:]]*:[[:space:]]*"app\.started"' "$LOG_PATH"; then
+              FLUTTER_STARTED=true
+              break
+            fi
+            if ! kill -0 "$FLUTTER_PID" >/dev/null 2>&1; then
+              echo "Flutter exited before reporting app.started"
+              cat "$LOG_PATH"
+              exit 1
+            fi
+            sleep 1
+          done
+          if [[ "$FLUTTER_STARTED" != true ]]; then
+            echo "Timed out waiting for Flutter to report app.started"
+            cat "$LOG_PATH"
+            exit 1
+          fi
+
+          if ! go test -tags webview -v -count=1 -timeout 600s ./internal/webview/rpcprovider/ -args -webview-rpc-network unix -webview-rpc-address "$SOCKET_PATH"; then
+            cat "$LOG_PATH"
+            exit 1
+          fi
+
+  build-desktop:
+    strategy:
+      matrix:
+        include:
+          - os: windows-2022
+          - os: windows-11-arm
+            llvm_ver: "20251202" # Only ARM64
+            flutter_channel: "main"
+            flutter_version: "7e1c8868"
+          - os: macos-latest
+          - os: ubuntu-22.04
+          - os: ubuntu-22.04-arm
+            flutter_channel: "main"
+    name: Build desktop check (${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    needs: [ test ]
+    steps:
+      - uses: actions/checkout@v3
+      - name: Enable long paths for flutter main branch checks
+        run: |
+          git config --global core.longpaths true
+      - name: Install llvm-mingw-ucrt-aarch64 (ARM64 only)
+        if: matrix.os == 'windows-11-arm'
+        run: |
+          $ver = "${{ matrix.llvm_ver }}"
+          $url = "https://github.com/mstorsjo/llvm-mingw/releases/download/$ver/llvm-mingw-$ver-ucrt-aarch64.zip"
+          $zip = "$env:RUNNER_TEMP\\llvm.zip"
+          $extract = "$env:RUNNER_TEMP\\extract"
+          $target = "C:\\clangarm64"
+
+          curl -L $url -o $zip
+          rm -r -fo $extract,$target -ea Ignore
+          mkdir $extract | Out-Null
+
+          tar -xf $zip -C $extract
+          mv (Get-ChildItem $extract)[0].FullName $target
+
+          $b = "$target\\bin"
+          "CC=$b\\clang.exe"        >> $env:GITHUB_ENV
+          "CXX=$b\\clang++.exe"     >> $env:GITHUB_ENV
+          "CLANGARM64_BIN=$b"       >> $env:GITHUB_ENV
+          "CGO_ENABLED=1"           >> $env:GITHUB_ENV
+          "CLANGARM64_ROOT=$target" >> $env:GITHUB_ENV
+          $b >> $env:GITHUB_PATH
+      - uses: actions/setup-go@v5
+        with:
+          go-version: ${{ env.GO_VERSION }}
+      - uses: subosito/flutter-action@v2
+        with:
+          channel: ${{ matrix.flutter_channel || 'stable' }}
+          flutter-version: ${{ matrix.flutter_version || env.FLUTTER_VERSION }}
+      - if: runner.os == 'Windows'
+        run: |
+          go build -tags nosqlite -ldflags="-w -s" -buildmode=c-shared -o ui/flutter/windows/libgopeed.dll github.com/GopeedLab/gopeed/bind/desktop
+          cd ui/flutter
+          flutter build windows
+      - if: runner.os == 'macOS'
+        run: |
+          go build -tags nosqlite -ldflags="-w -s" -buildmode=c-shared -o ui/flutter/macos/Frameworks/libgopeed.dylib github.com/GopeedLab/gopeed/bind/desktop
+          cd ui/flutter
+          flutter build macos
+      - if: runner.os == 'Linux'
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y ninja-build libgtk-3-dev libwebkit2gtk-4.1-dev libayatana-appindicator3-dev libkeybinder-3.0-dev
+          go build -tags nosqlite -ldflags="-w -s" -buildmode=c-shared -o ui/flutter/linux/bundle/lib/libgopeed.so github.com/GopeedLab/gopeed/bind/desktop
+          cd ui/flutter
+          flutter build linux
+  build-mobile:
+    name: Build mobile check
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ macos-26, ubuntu-latest ]
+    needs: [ test ]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-go@v5
        with:
          go-version: ${{ env.GO_VERSION }}
      - uses: subosito/flutter-action@v2
        with:
          flutter-version: ${{ env.FLUTTER_VERSION }}
      - run: |
-          sudo apt-get update -y
-          sudo apt-get install -y ninja-build libgtk-3-dev libayatana-appindicator3-dev
+          go install golang.org/x/mobile/cmd/gomobile@latest
+          go get golang.org/x/mobile/bind
+          gomobile init
+      - if: runner.os == 'macOS'
+        run: |
+          gomobile bind -tags nosqlite -ldflags="-w -s" -o ui/flutter/ios/Frameworks/Libgopeed.xcframework -target=ios github.com/GopeedLab/gopeed/bind/mobile
+          cd ui/flutter
+          flutter build ipa --no-codesign
+      - if: runner.os == 'Linux'
+        uses: actions/setup-java@v3
+        with:
+          distribution: "zulu"
+          java-version: "17"
+      - if: runner.os == 'Linux'
+        run: |
+          gomobile bind -tags nosqlite -ldflags="-w -s -checklinkname=0" -o ui/flutter/android/app/libs/libgopeed.aar -target=android -androidapi 21 -javapkg=com.gopeed github.com/GopeedLab/gopeed/bind/mobile
+          cd ui/flutter
+          flutter build apk
+
+  build-web:
+    name: Build web check
+    runs-on: ubuntu-latest
+    needs: [ test ]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-go@v5
+        with:
+          go-version: ${{ env.GO_VERSION }}
+      - uses: subosito/flutter-action@v2
+        with:
+          flutter-version: ${{ env.FLUTTER_VERSION }}
      - name: Build
        run: |
-          go build -tags nosqlite -ldflags="-w -s" -buildmode=c-shared -o ui/flutter/linux/bundle/lib/libgopeed.so github.com/GopeedLab/gopeed/bind/desktop
          cd ui/flutter
-          flutter build linux
+          flutter build web --no-web-resources-cdn
+          dart ../../.github/workflows/scripts/flutter_local_font.dart
+          cd ../../
+          rm -rf cmd/web/dist
+          cp -r ui/flutter/build/web cmd/web/dist
+          go build -tags nosqlite,web -ldflags="-s -w" github.com/GopeedLab/gopeed/cmd/web
+  build-docker:
+    name: Build docker check
+    runs-on: ubuntu-latest
+    needs: [ test ]
+    steps:
+      - uses: actions/checkout@v3
+      - uses: actions/setup-go@v5
+        with:
+          go-version: ${{ env.GO_VERSION }}
+      - uses: subosito/flutter-action@v2
+        with:
+          flutter-version: ${{ env.FLUTTER_VERSION }}
+      - name: Build
+        run: |
+          cd ui/flutter
+          flutter build web --no-web-resources-cdn
+          cd ../../
+          rm -rf cmd/web/dist
+          cp -r ui/flutter/build/web cmd/web/dist
+          docker build -t gopeed .
@@ -4,7 +4,7 @@
 *.dll
 *.so
 *.dylib
-
+ui/flutter/dist/
 # Test binary, built with `go test -c`
 *.test

@@ -17,10 +17,60 @@ start the front-end flutter project in `debug` mode to run.

 ## Translation

-The internationalization files of Gopeed are located in the `ui/flutter/lib/i18n/langs` directory.
-You only need to add the corresponding language file in this directory.
+Flutter translations are ARB files in `ui/flutter/lib/l10n`. Use `app_en.arb` as the source template,
+then edit or add `app_<locale>.arb` (for example, `app_de.arb` or `app_zh_TW.arb`). Every locale must
+contain the same message keys as the English template.

-Please refer to `en_us.dart` for translation.
+Translate message values only, and do not rename variables inside braces such as `{count}` and `{name}`.
+Do not translate metadata keys prefixed with `@`. Submit only the ARB source files you changed; do not generate or commit
+`app_localizations*.dart`. The pull-request CI automatically validates the catalogs, generates the
+localization code, and checks its integration.
+
+The following examples show both the ARB definition and the text users see after the app supplies values.
+
+1. Insert a variable into a message
+
+   ARB definition:
+
+   ```json
+   "welcomeUser": "Hola, {name}"
+   ```
+
+   Rendered result: when `name = Ana`, users see “Hola, Ana”. You may reorder the sentence, but keep `{name}`.
+
+2. Display different text for different quantities
+
+   ARB definition:
+
+   ```json
+   "fileCount": "{count, plural, =0{No hay archivos} =1{1 archivo} other{{count} archivos}}"
+   ```
+
+   Rendered results:
+
+   - `count = 0` → “No hay archivos”
+   - `count = 1` → “1 archivo”
+   - `count = 3` → “3 archivos”
+
+   `=0`, `=1`, and `other` mean zero, one, and every other quantity. Translate only the user-visible text
+   inside each branch.
+
+3. Display different text for different values
+
+   ARB definition:
+
+   ```json
+   "taskState": "{state, select, running{En curso} paused{En pausa} other{Desconocido}}"
+   ```
+
+   Rendered results:
+
+   - `state = running` → “En curso”
+   - `state = paused` → “En pausa”
+   - Any other value → “Desconocido”
+
+   `running`, `paused`, and `other` are values supplied by the app. Do not translate them; translate only
+   the display text inside the following braces.

 ## flutter development

@@ -30,4 +80,4 @@ Turn on build_runner watcher if you want to edit api/models:

 ```
 flutter pub run build_runner watch
-```
+```
@@ -17,10 +17,58 @@

 ## 翻訳

-Gopeed の国際化ファイルは `ui/flutter/lib/i18n/langs` ディレクトリにあります。
-このディレクトリに対応する言語ファイルを追加するだけでよいです。
+Flutter の翻訳ファイルは `ui/flutter/lib/l10n` にあります。`app_en.arb` を原文テンプレートとして、
+`app_<locale>.arb`（例: `app_de.arb`、`app_zh_TW.arb`）を編集または追加してください。すべての言語で
+英語テンプレートと同じメッセージ key が必要です。

-翻訳については `en_us.dart` を参照してください。
+翻訳するのはメッセージ値だけです。`{count}` や `{name}` など、中括弧内の変数名は変更しないでください。
+`@` で始まるメタデータ key は翻訳しません。変更した ARB ソースファイルだけをコミットし、
+`app_localizations*.dart` は生成もコミットも不要です。PR の CI が全言語を検証し、国際化コードを生成して
+統合結果を確認します。
+
+以下の例では、ARB に記述する定義と、アプリが値を渡した後にユーザーが実際に見る表示を示します。
+
+1. メッセージに変数を挿入する
+
+   ARB 定義：
+
+   ```json
+   "welcomeUser": "こんにちは、{name}"
+   ```
+
+   最終表示：`name = 太郎` の場合は「こんにちは、太郎」と表示されます。語順は変更できますが、`{name}` は残します。
+
+2. 数量に応じて表示を切り替える
+
+   ARB 定義：
+
+   ```json
+   "fileCount": "{count, plural, =0{ファイルなし} =1{1 個のファイル} other{{count} 個のファイル}}"
+   ```
+
+   最終表示：
+
+   - `count = 0` →「ファイルなし」
+   - `count = 1` →「1 個のファイル」
+   - `count = 3` →「3 個のファイル」
+
+   `=0`、`=1`、`other` はそれぞれ 0、1、その他の数量を表します。各分岐の中で画面に表示される文字だけを翻訳します。
+
+3. 変数の値に応じて表示を切り替える
+
+   ARB 定義：
+
+   ```json
+   "taskState": "{state, select, running{実行中} paused{一時停止} other{不明}}"
+   ```
+
+   最終表示：
+
+   - `state = running` →「実行中」
+   - `state = paused` →「一時停止」
+   - その他の値 →「不明」
+
+   `running`、`paused`、`other` はアプリが渡す分岐値なので翻訳せず、その後の中括弧内にある表示文字だけを翻訳します。

 ## flutter での開発

@@ -0,0 +1,79 @@
+# Hướng dẫn đóng góp cho Gopeed
+
+Trước tiên, cảm ơn bạn đã quan tâm đến việc đóng góp cho Gopeed. Hướng dẫn này sẽ giúp bạn tham gia
+phát triển Gopeed một cách tốt hơn.
+
+## Mô tả nhánh
+
+Dự án này chỉ có một nhánh chính duy nhất, đó là nhánh `main`. Nếu bạn muốn tham gia vào
+phát triển Gopeed, hãy fork dự án này trước, sau đó phát triển trong dự án fork của bạn. Sau khi
+hoàn thành phát triển, gửi một PR đến dự án này và merge vào nhánh `main`.
+
+## Phát triển cục bộ
+
+Đề nghị phát triển và gỡ lỗi thông qua web. Đầu tiên, khởi động dịch vụ backend bằng cách chạy
+lệnh `go run cmd/api/main.go` trong dòng lệnh, cổng mặc định của dịch vụ là `9999`, sau đó
+khởi động dự án flutter frontend trong chế độ `debug` để chạy.
+
+## Dịch thuật
+
+Các bản dịch Flutter là tệp ARB trong `ui/flutter/lib/l10n`. Hãy dùng `app_en.arb` làm mẫu nguồn,
+sau đó sửa hoặc thêm `app_<locale>.arb` (ví dụ `app_de.arb` hoặc `app_zh_TW.arb`). Mỗi ngôn ngữ phải
+có cùng các khóa thông điệp như mẫu tiếng Anh.
+
+Chỉ dịch giá trị thông điệp; không đổi tên biến trong dấu ngoặc nhọn như `{count}` và `{name}`. Không dịch khóa
+siêu dữ liệu bắt đầu bằng `@`. Chỉ commit các tệp nguồn ARB đã thay đổi; không cần tạo hoặc commit
+`app_localizations*.dart`. CI của pull request sẽ tự động
+kiểm tra tất cả ngôn ngữ, tạo mã bản địa hóa và xác minh việc tích hợp.
+
+Các ví dụ sau hiển thị cả định nghĩa trong ARB và nội dung người dùng thực sự thấy sau khi ứng dụng truyền giá trị.
+
+1. Chèn biến vào thông điệp
+
+   Định nghĩa ARB:
+
+   ```json
+   "welcomeUser": "Xin chào, {name}"
+   ```
+
+   Kết quả hiển thị: khi `name = An`, người dùng thấy “Xin chào, An”. Có thể đổi trật tự câu nhưng phải giữ `{name}`.
+
+2. Hiển thị nội dung khác nhau theo số lượng
+
+   Định nghĩa ARB:
+
+   ```json
+   "fileCount": "{count, plural, =0{Không có tệp} =1{1 tệp} other{{count} tệp}}"
+   ```
+
+   Kết quả hiển thị:
+
+   - `count = 0` → “Không có tệp”
+   - `count = 1` → “1 tệp”
+   - `count = 3` → “3 tệp”
+
+   `=0`, `=1` và `other` lần lượt biểu thị số lượng bằng 0, bằng 1 và các số lượng còn lại. Chỉ dịch phần chữ
+   hiển thị cho người dùng bên trong mỗi nhánh.
+
+3. Hiển thị nội dung khác nhau theo giá trị biến
+
+   Định nghĩa ARB:
+
+   ```json
+   "taskState": "{state, select, running{Đang chạy} paused{Đã tạm dừng} other{Không xác định}}"
+   ```
+
+   Kết quả hiển thị:
+
+   - `state = running` → “Đang chạy”
+   - `state = paused` → “Đã tạm dừng”
+   - Giá trị khác → “Không xác định”
+
+   `running`, `paused` và `other` là các giá trị do ứng dụng truyền vào nên không được dịch; chỉ dịch phần chữ
+   hiển thị trong dấu ngoặc theo sau chúng.
+
+## Phát triển flutter
+
+Đừng quên chạy `dart format ./ui/flutter` trước khi commit để giữ mã của bạn theo định dạng dart chuẩn.
+
+Bật build_runner watcher nếu bạn muốn chỉnh sửa api/models:
@@ -13,10 +13,57 @@ PR，合并到 `main` 分支。
 flutter 项目即可运行。

 ## 翻译
- 
-Gopeed 的国际化文件位于 `ui/flutter/lib/i18n/langs` 目录下，只需要在该目录下添加对应的语言文件即可。

-请注意以 `en_us.dart` 为参照进行翻译。
+Flutter 国际化文件位于 `ui/flutter/lib/l10n`，请以 `app_en.arb` 为源模板，修改或新增
+`app_<locale>.arb`（例如 `app_de.arb` 或 `app_zh_TW.arb`）。每个语种必须与英文模板包含相同的文案 key。
+
+只翻译文案值，不要修改 `{count}`、`{name}` 等花括号中的变量名。以 `@` 开头的元数据 key 不需要翻译。
+提交时只包含修改过的 ARB 源文件，不需要生成或提交 `app_localizations*.dart`。PR 的 CI 会自动校验所有语种、
+生成国际化代码并检查集成结果。
+
+下面的例子同时给出 ARB 中填写的文案定义，以及程序传值后用户最终看到的内容。
+
+1. 在文案中插入变量
+
+   ARB 定义：
+
+   ```json
+   "welcomeUser": "你好，{name}"
+   ```
+
+   最终显示：当 `name = 小明` 时，显示“你好，小明”。翻译时可以调整整句话，但必须保留 `{name}`。
+
+2. 根据数量显示不同文案
+
+   ARB 定义：
+
+   ```json
+   "fileCount": "{count, plural, =0{没有文件} =1{1 个文件} other{{count} 个文件}}"
+   ```
+
+   最终显示：
+
+   - `count = 0` → “没有文件”
+   - `count = 1` → “1 个文件”
+   - `count = 3` → “3 个文件”
+
+   `=0`、`=1`、`other` 分别表示数量为 0、数量为 1 和其他数量。只翻译每个分支花括号内显示给用户的文字。
+
+3. 根据变量值显示不同文案
+
+   ARB 定义：
+
+   ```json
+   "taskState": "{state, select, running{运行中} paused{已暂停} other{未知状态}}"
+   ```
+
+   最终显示：
+
+   - `state = running` → “运行中”
+   - `state = paused` → “已暂停”
+   - 其他值 → “未知状态”
+
+   `running`、`paused`、`other` 是程序传入的分支值，不能翻译；只翻译它们后面花括号内的显示文字。

 ## flutter开发

@@ -27,4 +74,3 @@ Gopeed 的国际化文件位于 `ui/flutter/lib/i18n/langs` 目录下，只需
 ```
 flutter pub run build_runner watch
 ```
-
@@ -11,11 +11,57 @@
 建議使用 web 端進行開發與調試，首先啟動服務，使用指令 `go run cmd/api/main.go` 啟動 ，該服務默認連接埠為 `9999`，接著以 `debug` 模式啟動前端 flutter 項目即可。

 ## 翻譯
- 
-Gopeed 的翻譯文件位於 `ui/flutter/lib/i18n/langs` 目錄中，只需要修改或新建翻譯文件即可。

+Flutter 翻譯檔位於 `ui/flutter/lib/l10n`，請以 `app_en.arb` 為來源範本，修改或新增
+`app_<locale>.arb`（例如 `app_de.arb` 或 `app_zh_TW.arb`）。每個語言都必須與英文範本包含相同的訊息 key。

-請以 `en_us.dart` 作為參照。
+只翻譯訊息值，不要修改 `{count}`、`{name}` 等大括號中的變數名稱。以 `@` 開頭的中繼資料 key 不需要翻譯。
+提交時只需包含修改過的 ARB 來源檔，不需要產生或提交 `app_localizations*.dart`。PR 的 CI
+會自動驗證所有語言、產生國際化程式碼並檢查整合結果。
+
+以下範例同時列出 ARB 中填寫的訊息定義，以及程式傳值後使用者最終看到的內容。
+
+1. 在訊息中插入變數
+
+   ARB 定義：
+
+   ```json
+   "welcomeUser": "你好，{name}"
+   ```
+
+   最終顯示：當 `name = 小明` 時，顯示「你好，小明」。翻譯時可以調整整句話，但必須保留 `{name}`。
+
+2. 依數量顯示不同訊息
+
+   ARB 定義：
+
+   ```json
+   "fileCount": "{count, plural, =0{沒有檔案} =1{1 個檔案} other{{count} 個檔案}}"
+   ```
+
+   最終顯示：
+
+   - `count = 0` →「沒有檔案」
+   - `count = 1` →「1 個檔案」
+   - `count = 3` →「3 個檔案」
+
+   `=0`、`=1`、`other` 分別代表數量為 0、數量為 1 和其他數量。只翻譯各分支大括號內顯示給使用者的文字。
+
+3. 依變數值顯示不同訊息
+
+   ARB 定義：
+
+   ```json
+   "taskState": "{state, select, running{執行中} paused{已暫停} other{未知狀態}}"
+   ```
+
+   最終顯示：
+
+   - `state = running` →「執行中」
+   - `state = paused` →「已暫停」
+   - 其他值 →「未知狀態」
+
+   `running`、`paused`、`other` 是程式傳入的分支值，不能翻譯；只翻譯其後大括號內的顯示文字。

 ## flutter開發

@@ -1,22 +1,23 @@
-FROM instrumentisto/flutter:3.16.1 AS flutter
-WORKDIR /app
-COPY ./ui/flutter/pubspec.yaml ./ui/flutter/pubspec.lock ./
-RUN flutter pub get
-COPY ./ui/flutter ./
-RUN flutter build web --web-renderer html
-
-FROM golang:1.19.3 AS go
+FROM golang:1.25.4-alpine3.22 AS go
 WORKDIR /app
 COPY ./go.mod ./go.sum ./
 RUN go mod download
 COPY . .
-COPY --from=flutter /app/build/web ./cmd/web/dist
-RUN CGO_ENABLED=0 go build -tags nosqlite,web -ldflags="-s -w" -o dist/gopeed github.com/GopeedLab/gopeed/cmd/web
+ARG VERSION=dev
+RUN CGO_ENABLED=0 go build -tags nosqlite,web \
+      -ldflags="-s -w -X github.com/GopeedLab/gopeed/pkg/base.Version=$VERSION -X github.com/GopeedLab/gopeed/pkg/base.InDocker=true" \
+      -o dist/gopeed github.com/GopeedLab/gopeed/cmd/web

-FROM alpine:3.14.2
+FROM alpine:3.23
 LABEL maintainer="monkeyWie"
 WORKDIR /app
 COPY --from=go /app/dist/gopeed ./
+COPY entrypoint.sh ./entrypoint.sh
+RUN apk update && \
+    apk add --no-cache su-exec ; \
+    chmod +x ./entrypoint.sh && \
+    rm -rf /var/cache/apk/*
 VOLUME ["/app/storage"]
+ENV PUID=0 PGID=0 UMASK=022
 EXPOSE 9999
-ENTRYPOINT ["./gopeed"]
+ENTRYPOINT ["./entrypoint.sh"]
@@ -1,105 +1,129 @@
+# [![](_docs/img/banner.svg)](https://gopeed.com)
+
 [![Test Status](https://github.com/GopeedLab/gopeed/workflows/test/badge.svg)](https://github.com/GopeedLab/gopeed/actions?query=workflow%3Atest)
 [![Codecov](https://codecov.io/gh/GopeedLab/gopeed/branch/main/graph/badge.svg)](https://codecov.io/gh/GopeedLab/gopeed)
 [![Release](https://img.shields.io/github/release/GopeedLab/gopeed.svg)](https://github.com/GopeedLab/gopeed/releases)
 [![Download](https://img.shields.io/github/downloads/GopeedLab/gopeed/total.svg)](https://github.com/GopeedLab/gopeed/releases)
-[![Donate](https://img.shields.io/badge/%24-donate-ff69b4.svg)](https://docs.gopeed.com/donate.html)
+[![Donate](https://img.shields.io/badge/%24-donate-ff69b4.svg)](https://gopeed.com/docs/donate)
+[![WeChat](https://img.shields.io/badge/WeChat%20Official%20Account-07C160?logo=wechat&logoColor=white)](https://raw.githubusercontent.com/GopeedLab/gopeed/main/_docs/img/weixin.png)
 [![Discord](https://img.shields.io/discord/1037992631881449472?label=Discord&logo=discord&style=social)](https://discord.gg/ZUJqJrwCGB)

-![](_docs/img/banner.png)
+<a href="https://trendshift.io/repositories/7953" target="_blank"><img src="https://trendshift.io/api/badge/repositories/7953" alt="GopeedLab%2Fgopeed | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>

-[![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/R6R6IJGN6)
+[English](/README.md) | [中文](/README_zh-CN.md) | [日本語](/README_ja-JP.md) | [正體中文](/README_zh-TW.md) | [Tiếng Việt](/README_vi-VN.md)

-[English](/README.md) | [中文](/README_zh-CN.md) | [日本語](/README_ja-JP.md) | [正體中文](/README_zh-TW.md)
+## 🚀 Introduction

-## Introduction
+Gopeed (short for **Go Speed**) is a fast, modern, free, and open-source download manager built with Go and Flutter. It supports HTTP, HTTPS, BitTorrent, magnet links, and ed2k on desktop, mobile, and the web.

-Gopeed (full name Go Speed), a high-speed downloader developed by `Golang` + `Flutter`, supports (HTTP, BitTorrent, Magnet) protocol, and supports all platforms. In addition to basic download functions, Gopeed is also a highly customizable downloader that supports implementing more features through integration with [APIs](https://docs.gopeed.com/dev-api.html) or installation and development of [extensions](https://docs.gopeed.com/dev-extension.html).
+Beyond core download management, Gopeed offers browser integration, JavaScript extensions, a REST API, a CLI, and a self-hosted web UI for customization and automation.

+Visit ✈ [Official Website](https://gopeed.com)

-Visit ✈ [Official Website](https://gopeed.com) | 📖 [Official Docs](https://docs.gopeed.com)
+![Application screenshot](_docs/img/ui-concept-en.png)

-## Install
+## ✨ Features

-**Supported platforms**
+- ⚡ **High-speed downloads** — combine concurrent tasks, multi-connection HTTP transfers, and peer-to-peer BitTorrent downloads to make the most of your bandwidth.
+- 🧲 **Multiple protocols** — download HTTP/HTTPS files, torrents, magnet links, and ed2k resources from a single app.
+- 🌱 **Full-featured BitTorrent** — use DHT peer discovery, uTP transport, Web Seeds, selective file downloads, tracker management, peer and piece statistics, and ratio- or time-based seeding limits.
+- 📋 **Flexible task management** — pause, resume, retry, run batch operations, search, filter by status, organize with categories, and recover tasks after a restart.
+- 🪶 **Lightweight native experience** — the main interface is rendered natively with Flutter. No Electron. No WebView shell. Enjoy a smaller footprint, lower overhead, and responsive performance.
+- 💻 **Cross-platform** — available for Windows, macOS, Linux, Android, iOS, and the web, with Docker and QNAP deployment options.
+- 🎨 **Customizable appearance** — follow your system theme or choose light or dark mode, with eight accent colors.
+- 📐 **Responsive interface** — task lists, navigation, settings, and detail views adapt to phones, tablets, and resizable desktop windows.
+- 🗣️ **Available in 20+ languages** — including English, Simplified and Traditional Chinese, Japanese, Korean, and many more.
+- 🌐 **Browser integration** — send downloads from Chrome, Edge, Firefox, and other compatible browsers directly to Gopeed.
+- 🧩 **JavaScript extensions** — add support for video platforms, AI model hubs, cloud storage services, and other download sources.
+- 🤖 **AI integration** — use Gopeed's MCP endpoint to connect compatible AI agents and create, inspect, or manage downloads with natural language.
+- 🔌 **Automation-ready** — integrate with Gopeed through its REST API, CLI, authenticated web UI, webhooks, and post-download scripts.
+- 🛠️ **Built-in essentials** — customize headers and the User-Agent, use proxies and GitHub mirrors, receive notifications, and extract archives automatically.

- [x] windows
- [x] macos
- [x] linux
- [x] android
- [x] ios
- [x] web
- [x] docker
+## 🤖 AI Integration

-[Download](https://github.com/GopeedLab/gopeed/releases/latest)
+Connect Gopeed to an AI agent and manage downloads with natural language. For example, you can say:

-> Tips: If the macos open failed, please execute the `xattr -d com.apple.quarantine /Applications/Gopeed.app` command in the terminal
+> Download the latest Gopeed client for Windows.

-### Command tool
+| Tool | Description |
+| --- | --- |
+| `resolve_task` | Resolve a download URL or URI and return its resource metadata and files before creating a task. |
+| `create_task` | Create and start a task from a resolved resource ID or a direct download request. |
+| `list_tasks` | List tasks, optionally filtering them by ID or status. |
+| `get_task` | Get the request, resource, options, and current progress for one task. |
+| `get_task_status` | Get lightweight runtime status and per-file progress for one task. |
+| `get_task_stats` | Get protocol-specific statistics, including HTTP connections or BitTorrent peers and seeding data. |
+| `pause_task` | Pause a task. |
+| `continue_task` | Continue a paused or failed task. |
+| `delete_task` | Delete a task, optionally deleting its downloaded files. |

-use `go install`:
+## ⬇️ Download
+
+### 🧪 Gopeed 2.0.0 Beta
+
+Gopeed 2.0.0 is currently in public beta, introducing a redesigned interface, a native communication architecture that connects desktop and mobile clients directly to the Go core through FFI, a more consistent cross-platform experience, improved task management, more flexible API support, and MCP-based AI agent integration. Some features may still be incomplete or unstable, so please try it and report any issues you encounter.
+
+- [Download Gopeed 2.0.0 Beta 2](https://github.com/GopeedLab/gopeed/releases/tag/v2.0.0-beta.2)
+
+Once the features and stability meet our release standards, we will publish the official Gopeed 2.0.0 release. Beta users will be able to upgrade directly to the final release, while existing stable users will not be automatically moved onto the beta channel.
+
+### Stable release
+
+- [Official Download](https://gopeed.com)
+- [GitHub Releases](https://github.com/GopeedLab/gopeed/releases/latest)
+
+### 🛠️ Command-line tool
+
+Install the CLI with `go install`:

 ```bash
 go install github.com/GopeedLab/gopeed/cmd/gopeed@latest
 ```

-### Docker
+## 🔌 Browser Extension

-#### Start directly
+Use the Gopeed browser extension to send downloads from Chrome, Edge, Firefox, and other compatible browsers directly to Gopeed: [GopeedLab/browser-extension](https://github.com/GopeedLab/browser-extension)

-```bash
-docker run -d -p 9999:9999 -v /path/to/download:/root/Downloads -v /path/to/storage:/app/storage liwei2633/gopeed
-```
+## 📱 WeChat Official Account

-[More details for docker](https://docs.gopeed.com/install.html#docker-installation)
+Follow Gopeed's official WeChat account for updates and news.

-#### Using Docker Compose
+<img src="_docs/img/weixin.png" width="200" />

-```bash
-docker-compose up -d
-```
+## 💝 Donate

-#### Access Gopeed
+If Gopeed is useful to you, please consider [supporting its development](https://gopeed.com/docs/donate). Thank you!

-When the docker container is running, you can access the web page through `http://localhost:9999`.
+## 👨‍💻 Development

-## Donate
+Gopeed consists of a Flutter front end and a Go back end. They communicate over HTTP, using Unix sockets on Unix-like systems and TCP on Windows.

-If you like this project, please consider [donating](https://docs.gopeed.com/donate.html) to support the development of this project, thank you!
+> The front-end source is located in the `ui/flutter` directory.

-## Showcase
+### 🌍 Environment

-![](_docs/img/ui-demo.png)
+1. Go 1.25+
+2. Flutter 3.41+

-## Development
-
-This project is divided into two parts, the front end uses `flutter`, the back end uses `Golang`, and the two sides communicate through the `http` protocol. On the unix system, `unix socket` is used, and on the windows system, `tcp` protocol is used.
-
-> The front code is located in the `ui/flutter` directory.
-
-### Environment
-
-1. Golang 1.19+
-2. Flutter 3.10+
-
-### Clone
+### 📋 Clone

 ```bash
 git clone [email protected]:GopeedLab/gopeed.git
 ```

-### Contributing
+### 🤝 Contributing

-Please refer to [CONTRIBUTING.md](/CONTRIBUTING.md)
+See [CONTRIBUTING.md](/CONTRIBUTING.md).

-### Build
+### 🏗️ Build

 #### Desktop

-First, you need to configure the environment according to the official [Flutter desktop website documention](https://docs.flutter.dev/development/platform-integration/desktop), then you will need to ensure the cgo environment is set up accordingly. For detailed instructions on setting up the cgo environment, please refer to relevant resources available online.
+Set up Flutter desktop development using the official [Flutter desktop guide](https://docs.flutter.dev/development/platform-integration/desktop), and make sure a working C toolchain is available for cgo. Then run the commands for your platform.

-command:
+Commands:

- windows
+- Windows

 ```bash
 go build -tags nosqlite -ldflags="-w -s" -buildmode=c-shared -o ui/flutter/windows/libgopeed.dll github.com/GopeedLab/gopeed/bind/desktop
@@ -107,7 +131,7 @@ cd ui/flutter
 flutter build windows
 ```

- macos
+- macOS

 ```bash
 go build -tags nosqlite -ldflags="-w -s" -buildmode=c-shared -o ui/flutter/macos/Frameworks/libgopeed.dylib github.com/GopeedLab/gopeed/bind/desktop
@@ -115,7 +139,7 @@ cd ui/flutter
 flutter build macos
 ```

- linux
+- Linux

 ```bash
 go build -tags nosqlite -ldflags="-w -s" -buildmode=c-shared -o ui/flutter/linux/bundle/lib/libgopeed.so github.com/GopeedLab/gopeed/bind/desktop
@@ -125,7 +149,7 @@ flutter build linux

 #### Mobile

-Same as before, you also need to prepare the `cgo` environment, and then install `gomobile`:
+Mobile builds also require a working cgo toolchain. Install and initialize `gomobile`:

 ```bash
 go install golang.org/x/mobile/cmd/gomobile@latest
@@ -133,17 +157,17 @@ go get golang.org/x/mobile/bind
 gomobile init
 ```

-command:
+Commands:

- android
+- Android

 ```bash
-gomobile bind -tags nosqlite -ldflags="-w -s" -o ui/flutter/android/app/libs/libgopeed.aar -target=android -androidapi 19 -javapkg=com.gopeed github.com/GopeedLab/gopeed/bind/mobile
+gomobile bind -tags nosqlite -ldflags="-w -s -checklinkname=0" -o ui/flutter/android/app/libs/libgopeed.aar -target=android -androidapi 21 -javapkg="com.gopeed" github.com/GopeedLab/gopeed/bind/mobile
 cd ui/flutter
 flutter build apk
 ```

- ios
+- iOS

 ```bash
 gomobile bind -tags nosqlite -ldflags="-w -s" -o ui/flutter/ios/Frameworks/Libgopeed.xcframework -target=ios github.com/GopeedLab/gopeed/bind/mobile
@@ -153,7 +177,7 @@ flutter build ios --no-codesign

 #### Web

-command:
+Build the web app and server:

 ```bash
 cd ui/flutter
@@ -164,18 +188,18 @@ cp -r ui/flutter/build/web cmd/web/dist
 go build -tags nosqlite,web -ldflags="-s -w" -o bin/ github.com/GopeedLab/gopeed/cmd/web
 ```

-## Credits
+## ❤️ Credits

-### Contributors
+### 👥 Contributors

 <a href="https://github.com/GopeedLab/gopeed/graphs/contributors">
  <img src="https://contrib.rocks/image?repo=GopeedLab/gopeed" />
 </a>

-### JetBrains
+### 🏢 JetBrains

 [![goland](_docs/img/goland.svg)](https://www.jetbrains.com/?from=gopeed)

-## License
+## 📄 License

 [GPLv3](LICENSE)
@@ -1,96 +1,111 @@
+# [![](_docs/img/banner.svg)](https://gopeed.com)
+
 [![Test Status](https://github.com/GopeedLab/gopeed/workflows/test/badge.svg)](https://github.com/GopeedLab/gopeed/actions?query=workflow%3Atest)
 [![Codecov](https://codecov.io/gh/GopeedLab/gopeed/branch/main/graph/badge.svg)](https://codecov.io/gh/GopeedLab/gopeed)
 [![Release](https://img.shields.io/github/release/GopeedLab/gopeed.svg)](https://github.com/GopeedLab/gopeed/releases)
 [![Download](https://img.shields.io/github/downloads/GopeedLab/gopeed/total.svg)](https://github.com/GopeedLab/gopeed/releases)
-[![Donate](https://img.shields.io/badge/%24-donate-ff69b4.svg)](https://docs.gopeed.com/donate.html)
+[![Donate](https://img.shields.io/badge/%24-donate-ff69b4.svg)](https://gopeed.com/docs/donate)
+[![WeChat](https://img.shields.io/badge/WeChat%20Official%20Account-07C160?logo=wechat&logoColor=white)](https://raw.githubusercontent.com/GopeedLab/gopeed/main/_docs/img/weixin.png)
 [![Discord](https://img.shields.io/discord/1037992631881449472?label=Discord&logo=discord&style=social)](https://discord.gg/ZUJqJrwCGB)

-![](_docs/img/banner.png)
+<a href="https://trendshift.io/repositories/7953" target="_blank"><img src="https://trendshift.io/api/badge/repositories/7953" alt="GopeedLab%2Fgopeed | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>

-[![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/R6R6IJGN6)
+[English](/README.md) | [中文](/README_zh-CN.md) | [日本語](/README_ja-JP.md) | [正體中文](/README_zh-TW.md) | [Tiếng Việt](/README_vi-VN.md)

-[English](/README.md) | [中文](/README_zh-CN.md) | [日本語](/README_ja-JP.md) | [正體中文](/README_zh-TW.md)
+## 🚀 はじめに

-## はじめに
+Gopeed（**Go Speed** の略）は、Go と Flutter で開発された高速でモダンな無料オープンソース・ダウンロードマネージャーです。HTTP、HTTPS、BitTorrent、Magnet、ed2k に対応し、デスクトップ、モバイル、Web で利用できます。

-Gopeed (正式名 Go Speed) は `Golang` + `Flutter` によって開発された高速ダウンローダーで、(HTTP、BitTorrent、Magnet) プロトコルをサポートし、すべてのプラットフォームをサポートします。基本的なダウンロード機能に加え、[APIs](https://docs.gopeed.com/dev-api.html)との連動や[拡張機能](https://docs.gopeed.com/dev-extension.html)のインストール・開発による追加機能にも対応した、カスタマイズ性の高いダウンローダーです。
+ブラウザー連携、JavaScript 拡張、REST API、CLI、セルフホスト可能な Web UI により、日常利用から高度な自動化まで幅広く対応します。

-見て下さい ✈ [公式ウェブサイト](https://gopeed.com) | 📖 [開発ドキュメント](https://docs.gopeed.com)
+✈ [公式サイト](https://gopeed.com)

-## インストール
+![アプリのスクリーンショット](_docs/img/ui-concept-en.png)

-**サポートするプラットフォーム**
+## ✨ 主な機能

- [x] windows
- [x] macos
- [x] linux
- [x] android
- [x] ios
- [x] web
- [x] docker
+- ⚡ **高速ダウンロード** — 複数タスク、HTTP のマルチ接続分割転送、BitTorrent の P2P ダウンロードで帯域を最大限に活用します。
+- 🧲 **マルチプロトコル** — HTTP、HTTPS、BitTorrent、Magnet、ed2k を一つの画面で管理します。
+- 🌱 **充実した BT 機能** — DHT によるピア検出、uTP 転送、Web Seed、ファイル選択、Tracker 管理、Peer/ピース統計、共有率または時間によるシード制御。
+- 📋 **タスク管理** — 一時停止、再開、再試行、一括操作、検索、状態フィルター、カテゴリ、起動時復元。
+- 🪶 **軽量なネイティブ体験** — メイン UI は Flutter でネイティブ描画。Electron 非採用。WebView ラッパーでもありません。パッケージサイズと実行時オーバーヘッドを抑え、軽快な応答性を実現します。
+- 💻 **クロスプラットフォーム** — Windows、macOS、Linux、Android、iOS、Web、Docker、QNAP に対応。
+- 🎨 **カスタマイズ可能なテーマ** — システム連動、ライト、ダークの各モードと 8 色のアクセントカラーに対応。
+- 📐 **レスポンシブ UI** — タスクリスト、ナビゲーション、設定、詳細画面がスマートフォン、タブレット、サイズ変更可能なデスクトップウィンドウに適応。
+- 🗣️ **20 以上の UI 言語** — 日本語、英語、簡体字・繁体字中国語、韓国語など多くの言語に対応。
+- 🌐 **ブラウザー連携** — Chrome、Edge、Firefox などのダウンロードを Gopeed に送信できます。
+- 🧩 **JavaScript 拡張** — 動画サイト、AI モデルハブ、クラウドストレージなどのダウンロード元を追加できます。
+- 🤖 **AI 連携** — MCP インターフェースを通じて対応する AI Agent と連携し、自然言語でダウンロードタスクを作成・確認・管理できます。
+- 🔌 **オープンなインターフェース** — REST API、CLI、認証付き Web UI、Webhook、完了後スクリプトに対応。
+- 🛠️ **便利な内蔵機能** — カスタム Header/User-Agent、Proxy、GitHub ミラー、通知、自動展開。

-[ダウンロード](https://github.com/GopeedLab/gopeed/releases/latest)
+## 🤖 AI 連携

-> ヒント: macos を開くのに失敗した場合は、ターミナルで `xattr -d com.apple.quarantine /Applications/Gopeed.app` コマンドを実行してください
+Gopeed を AI Agent と連携すると、自然言語でダウンロードを管理できます。たとえば、AI Agent に次のように依頼できます：

-### コマンドツール
+> 最新の Gopeed Windows クライアントをダウンロードして

-`go install` を使用:
+| Tool | 説明 |
+| --- | --- |
+| `resolve_task` | ダウンロード URL または URI を解析し、タスク作成前にリソース情報とファイル一覧を返します。 |
+| `create_task` | 解析済みのリソース ID または直接のダウンロードリクエストからタスクを作成して開始します。 |
+| `list_tasks` | タスクを一覧表示し、必要に応じて ID または状態で絞り込みます。 |
+| `get_task` | 一つのタスクについて、リクエスト、リソース、オプション、現在の進捗を取得します。 |
+| `get_task_status` | 一つのタスクの簡易的な実行状態とファイル別の進捗を取得します。 |
+| `get_task_stats` | HTTP 接続数や BitTorrent の Peer・シード情報など、プロトコル固有の統計を取得します。 |
+| `pause_task` | タスクを一時停止します。 |
+| `continue_task` | 一時停止または失敗したタスクを再開します。 |
+| `delete_task` | タスクを削除し、必要に応じてダウンロード済みファイルも削除します。 |

-```bash
-go install github.com/GopeedLab/gopeed/cmd/gopeed@latest
-```
+## ⬇️ インストール

-### Docker
+### 🧪 Gopeed 2.0.0 Beta

-#### 直接始める
+Gopeed 2.0.0 は現在パブリックベータ版です。刷新されたインターフェース、デスクトップおよびモバイルから FFI で Go コアへ直接接続するネイティブ通信アーキテクチャ、より統一されたクロスプラットフォーム体験、強化されたタスク管理、より柔軟な API、MCP による AI Agent 連携機能を導入しています。一部の機能はまだ不完全または不安定な場合がありますので、ぜひお試しいただき、問題があればフィードバックをお寄せください。

-```bash
-docker run -d -p 9999:9999 -v /path/to/download:/root/Downloads -v /path/to/storage:/app/storage liwei2633/gopeed
-```
+- [Gopeed 2.0.0 Beta 2 をダウンロード](https://github.com/GopeedLab/gopeed/releases/tag/v2.0.0-beta.2)

-[Dockerの使用については](https://docs.gopeed.com/install.html#docker-installation)
+機能と安定性が正式リリースの基準に達した時点で、Gopeed 2.0.0 正式版を公開します。ベータ版のユーザーは正式版へ直接アップデートできます。既存の安定版ユーザーが自動的にベータチャンネルへ移行することはありません。

-#### Docker Compose の使用
+### 安定版

-```bash
-docker-compose up -d
-```
+- [公式サイトからダウンロード](https://gopeed.com)
+- [GitHub Releases](https://github.com/GopeedLab/gopeed/releases/latest)

-#### Gopeed へのアクセス
+### 🛠️ コマンドツール

-docker コンテナが起動しているときは、`http://localhost:9999` からウェブページにアクセスできます。
+## 📱 WeChat 公式アカウント

-## 寄付
+公式アカウントをフォローして、最新のアップデートやニュースを入手してください。

-もしこのプロジェクトがお気に召しましたら、このプロジェクトの発展を支援するために[寄付](/.donate/index.md#donate)をご検討ください！
+<img src="_docs/img/weixin.png" width="200" />

-## ショーケース
+## 💝 寄付

-![](_docs/img/ui-demo.png)
+もしこのプロジェクトがお気に召しましたら、このプロジェクトの発展を支援するために[寄付](https://gopeed.com/docs/donate)をご検討ください！

-## 開発
+## 👨‍💻 開発

 このプロジェクトは二つの部分に分かれており、フロントエンドでは `flutter` を、バックエンドでは `Golang` を使用し、両者は `http` プロトコルで通信する。ユニックスシステムでは `unix socket` を、ウィンドウズシステムでは `tcp` プロトコルを使用します。

 > フロントコードは `ui/flutter` ディレクトリにあります。

-### 環境
+### 🌍 環境

-1. Go 言語 1.19+
-2. Flutter 3.10+
+1. Go 言語 1.25+
+2. Flutter 3.41+

-### クローン
+### 📋 クローン

 ```bash
 git clone [email protected]:GopeedLab/gopeed.git
 ```

-### コントリビュート
+### 🤝 コントリビュート

 [CONTRIBUTING.md](/CONTRIBUTING_ja-JP.md) をご参照ください

-### ビルド
+### 🏗️ ビルド

 #### デスクトップ

@@ -137,7 +152,7 @@ gomobile init
 - android

 ```bash
-gomobile bind -tags nosqlite -ldflags="-w -s" -o ui/flutter/android/app/libs/libgopeed.aar -target=android -androidapi 19 -javapkg=com.gopeed github.com/GopeedLab/gopeed/bind/mobile
+gomobile bind -tags nosqlite -ldflags="-w -s -checklinkname=0" -o ui/flutter/android/app/libs/libgopeed.aar -target=android -androidapi 21 -javapkg="com.gopeed" github.com/GopeedLab/gopeed/bind/mobile
 cd ui/flutter
 flutter build apk
 ```
@@ -163,7 +178,7 @@ cp -r ui/flutter/build/web cmd/web/dist
 go build -tags nosqlite,web -ldflags="-s -w" -o bin/ github.com/GopeedLab/gopeed/cmd/web
 ```

-## 感謝
+## ❤️ 感謝

 ### コントリビューター

@@ -0,0 +1,201 @@
+# [![](_docs/img/banner.svg)](https://gopeed.com)
+
+[![Trạng thái kiểm tra](https://github.com/GopeedLab/gopeed/workflows/test/badge.svg)](https://github.com/GopeedLab/gopeed/actions?query=workflow%3Atest)
+[![Codecov](https://codecov.io/gh/GopeedLab/gopeed/branch/main/graph/badge.svg)](https://codecov.io/gh/GopeedLab/gopeed)
+[![Phiên bản](https://img.shields.io/github/release/GopeedLab/gopeed.svg)](https://github.com/GopeedLab/gopeed/releases)
+[![Tải về](https://img.shields.io/github/downloads/GopeedLab/gopeed/total.svg)](https://github.com/GopeedLab/gopeed/releases)
+[![Ủng hộ](https://img.shields.io/badge/%24-ủng%20hộ-ff69b4.svg)](https://gopeed.com/docs/donate)
+[![WeChat](https://img.shields.io/badge/WeChat%20Official%20Account-07C160?logo=wechat&logoColor=white)](https://raw.githubusercontent.com/GopeedLab/gopeed/main/_docs/img/weixin.png)
+[![Discord](https://img.shields.io/discord/1037992631881449472?label=Discord&logo=discord&style=social)](https://discord.gg/ZUJqJrwCGB)
+
+<a href="https://trendshift.io/repositories/7953" target="_blank"><img src="https://trendshift.io/api/badge/repositories/7953" alt="GopeedLab%2Fgopeed | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>
+
+[English](/README.md) | [中文](/README_zh-CN.md) | [日本語](/README_ja-JP.md) | [正體中文](/README_zh-TW.md) | [Tiếng Việt](/README_vi-VN.md)
+
+## 🚀 Giới thiệu
+
+Gopeed (viết tắt của **Go Speed**) là trình quản lý tải xuống nhanh, hiện đại, miễn phí và mã nguồn mở, được xây dựng bằng Go và Flutter. Gopeed hỗ trợ HTTP, HTTPS, BitTorrent, Magnet và ed2k trên máy tính, thiết bị di động và Web.
+
+Ngoài việc quản lý tải xuống hằng ngày, Gopeed còn hỗ trợ tích hợp trình duyệt, tiện ích JavaScript, REST API, CLI và Web UI có thể tự lưu trữ để mở rộng và tự động hóa quy trình.
+
+Truy cập ✈ [Trang web chính thức](https://gopeed.com)
+
+![Ảnh chụp màn hình ứng dụng](_docs/img/ui-concept-en.png)
+
+## ✨ Tính năng chính
+
+- ⚡ **Tải xuống tốc độ cao** — kết hợp nhiều tác vụ, truyền HTTP phân đoạn qua nhiều kết nối và tải BitTorrent P2P để tận dụng tối đa băng thông.
+- 🧲 **Đa giao thức** — quản lý HTTP, HTTPS, BitTorrent, Magnet và ed2k trong một giao diện.
+- 🌱 **Bộ công cụ BT đầy đủ** — hỗ trợ khám phá Peer qua DHT, truyền tải uTP, Web Seed, chọn tệp, quản lý Tracker, xem Peer/mảnh và kiểm soát seed theo tỷ lệ hoặc thời gian.
+- 📋 **Quản lý tác vụ thực tế** — tạm dừng, tiếp tục, thử lại, thao tác hàng loạt, tìm kiếm, bộ lọc, danh mục và khôi phục khi khởi động.
+- 🪶 **Trải nghiệm native gọn nhẹ** — giao diện chính được Flutter kết xuất native. Không Electron. Không vỏ bọc WebView. Kích thước nhỏ hơn, ít tốn tài nguyên hơn và phản hồi nhanh hơn.
+- 💻 **Đa nền tảng** — Windows, macOS, Linux, Android, iOS, Web, Docker và QNAP.
+- 🎨 **Giao diện tùy biến** — hỗ trợ chế độ theo hệ thống, sáng, tối và 8 màu nhấn.
+- 📐 **Bố cục thích ứng** — danh sách tác vụ, điều hướng, cài đặt và màn hình chi tiết tự điều chỉnh cho điện thoại, máy tính bảng và cửa sổ desktop có thể thay đổi kích thước.
+- 🗣️ **Hơn 20 ngôn ngữ giao diện** — gồm tiếng Việt, tiếng Anh, tiếng Trung giản thể và phồn thể, tiếng Nhật, tiếng Hàn cùng nhiều ngôn ngữ khác.
+- 🌐 **Tích hợp trình duyệt** — gửi tải xuống từ Chrome, Edge, Firefox và các trình duyệt tương thích sang Gopeed.
+- 🧩 **Tiện ích JavaScript** — thêm nguồn tải từ nền tảng video, kho mô hình AI, lưu trữ đám mây và nhiều dịch vụ khác.
+- 🤖 **Tích hợp AI** — cung cấp giao diện MCP để kết nối với các AI Agent tương thích và tạo, kiểm tra hoặc quản lý tác vụ tải xuống bằng ngôn ngữ tự nhiên.
+- 🔌 **Giao diện mở** — REST API, CLI, Web UI có xác thực, webhook và script sau khi tải.
+- 🛠️ **Công cụ tích hợp** — Header/User-Agent tùy chỉnh, proxy, mirror GitHub, thông báo và tự động giải nén.
+
+## 🤖 Tích hợp AI
+
+Sau khi kết nối Gopeed với AI Agent, bạn có thể quản lý tải xuống bằng ngôn ngữ tự nhiên. Ví dụ, hãy nói với AI Agent:
+
+> Hãy tải xuống phiên bản Gopeed mới nhất dành cho Windows
+
+| Tool | Mô tả |
+| --- | --- |
+| `resolve_task` | Phân tích URL hoặc URI tải xuống và trả về thông tin tài nguyên cùng danh sách tệp trước khi tạo tác vụ. |
+| `create_task` | Tạo và bắt đầu tác vụ từ ID tài nguyên đã phân tích hoặc từ yêu cầu tải xuống trực tiếp. |
+| `list_tasks` | Liệt kê tác vụ và có thể lọc theo ID hoặc trạng thái. |
+| `get_task` | Lấy yêu cầu, tài nguyên, tùy chọn và tiến độ hiện tại của một tác vụ. |
+| `get_task_status` | Lấy trạng thái chạy rút gọn và tiến độ của từng tệp trong một tác vụ. |
+| `get_task_stats` | Lấy số liệu thống kê theo giao thức, gồm kết nối HTTP hoặc Peer và dữ liệu seed của BitTorrent. |
+| `pause_task` | Tạm dừng tác vụ. |
+| `continue_task` | Tiếp tục tác vụ đã tạm dừng hoặc bị lỗi. |
+| `delete_task` | Xóa tác vụ và có thể xóa cả các tệp đã tải xuống. |
+
+## ⬇️ Tải về
+
+### 🧪 Gopeed 2.0.0 Beta
+
+Gopeed 2.0.0 hiện đang trong giai đoạn beta công khai, với giao diện được thiết kế lại, kiến trúc giao tiếp native kết nối trực tiếp ứng dụng desktop và di động với lõi Go qua FFI, trải nghiệm đa nền tảng nhất quán hơn, khả năng quản lý tác vụ được cải thiện, API linh hoạt hơn và khả năng tích hợp AI Agent qua MCP. Một số tính năng có thể vẫn chưa hoàn thiện hoặc chưa ổn định, vì vậy hãy dùng thử và gửi phản hồi nếu bạn gặp vấn đề.
+
+- [Tải Gopeed 2.0.0 Beta 2](https://github.com/GopeedLab/gopeed/releases/tag/v2.0.0-beta.2)
+
+Khi các tính năng và độ ổn định đáp ứng tiêu chuẩn phát hành, chúng tôi sẽ phát hành Gopeed 2.0.0 chính thức. Người dùng bản beta có thể nâng cấp trực tiếp lên bản chính thức, trong khi người dùng bản ổn định hiện tại sẽ không tự động được chuyển sang kênh beta.
+
+### Bản ổn định
+
+- [Tải xuống từ trang web chính thức](https://gopeed.com)
+- [GitHub Releases](https://github.com/GopeedLab/gopeed/releases/latest)
+
+### 🛠️ Công cụ lệnh
+
+Sử dụng `go install`:
+
+```bash
+go install github.com/GopeedLab/gopeed/cmd/gopeed@latest
+```
+
+## 📱 WeChat Official Account
+
+Theo dõi tài khoản chính thức để nhận các cập nhật và tin tức mới nhất.
+
+<img src="_docs/img/weixin.png" width="200" />
+
+## 💝 Quyên góp
+
+Nếu bạn thích dự án này, xin vui lòng xem xét [quyên góp](https://gopeed.com/docs/donate) để hỗ trợ phát triển dự án này, cảm ơn bạn!
+
+## 👨‍💻 Development
+
+Dự án này được chia thành hai phần, phần giao diện sử dụng `flutter`, phần backend sử dụng `Golang`, và hai phía giao tiếp thông qua giao thức `http`. Trên hệ thống unix, sử dụng `unix socket`, và trên hệ thống windows, sử dụng giao thức `tcp`.
+
+> Mã giao diện nằm trong thư mục `ui/flutter`.
+
+### 🌍 Environment
+
+1. Golang 1.25+
+2. Flutter 3.41+
+
+### 📋 Clone
+
+```bash
+git clone [email protected]:GopeedLab/gopeed.git
+```
+
+### 🤝 Đóng góp
+
+Vui lòng tham khảo [CONTRIBUTING_vi-VN.md](/CONTRIBUTING_vi-VN.md)
+
+### 🏗️ Xây dựng
+
+#### Desktop
+
+Trước tiên, bạn cần cấu hình môi trường theo tài liệu chính thức của [Tài liệu trang web máy tính để bàn Flutter](https://docs.flutter.dev/development/platform-integration/desktop), sau đó bạn cần đảm bảo môi trường cgo được thiết lập đúng. Để biết hướng dẫn chi tiết về cách thiết lập môi trường cgo, vui lòng tham khảo các tài liệu tương ứng có sẵn trực tuyến.
+
+command:
+
+- windows
+
+```bash
+go build -tags nosqlite -ldflags="-w -s" -buildmode=c-shared -o ui/flutter/windows/libgopeed.dll github.com/GopeedLab/gopeed/bind/desktop
+cd ui/flutter
+flutter build windows
+```
+
+- macos
+
+```bash
+go build -tags nosqlite -ldflags="-w -s" -buildmode=c-shared -o ui/flutter/macos/Frameworks/libgopeed.dylib github.com/GopeedLab/gopeed/bind/desktop
+cd ui/flutter
+flutter build macos
+```
+
+- linux
+
+```bash
+go build -tags nosqlite -ldflags="-w -s" -buildmode=c-shared -o ui/flutter/linux/bundle/lib/libgopeed.so github.com/GopeedLab/gopeed/bind/desktop
+cd ui/flutter
+flutter build linux
+```
+
+#### Mobile
+
+Giống như trước đây, bạn cũng cần chuẩn bị môi trường `cgo` và sau đó cài đặt `gomobile`:
+
+```bash
+go install golang.org/x/mobile/cmd/gomobile@latest
+go get golang.org/x/mobile/bind
+gomobile init
+```
+
+command:
+
+- android
+
+```bash
+gomobile bind -tags nosqlite -ldflags="-w -s -checklinkname=0" -o ui/flutter/android/app/libs/libgopeed.aar -target=android -androidapi 21 -javapkg="com.gopeed" github.com/GopeedLab/gopeed/bind/mobile
+cd ui/flutter
+flutter build apk
+```
+
+- ios
+
+```bash
+gomobile bind -tags nosqlite -ldflags="-w -s" -o ui/flutter/ios/Frameworks/Libgopeed.xcframework -target=ios github.com/GopeedLab/gopeed/bind/mobile
+cd ui/flutter
+flutter build ios --no-codesign
+```
+
+#### Web
+
+command:
+
+```bash
+cd ui/flutter
+flutter build web
+cd ../../
+rm -rf cmd/web/dist
+cp -r ui/flutter/build/web cmd/web/dist
+go build -tags nosqlite,web -ldflags="-s -w" -o bin/ github.com/GopeedLab/gopeed/cmd/web
+```
+
+## ❤️ Tín dụng
+
+### Người đóng góp
+
+<a href="https://github.com/GopeedLab/gopeed/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=GopeedLab/gopeed" />
+</a>
+
+### JetBrains
+
+[![goland](_docs/img/goland.svg)](https://www.jetbrains.com/?from=gopeed)
+
+## Giấy phép
+
+[GPLv3](LICENSE)
@@ -1,39 +1,78 @@
+# [![](_docs/img/banner.svg)](https://gopeed.com)
+
 [![Test Status](https://github.com/GopeedLab/gopeed/workflows/test/badge.svg)](https://github.com/GopeedLab/gopeed/actions?query=workflow%3Atest)
 [![Codecov](https://codecov.io/gh/GopeedLab/gopeed/branch/main/graph/badge.svg)](https://codecov.io/gh/GopeedLab/gopeed)
 [![Release](https://img.shields.io/github/release/GopeedLab/gopeed.svg)](https://github.com/GopeedLab/gopeed/releases)
 [![Download](https://img.shields.io/github/downloads/GopeedLab/gopeed/total.svg)](https://github.com/GopeedLab/gopeed/releases)
-[![Donate](https://img.shields.io/badge/%24-donate-ff69b4.svg)](https://docs.gopeed.com/zh/donate.html)
+[![Donate](https://img.shields.io/badge/%24-donate-ff69b4.svg)](https://gopeed.com/docs/donate)
+[![WeChat](https://img.shields.io/badge/%E5%BE%AE%E4%BF%A1%E5%85%AC%E4%BC%97%E5%8F%B7-07C160?logo=wechat&logoColor=white)](https://raw.githubusercontent.com/GopeedLab/gopeed/main/_docs/img/weixin.png)
 [![Discord](https://img.shields.io/discord/1037992631881449472?label=Discord&logo=discord&style=social)](https://discord.gg/ZUJqJrwCGB)

-![](_docs/img/banner.png)
+<a href="https://trendshift.io/repositories/7953" target="_blank"><img src="https://trendshift.io/api/badge/repositories/7953" alt="GopeedLab%2Fgopeed | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>

-[![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/R6R6IJGN6)
+[English](/README.md) | [中文](/README_zh-CN.md) | [日本語](/README_ja-JP.md) | [正體中文](/README_zh-TW.md) | [Tiếng Việt](/README_vi-VN.md)

-[English](/README.md) | [中文](/README_zh-CN.md) | [日本語](/README_ja-JP.md) | [正體中文](/README_zh-TW.md)
+## 🚀 介绍

-## 介绍
+Gopeed（全称 **Go Speed**，也叫“够快下载器”）是一款使用 Go 和 Flutter 开发的高速、现代、免费开源下载器，支持 HTTP、HTTPS、BitTorrent、磁力链接和 ed2k，并覆盖桌面端、移动端与 Web。

-Gopeed（全称 Go Speed），直译过来中文名叫做`够快下载器`（不是狗屁下载器！），是一款由`Golang`+`Flutter`开发的高速下载器，支持（HTTP、BitTorrent、Magnet）协议下载，并且支持全平台使用。除了基本的下载功能外，Gopeed 还是一款高度可定制化的下载器，支持通过对接[APIs](https://docs.gopeed.com/zh/dev-api.html)或者安装和开发[扩展](https://docs.gopeed.com/zh/dev-extension.html)来实现更多的功能。
+除了日常下载任务管理，Gopeed 还提供浏览器接管、JavaScript 扩展、REST API、命令行工具和可自托管 Web UI，方便高级用户扩展和自动化自己的下载流程。

-访问 ✈ [官方网站](https://gopeed.com/zh-CN) | 📖 [官方文档](https://docs.gopeed.com/zh/)
+访问 ✈ [官方网站](https://gopeed.com)

-## 安装
+![应用截图](_docs/img/ui-concept-zh-CN.png)

-**已支持平台**
+## ✨ 主要特性

- [x] windows
- [x] macos
- [x] linux
- [x] android
- [x] ios
- [x] web
- [x] docker
+- ⚡ **高速下载** — 多任务并发、HTTP 多连接分段传输和 BitTorrent P2P 下载，充分利用可用带宽。
+- 🧲 **多协议支持** — 在同一个界面管理 HTTP、HTTPS、BitTorrent、磁力链接和 ed2k。
+- 🌱 **完整 BT 能力** — 支持 DHT 节点发现、uTP 传输、Web Seed、按文件选择下载、Tracker 管理、Peer/分片统计，以及按分享率或时间控制做种。
+- 📋 **实用任务管理** — 暂停、续传、重试、批量操作、搜索、状态筛选、下载分类和启动恢复。
+- 🪶 **轻量原生体验** — 主界面使用 Flutter 原生渲染，非 Electron，非 WebView 的套壳，安装包更轻量、运行开销更低、响应更流畅。
+- 💻 **全平台覆盖** — 支持 Windows、macOS、Linux、Android、iOS 和 Web，并提供 Docker、QNAP 部署方式。
+- 🎨 **个性化主题** — 支持跟随系统、浅色、深色三种模式，以及 8 种主题强调色。
+- 📐 **响应式界面** — 任务列表、导航、设置和详情视图会针对手机、平板及可调整大小的桌面窗口自动布局。
+- 🗣️ **20+ 种界面语言** — 支持简体中文、繁体中文、英语、日语、韩语等多种语言。
+- 🌐 **浏览器接管** — 支持 Chrome、Edge、Firefox 等兼容浏览器，将下载任务直接发送到 Gopeed。
+- 🧩 **JavaScript 扩展** — 扩展视频网站、AI 模型站、网盘等更多下载源。
+- 🤖 **AI 接入** — 开放 MCP 接口，可接入 AI Agent，通过自然语言创建、查询和管理下载任务。
+- 🔌 **开放接口** — 通过 REST API、CLI、带身份认证的 Web UI、Webhook 和下载后脚本进行自动化。
+- 🛠️ **常用内置能力** — 自定义 Header 与 User-Agent、代理、GitHub 镜像、通知和自动解压。

-[前往下载](https://github.com/GopeedLab/gopeed/releases/latest)
+## 🤖 AI 接入

-> 注：macos 版本运行如果提示损坏，请在终端执行 `xattr -d com.apple.quarantine /Applications/Gopeed.app` 命令
+将 Gopeed 接入 AI Agent 后，即可通过自然语言管理下载。例如，直接对 AI Agent 说：

-### 命令行工具
+> 帮我下载最新的 Gopeed Windows 客户端
+
+| Tool | 功能说明 |
+| --- | --- |
+| `resolve_task` | 解析下载 URL 或 URI，在创建任务前返回资源信息及文件列表。 |
+| `create_task` | 使用已解析的资源 ID 或直接下载请求创建并启动任务。 |
+| `list_tasks` | 查询任务列表，并可按任务 ID 或状态筛选。 |
+| `get_task` | 获取单个任务的请求、资源、选项及当前进度等完整信息。 |
+| `get_task_status` | 获取单个任务的轻量运行状态和各文件下载进度。 |
+| `get_task_stats` | 获取协议相关统计信息，包括 HTTP 连接或 BitTorrent Peer 与做种数据。 |
+| `pause_task` | 暂停任务。 |
+| `continue_task` | 继续已暂停或失败的任务。 |
+| `delete_task` | 删除任务，并可选择同时删除已下载文件。 |
+
+## ⬇️ 下载
+
+### 🧪 Gopeed 2.0.0 Beta
+
+Gopeed 2.0.0 目前处于公开 Beta 测试阶段，引入了全新界面、通过 FFI 直连 Go 核心的原生通信架构、更一致的跨平台体验、更完善的任务管理、更灵活的 API，以及用于 AI Agent 接入的 MCP 能力。部分功能仍可能不够完善或稳定，欢迎提前体验并向我们反馈问题。
+
+- [下载 Gopeed 2.0.0 Beta 2](https://github.com/GopeedLab/gopeed/releases/tag/v2.0.0-beta.2)
+
+当功能完整度和稳定性达到正式发布标准后，我们会发布 Gopeed 2.0.0 正式版。已安装 Beta 版本的用户可以直接升级到最终正式版，现有稳定版用户则不会被自动切换到 Beta 渠道。
+
+### 正式稳定版
+
+- [官方网站下载](https://gopeed.com)
+- [GitHub Releases](https://github.com/GopeedLab/gopeed/releases/latest)
+
+### 🛠️ 命令行工具

 使用`go install`安装：

@@ -41,56 +80,42 @@ Gopeed（全称 Go Speed），直译过来中文名叫做`够快下载器`（不
 go install github.com/GopeedLab/gopeed/cmd/gopeed@latest
 ```

-### Docker
+## 🔌 浏览器扩展

-#### 直接运行
+Gopeed 还提供了浏览器扩展用于接管浏览器下载，支持 Chrome、Edge、Firefox 等浏览器，具体请参考：[https://github.com/GopeedLab/browser-extension](https://github.com/GopeedLab/browser-extension)

-```bash
-docker run -d -p 9999:9999 -v /path/to/download:/root/Downloads -v /path/to/storage:/app/storage liwei2633/gopeed
-```
+## 📱 微信公众号

-[更多关于 Docker 的使用](https://docs.gopeed.com/zh/install.html#docker-%E5%AE%89%E8%A3%85)
+关注公众号获取项目最新动态和资讯。

-#### 使用 Docker Compose
+<img src="_docs/img/weixin.png" width="200" />

-```bash
-docker-compose up -d
-```
+## 💝 赞助

-#### 访问服务
+如果觉得项目对你有帮助，请考虑[赞助](https://gopeed.com/docs/donate)以支持这个项目的发展，非常感谢！

-当 docker 容器运行时，可以通过 `http://localhost:9999` 访问 web 页面。
-
-## 赞助
-
-如果觉得项目对你有帮助，请考虑[赞助](https://docs.gopeed.com/zh/donate)以支持这个项目的发展，非常感谢！
-
-## 界面展示
-
-![](_docs/img/ui-demo.png)
-
-## 开发
+## 👨‍💻 开发

 本项目分为前端和后端两个部分，前端使用`flutter`，后端使用`Golang`，两边通过`http`协议进行通讯，在 unix 系统下，使用的是`unix socket`，在 windows 系统下，使用的是`tcp`协议。

 > 前端代码位于`ui/flutter`目录下。

-### 环境要求
+### 🌍 环境要求

-1. Golang 1.19+
-2. Flutter 3.10+
+1. Golang 1.25+
+2. Flutter 3.41+

-### 克隆项目
+### 📋 克隆项目

 ```bash
 git clone [email protected]:GopeedLab/gopeed.git
 ```

-### 贡献代码
+### 🤝 贡献代码

 请参考[贡献指南](CONTRIBUTING_zh-CN.md)

-### 编译
+### 🏗️ 编译

 #### 桌面端

@@ -137,7 +162,7 @@ gomobile init
 - android

 ```bash
-gomobile bind -tags nosqlite -ldflags="-w -s" -o ui/flutter/android/app/libs/libgopeed.aar -target=android -androidapi 19 -javapkg=com.gopeed github.com/GopeedLab/gopeed/bind/mobile
+gomobile bind -tags nosqlite -ldflags="-w -s -checklinkname=0" -o ui/flutter/android/app/libs/libgopeed.aar -target=android -androidapi 21 -javapkg="com.gopeed" github.com/GopeedLab/gopeed/bind/mobile
 cd ui/flutter
 flutter build apk
 ```
@@ -163,7 +188,7 @@ cp -r ui/flutter/build/web cmd/web/dist
 go build -tags nosqlite,web -ldflags="-s -w" -o bin/ github.com/GopeedLab/gopeed/cmd/web
 ```

-## 感谢
+## ❤️ 感谢

 ### 贡献者

@@ -1,39 +1,78 @@
+# [![](_docs/img/banner.svg)](https://gopeed.com)
+
 [![Test Status](https://github.com/GopeedLab/gopeed/workflows/test/badge.svg)](https://github.com/GopeedLab/gopeed/actions?query=workflow%3Atest)
 [![Codecov](https://codecov.io/gh/GopeedLab/gopeed/branch/main/graph/badge.svg)](https://codecov.io/gh/GopeedLab/gopeed)
 [![Release](https://img.shields.io/github/release/GopeedLab/gopeed.svg)](https://github.com/GopeedLab/gopeed/releases)
 [![Download](https://img.shields.io/github/downloads/GopeedLab/gopeed/total.svg)](https://github.com/GopeedLab/gopeed/releases)
-[![Donate](https://img.shields.io/badge/%24-donate-ff69b4.svg)](https://docs.gopeed.com/donate.html)
+[![Donate](https://img.shields.io/badge/%24-donate-ff69b4.svg)](https://gopeed.com/docs/donate)
+[![WeChat](https://img.shields.io/badge/%E5%BE%AE%E4%BF%A1%E5%85%AC%E4%BC%97%E5%8F%B7-07C160?logo=wechat&logoColor=white)](https://raw.githubusercontent.com/GopeedLab/gopeed/main/_docs/img/weixin.png)
 [![Discord](https://img.shields.io/discord/1037992631881449472?label=Discord&logo=discord&style=social)](https://discord.gg/ZUJqJrwCGB)

-![](_docs/img/banner.png)
+<a href="https://trendshift.io/repositories/7953" target="_blank"><img src="https://trendshift.io/api/badge/repositories/7953" alt="GopeedLab%2Fgopeed | Trendshift" style="width: 250px; height: 55px;" width="250" height="55"/></a>

-[![ko-fi](https://ko-fi.com/img/githubbutton_sm.svg)](https://ko-fi.com/R6R6IJGN6)
+[English](/README.md) | [中文](/README_zh-CN.md) | [日本語](/README_ja-JP.md) | [正體中文](/README_zh-TW.md) | [Tiếng Việt](/README_vi-VN.md)

-[English](/README.md) | [中文](/README_zh-CN.md) | [日本語](/README_ja-JP.md) | [正體中文](/README_zh-TW.md)
+## 🚀 簡介

-## 簡介
+Gopeed（**Go Speed** 的縮寫）是一款以 Go 與 Flutter 開發的高速、現代化、免費開源下載器，支援 HTTP、HTTPS、BitTorrent、磁力連結與 ed2k，並涵蓋桌面、行動裝置及 Web。

-Gopeed（全稱 Go Speed），是一款使用`Golang`+`Flutter`編寫的高速下載軟體，支援（HTTP、BitTorrent、Magnet）協定，同時支援所有的平台。
+除了日常任務管理，Gopeed 也提供瀏覽器整合、JavaScript 擴充、REST API、命令列工具及可自行託管的 Web UI，方便進階使用者擴充與自動化下載流程。

-前往 ✈ [主頁](https://gopeed.com/zh-CN) | 📖 [文檔](https://docs.gopeed.com/zh/)
+瀏覽 ✈ [官方網站](https://gopeed.com)

-## 安裝
+![應用程式截圖](_docs/img/ui-concept-en.png)

-**已支援的平台**
+## ✨ 主要功能

- [x] Windows
- [x] MacOS
- [x] Linux
- [x] Android
- [x] iOS
- [x] Web
- [x] Docker
+- ⚡ **高速下載** — 多任務並行、HTTP 多連線分段傳輸與 BitTorrent P2P 下載，充分利用可用頻寬。
+- 🧲 **多協定支援** — 在同一介面管理 HTTP、HTTPS、BitTorrent、磁力連結與 ed2k。
+- 🌱 **完整 BT 功能** — 支援 DHT 節點探索、uTP 傳輸、Web Seed、逐檔選擇、Tracker 管理、Peer/分片統計，以及依分享率或時間控制做種。
+- 📋 **實用任務管理** — 暫停、續傳、重試、批次操作、搜尋、狀態篩選、分類及啟動恢復。
+- 🪶 **輕量原生體驗** — 主介面使用 Flutter 原生渲染，非 Electron，非 WebView 套殼，安裝包更輕量、執行開銷更低、操作回應更流暢。
+- 💻 **跨平台** — 支援 Windows、macOS、Linux、Android、iOS、Web、Docker 與 QNAP。
+- 🎨 **個人化主題** — 支援跟隨系統、淺色、深色模式及 8 種主題強調色。
+- 📐 **響應式介面** — 任務列表、導覽、設定與詳細資訊會配合手機、平板及可調整大小的桌面視窗自動配置。
+- 🗣️ **20+ 種介面語言** — 支援繁體中文、簡體中文、英文、日文、韓文等多種語言。
+- 🌐 **瀏覽器整合** — 可接管 Chrome、Edge、Firefox 等相容瀏覽器的下載。
+- 🧩 **JavaScript 擴充** — 新增影音網站、AI 模型平台、雲端儲存等下載來源。
+- 🤖 **AI 整合** — 提供 MCP 介面，可串接相容的 AI Agent，以自然語言建立、查詢及管理下載任務。
+- 🔌 **開放介面** — 支援 REST API、CLI、認證 Web UI、Webhook 及下載後腳本。
+- 🛠️ **實用內建能力** — 自訂 Header/User-Agent、Proxy、GitHub 鏡像、通知及自動解壓縮。

-[下載](https://github.com/GopeedLab/gopeed/releases/latest)
+## 🤖 AI 整合

-> 註：MacOS 版運行時若提示損壞，請在終端中執行 `xattr -d com.apple.quarantine /Applications/Gopeed.app`
+將 Gopeed 與 AI Agent 串接後，即可透過自然語言管理下載。例如，直接對 AI Agent 說：

-### 使用CLI安裝
+> 幫我下載最新的 Gopeed Windows 用戶端
+
+| Tool | 功能說明 |
+| --- | --- |
+| `resolve_task` | 解析下載 URL 或 URI，在建立任務前回傳資源資訊及檔案清單。 |
+| `create_task` | 使用已解析的資源 ID 或直接下載請求建立並啟動任務。 |
+| `list_tasks` | 查詢任務清單，並可依任務 ID 或狀態篩選。 |
+| `get_task` | 取得單一任務的請求、資源、選項及目前進度等完整資訊。 |
+| `get_task_status` | 取得單一任務的簡要執行狀態及各檔案下載進度。 |
+| `get_task_stats` | 取得協定相關統計資訊，包括 HTTP 連線或 BitTorrent Peer 與做種資料。 |
+| `pause_task` | 暫停任務。 |
+| `continue_task` | 繼續已暫停或失敗的任務。 |
+| `delete_task` | 刪除任務，並可選擇同時刪除已下載檔案。 |
+
+## ⬇️ 下載
+
+### 🧪 Gopeed 2.0.0 Beta
+
+Gopeed 2.0.0 目前處於公開 Beta 測試階段，引入了全新介面、透過 FFI 直連 Go 核心的原生通訊架構、更一致的跨平台體驗、更完善的任務管理、更靈活的 API，以及透過 MCP 串接 AI Agent 的能力。部分功能仍可能不夠完善或穩定，歡迎搶先體驗並向我們回報問題。
+
+- [下載 Gopeed 2.0.0 Beta 2](https://github.com/GopeedLab/gopeed/releases/tag/v2.0.0-beta.2)
+
+當功能完整度與穩定性達到正式發布標準後，我們會發布 Gopeed 2.0.0 正式版。已安裝 Beta 版本的使用者可以直接升級至最終正式版，現有穩定版使用者則不會被自動切換至 Beta 頻道。
+
+### 正式穩定版
+
+- [官方網站下載](https://gopeed.com)
+- [GitHub Releases](https://github.com/GopeedLab/gopeed/releases/latest)
+
+### 🛠️ 使用 CLI 安裝

 使用`go install`安裝：

@@ -41,56 +80,38 @@ Gopeed（全稱 Go Speed），是一款使用`Golang`+`Flutter`編寫的高速
 go install github.com/GopeedLab/gopeed/cmd/gopeed@latest
 ```

-### Docker
+## 📱 微信公眾號

-#### 直接執行
+關注公眾號獲取項目最新動態和資訊。

-```bash
-docker run -d -p 9999:9999 -v /path/to/download:/root/Downloads -v /path/to/storage:/app/storage liwei2633/gopeed
-```
+<img src="_docs/img/weixin.png" width="200" />

-[更多關於 Docker 的使用](https://docs.gopeed.com/zh/install.html#docker-%E5%AE%89%E8%A3%85)
+## 💝 贊助

-#### 使用 Docker Compose
+如果你認為該項目對你有所幫助，請考慮[贊助](https://gopeed.com/docs/donate)以支持該項目的持續發展，謝謝！

-```bash
-docker-compose up -d
-```
-
-#### 訪問服務
-
-當 docker 容器運作時，可以通過 `http://localhost:9999` 訪問 web 頁面。
-
-## 贊助
-
-如果你認為該項目對你有所幫助，請考慮[贊助](https://docs.gopeed.com/zh/donate)以支持該項目的持續發展，謝謝！
-
-## 軟體介面
-
-![](_docs/img/ui-demo.png)
-
-## 開發
+## 👨‍💻 開發

 該項目分為前端與後端，前端使用`flutter`編寫，後端使用`Golang`編寫，兩邊通過`http`協定進行通訊，在 unix 系統下，則使用`unix socket`，在 windows 系統下，則使用`tcp`協定。

 > 前端代碼位於`ui/flutter`目錄內。

-### 開發環境
+### 🌍 開發環境

-1. Golang 1.19+
-2. Flutter 3.10+
+1. Golang 1.25+
+2. Flutter 3.41+

-### 克隆項目
+### 📋 克隆項目

 ```bash
 git clone [email protected]:GopeedLab/gopeed.git
 ```

-### 協助開發
+### 🤝 協助開發

 請參考[協助指南](CONTRIBUTING_zh-TW.md)

-### 編譯
+### 🏗️ 編譯

 #### 桌面端

@@ -137,7 +158,7 @@ gomobile init
 - android

 ```bash
-gomobile bind -tags nosqlite -ldflags="-w -s" -o ui/flutter/android/app/libs/libgopeed.aar -target=android -androidapi 19 -javapkg=com.gopeed github.com/GopeedLab/gopeed/bind/mobile
+gomobile bind -tags nosqlite -ldflags="-w -s -checklinkname=0" -o ui/flutter/android/app/libs/libgopeed.aar -target=android -androidapi 21 -javapkg="com.gopeed" github.com/GopeedLab/gopeed/bind/mobile
 cd ui/flutter
 flutter build apk
 ```
@@ -163,7 +184,7 @@ cp -r ui/flutter/build/web cmd/web/dist
 go build -tags nosqlite,web -ldflags="-s -w" -o bin/ github.com/GopeedLab/gopeed/cmd/web
 ```

-## 感謝
+## ❤️ 感謝

 ### 貢獻者

@@ -0,0 +1,54 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1200 400" width="1200" height="400">
+  <rect width="1200" height="400" fill="#040605"/>
+  <g fill="#5dc76c">
+    <rect x="-100" y="50" width="150" height="2" opacity="0.6">
+      <animate attributeName="x" from="-200" to="1300" dur="0.8s" repeatCount="indefinite"/>
+    </rect>
+    <rect x="-200" y="150" width="200" height="1" opacity="0.4">
+      <animate attributeName="x" from="-300" to="1300" dur="1.2s" repeatCount="indefinite"/>
+    </rect>
+    <rect x="-50" y="250" width="180" height="3" opacity="0.8">
+      <animate attributeName="x" from="-200" to="1300" dur="0.6s" repeatCount="indefinite"/>
+    </rect>
+    <rect x="-150" y="350" width="220" height="2" opacity="0.5">
+      <animate attributeName="x" from="-300" to="1300" dur="1s" repeatCount="indefinite"/>
+    </rect>
+    <rect x="-100" y="100" width="100" height="1" opacity="0.7">
+      <animate attributeName="x" from="-150" to="1300" dur="0.9s" repeatCount="indefinite"/>
+    </rect>
+    <rect x="-250" y="300" width="250" height="2" opacity="0.3">
+      <animate attributeName="x" from="-400" to="1300" dur="1.5s" repeatCount="indefinite"/>
+    </rect>
+  </g>
+  <defs>
+    <filter id="logoGlow" x="-50%" y="-50%" width="200%" height="200%">
+      <feGaussianBlur stdDeviation="12" result="blur" />
+      <feComposite in="SourceGraphic" in2="blur" operator="over" />
+    </filter>
+  </defs>
+  <g transform="translate(600, 160)">
+    <!-- Floating animation -->
+    <g>
+      <animateTransform attributeName="transform" type="translate" values="0,-8; 0,8; 0,-8" dur="3s" repeatCount="indefinite" />
+      
+      <!-- Pulsing glow behind logo -->
+      <circle cx="0" cy="0" r="45" fill="#5dc76c" filter="url(#logoGlow)" opacity="0.3">
+        <animate attributeName="opacity" values="0.1; 0.6; 0.1" dur="2s" repeatCount="indefinite" />
+        <animate attributeName="r" values="40; 65; 40" dur="2s" repeatCount="indefinite" />
+      </circle>
+
+      <!-- Breathing scale animation -->
+      <g>
+        <animateTransform attributeName="transform" type="scale" values="0.95; 1.05; 0.95" dur="2s" repeatCount="indefinite" />
+        <g transform="scale(0.12) translate(-512, -512)">
+          <path style="opacity:0.998" fill="#5dc76c" d="M 951.5,763.5 C 940.739,755.276 929.405,747.776 917.5,741C 908.477,736.319 899.143,732.485 889.5,729.5C 885.844,625.779 840.844,545.613 754.5,489C 674.802,441.453 590.135,430.12 500.5,455C 419.755,480.605 359.588,530.771 320,605.5C 278.585,565.816 230.752,555.649 176.5,575C 131.948,594.935 106.448,629.102 100,677.5C 99.3333,685.833 99.3333,694.167 100,702.5C 102.081,714.824 105.081,726.824 109,738.5C 95.4882,745.492 82.9882,753.826 71.5,763.5C 37.7121,705.639 16.5454,643.306 8,576.5C -9.41698,416.759 35.9164,278.093 144,160.5C 244.661,58.2827 367.161,5.94939 511.5,3.5C 678.975,7.48829 814.142,74.8216 917,205.5C 1011.33,336.426 1040,480.759 1003,638.5C 991.564,682.671 974.397,724.337 951.5,763.5 Z"/>
+          <path style="opacity:0.999" fill="#fefefe" d="M 951.5,763.5 C 949.28,768.272 946.78,772.938 944,777.5C 938.305,786.913 932.138,795.913 925.5,804.5C 915.954,796.888 905.288,791.055 893.5,787C 878.282,782.958 863.115,778.791 848,774.5C 854.013,716.891 841.346,663.891 810,615.5C 768.341,553.228 711.174,512.395 638.5,493C 560.311,479.566 490.311,497.566 428.5,547C 411.963,560.536 397.13,575.703 384,592.5C 366.745,616.923 348.911,640.923 330.5,664.5C 310.135,651.302 290.469,637.135 271.5,622C 238.448,602.307 206.782,604.307 176.5,628C 159.375,642.752 148.875,661.252 145,683.5C 143.968,692.716 144.968,701.716 148,710.5C 154.334,725.339 160.167,740.339 165.5,755.5C 138.118,764.688 114.451,779.688 94.5,800.5C 85.653,788.968 77.9863,776.635 71.5,763.5C 82.9882,753.826 95.4882,745.492 109,738.5C 105.081,726.824 102.081,714.824 100,702.5C 99.3333,694.167 99.3333,685.833 100,677.5C 106.448,629.102 131.948,594.935 176.5,575C 230.752,555.649 278.585,565.816 320,605.5C 359.588,530.771 419.755,480.605 500.5,455C 590.135,430.12 674.802,441.453 754.5,489C 840.844,545.613 885.844,625.779 889.5,729.5C 899.143,732.485 908.477,736.319 917.5,741C 929.405,747.776 940.739,755.276 951.5,763.5 Z"/>
+          <path style="opacity:0.998" fill="#5dc76c" d="M 925.5,804.5 C 850.791,908.608 750.791,975.775 625.5,1006C 609.308,1009.7 592.975,1012.53 576.5,1014.5C 615.708,969.938 655.042,925.438 694.5,881C 664.168,880.5 633.835,880.333 603.5,880.5C 603.5,811.167 603.5,741.833 603.5,672.5C 542.167,672.5 480.833,672.5 419.5,672.5C 419.5,741.5 419.5,810.5 419.5,879.5C 388.493,879.167 357.493,879.5 326.5,880.5C 326.624,881.107 326.957,881.44 327.5,881.5C 366.805,925.808 406.138,970.141 445.5,1014.5C 318.63,996.317 212.796,939.651 128,844.5C 115.85,830.525 104.683,815.859 94.5,800.5C 114.451,779.688 138.118,764.688 165.5,755.5C 160.167,740.339 154.334,725.339 148,710.5C 144.968,701.716 143.968,692.716 145,683.5C 148.875,661.252 159.375,642.752 176.5,628C 206.782,604.307 238.448,602.307 271.5,622C 290.469,637.135 310.135,651.302 330.5,664.5C 348.911,640.923 366.745,616.923 384,592.5C 397.13,575.703 411.963,560.536 428.5,547C 490.311,497.566 560.311,479.566 638.5,493C 711.174,512.395 768.341,553.228 810,615.5C 841.346,663.891 854.013,716.891 848,774.5C 863.115,778.791 878.282,782.958 893.5,787C 905.288,791.055 915.954,796.888 925.5,804.5 Z"/>
+          <path style="opacity:0.999" fill="#fefefe" d="M 576.5,1014.5 C 532.836,1019.82 489.169,1019.82 445.5,1014.5C 406.138,970.141 366.805,925.808 327.5,881.5C 358.167,880.833 388.833,880.167 419.5,879.5C 419.5,810.5 419.5,741.5 419.5,672.5C 480.833,672.5 542.167,672.5 603.5,672.5C 603.5,741.833 603.5,811.167 603.5,880.5C 633.835,880.333 664.168,880.5 694.5,881C 655.042,925.438 615.708,969.938 576.5,1014.5 Z"/>
+          <path style="opacity:1" fill="#ade2b5" d="M 419.5,879.5 C 388.833,880.167 358.167,880.833 327.5,881.5C 326.957,881.44 326.624,881.107 326.5,880.5C 357.493,879.5 388.493,879.167 419.5,879.5 Z"/>
+        </g>
+      </g>
+    </g>
+  </g>
+  <text x="600" y="300" font-family="sans-serif" font-size="72" font-style="italic" font-weight="900" text-anchor="middle" fill="#fff" letter-spacing="8">GOPEED</text>
+</svg>
@@ -2,6 +2,7 @@ package main

 import (
 	"fmt"
+
 	"github.com/GopeedLab/gopeed/pkg/base"
 	"github.com/GopeedLab/gopeed/pkg/download"
 	"github.com/GopeedLab/gopeed/pkg/protocol/http"
@@ -1,8 +1,28 @@
 package main

+/*
+#include <stdlib.h>
+#include <stdint.h>
+
+typedef void (*TaskEventCallback)(char* payload);
+
+typedef void (*InvokeResultCallback)(uint64_t request_id, int success, char* payload);
+
+static void callTaskEventCallback(uintptr_t callback, char* payload) {
+	((TaskEventCallback)callback)(payload);
+}
+
+static void callInvokeResultCallback(uintptr_t callback, uint64_t request_id, int success, char* payload) {
+	((InvokeResultCallback)callback)(request_id, success, payload);
+}
+*/
 import "C"
 import (
 	"encoding/json"
+	"fmt"
+	"unsafe"
+
+	nativebridge "github.com/GopeedLab/gopeed/bind/native"
 	"github.com/GopeedLab/gopeed/pkg/rest"
 	"github.com/GopeedLab/gopeed/pkg/rest/model"
 )
@@ -16,14 +36,104 @@ func Start(cfg *C.char) (int, *C.char) {
 		return 0, C.CString(err.Error())
 	}
 	config.ProductionMode = true
+	config.NativeMode = true
+	applyWebViewProvider(&config)
 	realPort, err := rest.Start(&config)
 	if err != nil {
 		return 0, C.CString(err.Error())
 	}
+	nativebridge.ResumeInvokes()
 	return realPort, nil
 }

 //export Stop
 func Stop() {
-	rest.Stop()
+	nativebridge.Stop()
+}
+
+//export GetAPIServerState
+func GetAPIServerState() *C.char {
+	return C.CString(apiServerResult(rest.GetAPIServerState()))
+}
+
+//export StartAPIServer
+func StartAPIServer() *C.char {
+	return C.CString(apiServerResult(rest.StartAPIServer()))
+}
+
+//export StopAPIServer
+func StopAPIServer() *C.char {
+	return C.CString(apiServerResult(rest.StopAPIServer()))
+}
+
+//export RestartAPIServer
+func RestartAPIServer() *C.char {
+	return C.CString(apiServerResult(rest.RestartAPIServer()))
+}
+
+func apiServerResult(state *model.APIServerState, err error) string {
+	result := &model.APIServerOperationResult{State: state}
+	if err != nil {
+		result.Error = err.Error()
+	}
+	data, marshalErr := json.Marshal(result)
+	if marshalErr != nil {
+		return fmt.Sprintf(`{"state":null,"error":%q}`, marshalErr.Error())
+	}
+	return string(data)
+}
+
+//export InvokeAsync
+func InvokeAsync(
+	method *C.char,
+	path *C.char,
+	query *C.char,
+	body *C.char,
+	requestID C.ulonglong,
+	callback C.uintptr_t,
+) {
+	if callback == 0 {
+		return
+	}
+	complete := func(result string, err error) {
+		success := C.int(1)
+		payload := result
+		if err != nil {
+			success = 0
+			payload = err.Error()
+		}
+		C.callInvokeResultCallback(
+			callback,
+			C.uint64_t(requestID),
+			success,
+			C.CString(payload),
+		)
+	}
+	nativebridge.InvokeAsync(
+		C.GoString(method),
+		C.GoString(path),
+		C.GoString(query),
+		C.GoString(body),
+		complete,
+	)
+}
+
+//export SubscribeTaskEvents
+func SubscribeTaskEvents(mask C.ulonglong, callback C.uintptr_t) {
+	if mask == 0 || callback == 0 {
+		rest.SubscribeTaskEvents(0, nil)
+		return
+	}
+	rest.SubscribeTaskEvents(uint64(mask), func(payload string) {
+		// Ownership crosses the asynchronous Dart callback boundary. Dart frees
+		// this string with FreeCString after decoding it.
+		C.callTaskEventCallback(callback, C.CString(payload))
+	})
+}
+
+//export FreeCString
+func FreeCString(value *C.char) {
+	if value != nil {
+		C.free(unsafe.Pointer(value))
+	}
 }
@@ -0,0 +1,23 @@
+//go:build darwin
+
+package main
+
+import (
+	"github.com/GopeedLab/gopeed/internal/webview/rpcprovider"
+	enginewebview "github.com/GopeedLab/gopeed/pkg/download/engine/webview"
+	"github.com/GopeedLab/gopeed/pkg/rest/model"
+)
+
+func applyWebViewProvider(config *model.StartConfig) {
+	if config == nil {
+		return
+	}
+	config.WebViewProvider = newDesktopWebViewProvider(config.WebViewRPCConfig)
+}
+
+func newDesktopWebViewProvider(rpcCfg *enginewebview.RPCConfig) enginewebview.Provider {
+	if rpcCfg != nil && rpcCfg.Enabled() {
+		return rpcprovider.New(*rpcCfg)
+	}
+	return enginewebview.NewUnavailableProvider()
+}
@@ -0,0 +1,15 @@
+//go:build !darwin
+
+package main
+
+import (
+	"github.com/GopeedLab/gopeed/internal/webview/goprovider"
+	"github.com/GopeedLab/gopeed/pkg/rest/model"
+)
+
+func applyWebViewProvider(config *model.StartConfig) {
+	if config == nil {
+		return
+	}
+	config.WebViewProvider = goprovider.New()
+}
@@ -4,6 +4,9 @@ package libgopeed
 import "C"
 import (
 	"encoding/json"
+
+	nativebridge "github.com/GopeedLab/gopeed/bind/native"
+	"github.com/GopeedLab/gopeed/internal/webview/rpcprovider"
 	"github.com/GopeedLab/gopeed/pkg/rest"
 	"github.com/GopeedLab/gopeed/pkg/rest/model"
 )
@@ -14,9 +17,76 @@ func Start(cfg string) (int, error) {
 		return 0, err
 	}
 	config.ProductionMode = true
-	return rest.Start(&config)
+	config.NativeMode = true
+	applyWebViewProvider(&config)
+	port, err := rest.Start(&config)
+	if err == nil {
+		nativebridge.ResumeInvokes()
+	}
+	return port, err
 }

 func Stop() {
-	rest.Stop()
+	nativebridge.Stop()
+}
+
+func GetAPIServerState() string {
+	return apiServerResult(rest.GetAPIServerState())
+}
+
+func StartAPIServer() string {
+	return apiServerResult(rest.StartAPIServer())
+}
+
+func StopAPIServer() string {
+	return apiServerResult(rest.StopAPIServer())
+}
+
+func RestartAPIServer() string {
+	return apiServerResult(rest.RestartAPIServer())
+}
+
+func apiServerResult(state *model.APIServerState, err error) string {
+	result := &model.APIServerOperationResult{State: state}
+	if err != nil {
+		result.Error = err.Error()
+	}
+	data, _ := json.Marshal(result)
+	return string(data)
+}
+
+type InvokeResultListener interface {
+	OnResult(requestID int64, success bool, payload string)
+}
+
+func InvokeAsync(method, path, query, body string, requestID int64, listener InvokeResultListener) {
+	if listener == nil {
+		return
+	}
+	nativebridge.InvokeAsync(method, path, query, body, func(result string, err error) {
+		if err != nil {
+			listener.OnResult(requestID, false, err.Error())
+			return
+		}
+		listener.OnResult(requestID, true, result)
+	})
+}
+
+type TaskEventListener interface {
+	OnTaskEvent(payload string)
+}
+
+func SubscribeTaskEvents(mask int64, listener TaskEventListener) {
+	if mask == 0 || listener == nil {
+		rest.SubscribeTaskEvents(0, nil)
+		return
+	}
+	rest.SubscribeTaskEvents(uint64(mask), listener.OnTaskEvent)
+}
+
+func applyWebViewProvider(config *model.StartConfig) {
+	if config == nil || config.WebViewRPCConfig == nil || !config.WebViewRPCConfig.Enabled() {
+		return
+	}
+	config.WebViewProvider = rpcprovider.New(*config.WebViewRPCConfig)
 }
@@ -0,0 +1,240 @@
+// Package nativebridge contains transport-neutral behavior shared by the
+// Desktop C FFI and gomobile bridge adapters.
+package nativebridge
+
+import (
+	"errors"
+	"fmt"
+	"sync"
+	"time"
+
+	"github.com/GopeedLab/gopeed/pkg/rest"
+)
+
+// StopTimeout bounds native shutdown even when an in-process request never returns.
+const StopTimeout = 3 * time.Second
+
+var errNativeBridgeStopping = errors.New("native bridge is stopping")
+
+type invokeRequest struct {
+	method string
+	path   string
+	query  string
+	body   string
+}
+
+type invokeTask struct {
+	id       uint64
+	request  invokeRequest
+	complete func(result string, err error)
+	once     sync.Once
+}
+
+func (t *invokeTask) finish(result string, err error) {
+	t.once.Do(func() {
+		completeCallback(t.complete, result, err)
+	})
+}
+
+// InvokeAsync starts an in-process API request and completes it through the
+// supplied callback. Desktop and mobile adapters share this executor.
+func InvokeAsync(method, path, query, body string, callback func(result string, err error)) {
+	if callback == nil {
+		return
+	}
+	task := invokeTask{
+		request: invokeRequest{
+			method: method,
+			path:   path,
+			query:  query,
+			body:   body,
+		},
+		complete: callback,
+	}
+	if !getInvokeExecutor().submit(task) {
+		completeCallback(callback, "", errNativeBridgeStopping)
+	}
+}
+
+// ResumeInvokes enables request submission after the native runtime starts.
+func ResumeInvokes() {
+	getInvokeExecutor().resume()
+}
+
+// PauseInvokesAndWait prevents new submissions and gives running requests a
+// bounded opportunity to finish before a native runtime is stopped.
+// Requests still pending after StopTimeout are failed and detached so shutdown
+// can continue without invoking their callbacks a second time.
+func PauseInvokesAndWait() bool {
+	return getInvokeExecutor().pauseAndWait(StopTimeout)
+}
+
+// Stop pauses native requests and shuts down the shared runtime, but never
+// keeps the host application waiting longer than StopTimeout. Cleanup that
+// cannot finish within the deadline is allowed to continue in the background.
+func Stop() {
+	stopWithin(getInvokeExecutor(), rest.Stop, StopTimeout)
+}
+
+func stopWithin(executor *invokeExecutor, cleanup func(), timeout time.Duration) {
+	deadline := time.Now().Add(timeout)
+	executor.pauseAndWait(time.Until(deadline))
+
+	stopped := make(chan struct{})
+	go func() {
+		defer close(stopped)
+		cleanup()
+	}()
+
+	remaining := time.Until(deadline)
+	if remaining <= 0 {
+		return
+	}
+	timer := time.NewTimer(remaining)
+	defer timer.Stop()
+	select {
+	case <-stopped:
+	case <-timer.C:
+	}
+}
+
+var (
+	invokeExecutorOnce sync.Once
+	sharedInvoker      *invokeExecutor
+)
+
+func getInvokeExecutor() *invokeExecutor {
+	invokeExecutorOnce.Do(func() {
+		sharedInvoker = newInvokeExecutor(func(request invokeRequest) string {
+			return rest.Dispatch(request.method, request.path, request.query, request.body)
+		})
+	})
+	return sharedInvoker
+}
+
+// invokeExecutor starts every native API request in its own goroutine, matching
+// net/http's request concurrency. It only tracks them to support bounded drain
+// during shutdown; one stuck request must never prevent another from starting.
+type invokeExecutor struct {
+	mu        sync.Mutex
+	closed    bool
+	accepting bool
+	nextID    uint64
+	pending   map[uint64]*invokeTask
+	drained   chan struct{}
+	running   sync.WaitGroup
+	handler   func(invokeRequest) string
+}
+
+func newInvokeExecutor(handler func(invokeRequest) string) *invokeExecutor {
+	drained := make(chan struct{})
+	close(drained)
+	return &invokeExecutor{
+		handler:   handler,
+		accepting: true,
+		pending:   make(map[uint64]*invokeTask),
+		drained:   drained,
+	}
+}
+
+func (e *invokeExecutor) submit(task invokeTask) bool {
+	e.mu.Lock()
+	if e.closed || !e.accepting {
+		e.mu.Unlock()
+		return false
+	}
+	if len(e.pending) == 0 {
+		e.drained = make(chan struct{})
+	}
+	taskID := e.nextID
+	e.nextID++
+	task.id = taskID
+	taskPtr := &task
+	e.pending[taskID] = taskPtr
+	e.running.Add(1)
+	e.mu.Unlock()
+
+	go e.run(taskPtr)
+	return true
+}
+
+func (e *invokeExecutor) resume() {
+	e.mu.Lock()
+	e.accepting = true
+	e.mu.Unlock()
+}
+
+func (e *invokeExecutor) pauseAndWait(timeout time.Duration) bool {
+	e.mu.Lock()
+	e.accepting = false
+	if len(e.pending) == 0 {
+		e.mu.Unlock()
+		return true
+	}
+	drained := e.drained
+	e.mu.Unlock()
+
+	timer := time.NewTimer(timeout)
+	defer timer.Stop()
+	select {
+	case <-drained:
+		return true
+	case <-timer.C:
+	}
+
+	e.mu.Lock()
+	if len(e.pending) == 0 {
+		e.mu.Unlock()
+		return true
+	}
+	pending := make([]*invokeTask, 0, len(e.pending))
+	for _, task := range e.pending {
+		pending = append(pending, task)
+	}
+	e.pending = make(map[uint64]*invokeTask)
+	close(e.drained)
+	e.mu.Unlock()
+
+	for _, task := range pending {
+		task.finish("", errNativeBridgeStopping)
+	}
+	return false
+}
+
+func (e *invokeExecutor) close() {
+	e.mu.Lock()
+	e.closed = true
+	e.accepting = false
+	e.mu.Unlock()
+	e.running.Wait()
+}
+
+func (e *invokeExecutor) run(task *invokeTask) {
+	defer e.running.Done()
+	result, err := e.execute(task.request)
+	task.finish(result, err)
+	e.mu.Lock()
+	if _, exists := e.pending[task.id]; exists {
+		delete(e.pending, task.id)
+		if len(e.pending) == 0 {
+			close(e.drained)
+		}
+	}
+	e.mu.Unlock()
+}
+
+func (e *invokeExecutor) execute(request invokeRequest) (result string, err error) {
+	defer func() {
+		if recovered := recover(); recovered != nil {
+			err = fmt.Errorf("invoke panic: %v", recovered)
+		}
+	}()
+	return e.handler(request), nil
+}
+
+func completeCallback(callback func(string, error), result string, err error) {
+	defer func() {
+		_ = recover()
+	}()
+	callback(result, err)
+}
@@ -0,0 +1,258 @@
+package nativebridge
+
+import (
+	"runtime"
+	"strconv"
+	"sync"
+	"testing"
+	"time"
+)
+
+func TestInvokeExecutorStartsEveryRequestIndependently(t *testing.T) {
+	const taskCount = 64
+	release := make(chan struct{})
+	started := make(chan struct{}, taskCount)
+	executor := newInvokeExecutor(func(request invokeRequest) string {
+		started <- struct{}{}
+		<-release
+		return request.path
+	})
+
+	var completed sync.WaitGroup
+	completed.Add(taskCount)
+	for i := range taskCount {
+		accepted := executor.submit(invokeTask{
+			request: invokeRequest{path: strconv.Itoa(i)},
+			complete: func(string, error) {
+				completed.Done()
+			},
+		})
+		if !accepted {
+			t.Fatalf("request %d was rejected", i)
+		}
+	}
+
+	// Every handler must start before any of them is released. A worker pool
+	// would stall here once all of its workers were occupied.
+	for range taskCount {
+		select {
+		case <-started:
+		case <-time.After(time.Second):
+			t.Fatal("a request waited behind other blocked requests")
+		}
+	}
+
+	close(release)
+	completed.Wait()
+	executor.close()
+}
+
+func TestInvokeExecutorConvertsPanicsToErrors(t *testing.T) {
+	executor := newInvokeExecutor(func(invokeRequest) string {
+		panic("boom")
+	})
+	completed := make(chan error, 1)
+	executor.submit(invokeTask{complete: func(_ string, err error) {
+		completed <- err
+	}})
+	select {
+	case err := <-completed:
+		if err == nil || err.Error() != "invoke panic: boom" {
+			t.Fatalf("unexpected error: %v", err)
+		}
+	case <-time.After(time.Second):
+		t.Fatal("panic result was not completed")
+	}
+	executor.close()
+}
+
+func TestInvokeExecutorSurvivesCallbackPanic(t *testing.T) {
+	executor := newInvokeExecutor(func(request invokeRequest) string {
+		return request.path
+	})
+	executor.submit(invokeTask{complete: func(string, error) {
+		panic("callback failed")
+	}})
+
+	completed := make(chan string, 1)
+	executor.submit(invokeTask{
+		request: invokeRequest{path: "next"},
+		complete: func(result string, _ error) {
+			completed <- result
+		},
+	})
+	select {
+	case result := <-completed:
+		if result != "next" {
+			t.Fatalf("unexpected result: %q", result)
+		}
+	case <-time.After(time.Second):
+		t.Fatal("worker stopped after callback panic")
+	}
+	executor.close()
+}
+
+func TestInvokeExecutorPausesAndDrains(t *testing.T) {
+	release := make(chan struct{})
+	started := make(chan struct{})
+	executor := newInvokeExecutor(func(request invokeRequest) string {
+		if request.path == "running" {
+			close(started)
+			<-release
+		}
+		return request.path
+	})
+	completed := make(chan struct{})
+	if !executor.submit(invokeTask{
+		request: invokeRequest{path: "running"},
+		complete: func(string, error) {
+			close(completed)
+		},
+	}) {
+		t.Fatal("initial task was rejected")
+	}
+	<-started
+
+	drained := make(chan struct{})
+	go func() {
+		executor.pauseAndWait(time.Second)
+		close(drained)
+	}()
+	deadline := time.Now().Add(time.Second)
+	for {
+		executor.mu.Lock()
+		paused := !executor.accepting
+		executor.mu.Unlock()
+		if paused {
+			break
+		}
+		if time.Now().After(deadline) {
+			t.Fatal("executor did not pause")
+		}
+		runtime.Gosched()
+	}
+	select {
+	case <-drained:
+		t.Fatal("pause returned before the running request completed")
+	default:
+	}
+	if executor.submit(invokeTask{}) {
+		t.Fatal("paused executor accepted a new request")
+	}
+
+	close(release)
+	<-completed
+	select {
+	case <-drained:
+	case <-time.After(time.Second):
+		t.Fatal("pause did not return after pending requests drained")
+	}
+
+	executor.resume()
+	resumed := make(chan struct{})
+	if !executor.submit(invokeTask{complete: func(string, error) {
+		close(resumed)
+	}}) {
+		t.Fatal("resumed executor rejected a request")
+	}
+	<-resumed
+	executor.close()
+}
+
+func TestInvokeExecutorPauseTimesOutAndFailsPendingRequests(t *testing.T) {
+	release := make(chan struct{})
+	started := make(chan struct{})
+	executor := newInvokeExecutor(func(request invokeRequest) string {
+		started <- struct{}{}
+		<-release
+		return request.path
+	})
+
+	errors := make(chan error, 2)
+	for _, path := range []string{"first", "second"} {
+		if !executor.submit(invokeTask{
+			request: invokeRequest{path: path},
+			complete: func(_ string, err error) {
+				errors <- err
+			},
+		}) {
+			t.Fatalf("request %q was rejected", path)
+		}
+	}
+	for range 2 {
+		<-started
+	}
+
+	const timeout = 30 * time.Millisecond
+	startedAt := time.Now()
+	if executor.pauseAndWait(timeout) {
+		t.Fatal("pause unexpectedly reported a complete drain")
+	}
+	if elapsed := time.Since(startedAt); elapsed < timeout || elapsed > 10*timeout {
+		t.Fatalf("pause returned after %s, want close to %s", elapsed, timeout)
+	}
+	for range 2 {
+		select {
+		case err := <-errors:
+			if err == nil || err.Error() != errNativeBridgeStopping.Error() {
+				t.Fatalf("unexpected timeout error: %v", err)
+			}
+		case <-time.After(time.Second):
+			t.Fatal("pending request was not failed after the timeout")
+		}
+	}
+
+	close(release)
+	executor.close()
+	select {
+	case err := <-errors:
+		t.Fatalf("request callback ran more than once: %v", err)
+	default:
+	}
+}
+
+func TestStopWithinUsesOneDeadlineForRequestsAndCleanup(t *testing.T) {
+	releaseRequest := make(chan struct{})
+	requestStarted := make(chan struct{})
+	executor := newInvokeExecutor(func(invokeRequest) string {
+		close(requestStarted)
+		<-releaseRequest
+		return "done"
+	})
+	requestResult := make(chan error, 1)
+	executor.submit(invokeTask{complete: func(_ string, err error) {
+		requestResult <- err
+	}})
+	<-requestStarted
+
+	releaseCleanup := make(chan struct{})
+	cleanupStarted := make(chan struct{})
+	cleanup := func() {
+		close(cleanupStarted)
+		<-releaseCleanup
+	}
+
+	const timeout = 40 * time.Millisecond
+	startedAt := time.Now()
+	stopWithin(executor, cleanup, timeout)
+	if elapsed := time.Since(startedAt); elapsed < timeout || elapsed > 10*timeout {
+		t.Fatalf("stop returned after %s, want close to %s", elapsed, timeout)
+	}
+	select {
+	case <-cleanupStarted:
+	case <-time.After(time.Second):
+		t.Fatal("cleanup was not started after the request deadline")
+	}
+	select {
+	case err := <-requestResult:
+		if err == nil || err.Error() != errNativeBridgeStopping.Error() {
+			t.Fatalf("unexpected request result: %v", err)
+		}
+	case <-time.After(time.Second):
+		t.Fatal("timed-out request was not failed")
+	}
+
+	close(releaseRequest)
+	close(releaseCleanup)
+	executor.close()
+}
@@ -0,0 +1,723 @@
+package main
+
+import (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/GopeedLab/gopeed/internal/webview/goprovider"
+	"github.com/GopeedLab/gopeed/internal/webview/rpcprovider"
+	"github.com/GopeedLab/gopeed/pkg/base"
+	"github.com/GopeedLab/gopeed/pkg/download"
+	enginewebview "github.com/GopeedLab/gopeed/pkg/download/engine/webview"
+)
+
+type kvFlag map[string]string
+
+type webViewConfig struct {
+	provider string
+	network  string
+	address  string
+	token    string
+}
+
+func (l *kvFlag) String() string {
+	if l == nil {
+		return ""
+	}
+	data, _ := json.Marshal(map[string]string(*l))
+	return string(data)
+}
+
+func (l *kvFlag) Set(value string) error {
+	if *l == nil {
+		*l = make(map[string]string)
+	}
+	idx := -1
+	for i := 0; i < len(value); i++ {
+		if value[i] == '=' {
+			idx = i
+			break
+		}
+	}
+	if idx <= 0 {
+		return fmt.Errorf("invalid label %q, expected key=value", value)
+	}
+	(*l)[value[:idx]] = value[idx+1:]
+	return nil
+}
+
+func main() {
+	os.Exit(goprovider.RunMainThreadLoop(run))
+}
+
+func run() int {
+	if len(os.Args) < 2 {
+		usage()
+		return 2
+	}
+
+	switch os.Args[1] {
+	case "resolve":
+		if err := runResolve(os.Args[2:]); err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			return 1
+		}
+	case "download":
+		if err := runDownload(os.Args[2:]); err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			return 1
+		}
+	case "eval":
+		if err := runEval(os.Args[2:]); err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			return 1
+		}
+	case "-h", "--help", "help":
+		usage()
+	default:
+		fmt.Fprintf(os.Stderr, "unknown subcommand %q\n", os.Args[1])
+		usage()
+		return 2
+	}
+	return 0
+}
+
+func usage() {
+	fmt.Fprintf(os.Stderr, `gopeed extmock CLI
+
+Usage:
+  extmock resolve [flags] <extension-dir> <url>
+  extmock download [flags] <extension-dir> <url> <output-dir>
+  extmock eval [flags] [script-file]
+
+Flags:
+  -label key=value   Request label, repeatable
+  -setting key=value Extension setting override, repeatable
+  -webview-provider  WebView provider: go|rpc
+  -webview-network   RPC network when provider=rpc: unix|tcp
+  -webview-address   RPC address when provider=rpc
+  -webview-token     RPC bearer token when provider=rpc
+  -verb              Print download progress while running
+  -pretty            Pretty-print JSON output
+
+Examples:
+  extmock resolve ./ https://www.google.com
+  extmock download ./ https://example.com/video /tmp/extmock-download
+  extmock resolve ./ https://example.com/video -label env=test -setting token=abc
+  extmock eval ./test.js
+  extmock eval -e "new Blob(['hello']).size"
+`)
+}
+
+func runResolve(args []string) error {
+	fs := flag.NewFlagSet("resolve", flag.ContinueOnError)
+	fs.SetOutput(os.Stderr)
+	var labels kvFlag
+	var settings kvFlag
+	var pretty bool
+	cfg := webViewConfig{}
+	fs.Var(&labels, "label", "Request label in key=value form (repeatable)")
+	fs.Var(&settings, "setting", "Extension setting override in key=value form (repeatable)")
+	fs.StringVar(&cfg.provider, "webview-provider", "", "WebView provider: go|rpc")
+	fs.StringVar(&cfg.network, "webview-network", "", "WebView RPC network: unix|tcp")
+	fs.StringVar(&cfg.address, "webview-address", "", "WebView RPC address")
+	fs.StringVar(&cfg.token, "webview-token", "", "WebView RPC bearer token")
+	fs.BoolVar(&pretty, "pretty", false, "Pretty-print JSON output")
+
+	flagArgs, positionalArgs, err := splitResolveArgs(args)
+	if err != nil {
+		return err
+	}
+	if err := fs.Parse(flagArgs); err != nil {
+		return err
+	}
+	if fs.NArg() != 0 {
+		return fmt.Errorf("unexpected trailing args: %v", fs.Args())
+	}
+	if len(positionalArgs) != 2 {
+		return fmt.Errorf("resolve expects exactly 2 args: <extension-dir> <url>")
+	}
+
+	extDir, err := filepath.Abs(positionalArgs[0])
+	if err != nil {
+		return err
+	}
+	url := positionalArgs[1]
+
+	d, cleanup, err := newExtMockDownloader(cfg)
+	if err != nil {
+		return err
+	}
+	defer cleanup()
+
+	ext, err := d.InstallExtensionByFolder(extDir, true)
+	if err != nil {
+		return err
+	}
+	if len(settings) > 0 {
+		if err := d.UpdateExtensionSettings(ext.Identity, toAnyMap(settings)); err != nil {
+			return err
+		}
+	}
+	result, err := d.Resolve(&base.Request{
+		URL:    url,
+		Labels: map[string]string(labels),
+	}, nil)
+	if err != nil {
+		return err
+	}
+	return printJSON(result, pretty)
+}
+
+type downloadResult struct {
+	Resolve   *download.ResolveResult `json:"resolve"`
+	OutputDir string                  `json:"outputDir"`
+	Files     []*downloadedFileResult `json:"files"`
+}
+
+type downloadedFileResult struct {
+	Index  int           `json:"index"`
+	Name   string        `json:"name"`
+	Path   string        `json:"path"`
+	TaskID string        `json:"taskId"`
+	Status base.Status   `json:"status"`
+	Size   int64         `json:"size"`
+	Req    *base.Request `json:"req,omitempty"`
+}
+
+func runDownload(args []string) error {
+	fs := flag.NewFlagSet("download", flag.ContinueOnError)
+	fs.SetOutput(os.Stderr)
+	var labels kvFlag
+	var settings kvFlag
+	var pretty bool
+	var verbose bool
+	cfg := webViewConfig{}
+	fs.Var(&labels, "label", "Request label in key=value form (repeatable)")
+	fs.Var(&settings, "setting", "Extension setting override in key=value form (repeatable)")
+	fs.StringVar(&cfg.provider, "webview-provider", "", "WebView provider: go|rpc")
+	fs.StringVar(&cfg.network, "webview-network", "", "WebView RPC network: unix|tcp")
+	fs.StringVar(&cfg.address, "webview-address", "", "WebView RPC address")
+	fs.StringVar(&cfg.token, "webview-token", "", "WebView RPC bearer token")
+	fs.BoolVar(&verbose, "verb", false, "Print download progress while running")
+	fs.BoolVar(&verbose, "verbose", false, "Print download progress while running")
+	fs.BoolVar(&pretty, "pretty", false, "Pretty-print JSON output")
+
+	flagArgs, positionalArgs, err := splitDownloadArgs(args)
+	if err != nil {
+		return err
+	}
+	if err := fs.Parse(flagArgs); err != nil {
+		return err
+	}
+	if fs.NArg() != 0 {
+		return fmt.Errorf("unexpected trailing args: %v", fs.Args())
+	}
+	if len(positionalArgs) != 3 {
+		return fmt.Errorf("download expects exactly 3 args: <extension-dir> <url> <output-dir>")
+	}
+
+	extDir, err := filepath.Abs(positionalArgs[0])
+	if err != nil {
+		return err
+	}
+	url := positionalArgs[1]
+	outputDir, err := filepath.Abs(positionalArgs[2])
+	if err != nil {
+		return err
+	}
+
+	d, cleanup, err := newExtMockDownloader(cfg)
+	if err != nil {
+		return err
+	}
+	defer cleanup()
+
+	ext, err := d.InstallExtensionByFolder(extDir, true)
+	if err != nil {
+		return err
+	}
+	if len(settings) > 0 {
+		if err := d.UpdateExtensionSettings(ext.Identity, toAnyMap(settings)); err != nil {
+			return err
+		}
+	}
+
+	result, err := d.Resolve(&base.Request{
+		URL:    url,
+		Labels: map[string]string(labels),
+	}, nil)
+	if err != nil {
+		return err
+	}
+	if result == nil || result.Res == nil {
+		return fmt.Errorf("resolve returned empty resource")
+	}
+	if len(result.Res.Files) == 0 {
+		return fmt.Errorf("resolve returned no files")
+	}
+
+	resourceOutputDir := outputDir
+	if result.Res.Name != "" {
+		resourceOutputDir = filepath.Join(outputDir, result.Res.Name)
+	}
+	if err := os.MkdirAll(resourceOutputDir, 0o755); err != nil {
+		return err
+	}
+
+	waiter := newTaskTerminalWaiter(d)
+	summary := &downloadResult{
+		Resolve:   result,
+		OutputDir: resourceOutputDir,
+		Files:     make([]*downloadedFileResult, 0, len(result.Res.Files)),
+	}
+
+	for idx, file := range result.Res.Files {
+		if file == nil {
+			return fmt.Errorf("file %d is nil", idx)
+		}
+		if file.Req == nil {
+			return fmt.Errorf("file %d request is nil", idx)
+		}
+
+		targetDir := resourceOutputDir
+		if file.Path != "" {
+			targetDir = filepath.Join(resourceOutputDir, file.Path)
+		}
+		if err := os.MkdirAll(targetDir, 0o755); err != nil {
+			return err
+		}
+
+		taskID, err := d.CreateDirect(file.Req, &base.Options{
+			Path: targetDir,
+			Name: file.Name,
+		})
+		if err != nil {
+			return fmt.Errorf("create task for %q failed: %w", file.Name, err)
+		}
+		waiter.Register(taskID)
+
+		summary.Files = append(summary.Files, &downloadedFileResult{
+			Index:  idx,
+			Name:   file.Name,
+			Path:   filepath.Join(targetDir, file.Name),
+			TaskID: taskID,
+			Req:    file.Req,
+		})
+	}
+
+	var stopVerbose func()
+	if verbose {
+		stopVerbose = startVerboseTaskListener(d, summary.Files)
+		defer stopVerbose()
+	}
+
+	for _, file := range summary.Files {
+		task, err := waiter.Wait(file.TaskID, 5*time.Minute)
+		if err != nil {
+			return fmt.Errorf("download %q failed: %w", file.Name, err)
+		}
+		file.Status = task.Status
+		if info, statErr := os.Stat(file.Path); statErr == nil {
+			file.Size = info.Size()
+		}
+	}
+
+	return printJSON(summary, pretty)
+}
+
+func runEval(args []string) error {
+	fs := flag.NewFlagSet("eval", flag.ContinueOnError)
+	fs.SetOutput(os.Stderr)
+	var (
+		script string
+		pretty bool
+	)
+	cfg := webViewConfig{}
+	fs.StringVar(&script, "e", "", "Inline JavaScript to execute")
+	fs.StringVar(&script, "eval", "", "Inline JavaScript to execute")
+	fs.StringVar(&cfg.provider, "webview-provider", "", "WebView provider: go|rpc")
+	fs.StringVar(&cfg.network, "webview-network", "", "WebView RPC network: unix|tcp")
+	fs.StringVar(&cfg.address, "webview-address", "", "WebView RPC address")
+	fs.StringVar(&cfg.token, "webview-token", "", "WebView RPC bearer token")
+	fs.BoolVar(&pretty, "pretty", false, "Pretty-print JSON output")
+
+	flagArgs, positionalArgs, err := splitEvalArgs(args)
+	if err != nil {
+		return err
+	}
+	if err := fs.Parse(flagArgs); err != nil {
+		return err
+	}
+	if fs.NArg() != 0 {
+		return fmt.Errorf("unexpected trailing args: %v", fs.Args())
+	}
+	if script == "" && len(positionalArgs) == 0 {
+		return fmt.Errorf("eval expects inline code via -e/--eval or a script file path")
+	}
+	if script != "" && len(positionalArgs) > 0 {
+		return fmt.Errorf("eval accepts either inline code or a script file path, not both")
+	}
+	if len(positionalArgs) > 1 {
+		return fmt.Errorf("eval expects at most 1 script file path")
+	}
+
+	d, cleanup, err := newExtMockDownloader(cfg)
+	if err != nil {
+		return err
+	}
+	defer cleanup()
+
+	runtime, err := d.NewExtensionEngine(newExtMockExtension(), map[string]any{})
+	if err != nil {
+		return err
+	}
+	defer runtime.Close()
+
+	var value any
+	if script != "" {
+		value, err = runtime.Eval(script)
+	} else {
+		scriptPath, pathErr := filepath.Abs(positionalArgs[0])
+		if pathErr != nil {
+			return pathErr
+		}
+		value, err = runtime.EvalFile(scriptPath)
+	}
+	if err != nil {
+		return err
+	}
+	return printJSON(value, pretty)
+}
+
+func splitResolveArgs(args []string) ([]string, []string, error) {
+	var flagArgs []string
+	var positionalArgs []string
+	for i := 0; i < len(args); i++ {
+		arg := args[i]
+		switch {
+		case arg == "-pretty":
+			flagArgs = append(flagArgs, arg)
+		case arg == "-webview-provider", arg == "-webview-network", arg == "-webview-address", arg == "-webview-token":
+			if i+1 >= len(args) {
+				return nil, nil, fmt.Errorf("flag %q requires a value", arg)
+			}
+			flagArgs = append(flagArgs, arg, args[i+1])
+			i++
+		case arg == "-label":
+			if i+1 >= len(args) {
+				return nil, nil, fmt.Errorf("flag %q requires a value", arg)
+			}
+			flagArgs = append(flagArgs, arg, args[i+1])
+			i++
+		case arg == "-setting":
+			if i+1 >= len(args) {
+				return nil, nil, fmt.Errorf("flag %q requires a value", arg)
+			}
+			flagArgs = append(flagArgs, arg, args[i+1])
+			i++
+		case len(arg) > len("-label=") && arg[:len("-label=")] == "-label=":
+			flagArgs = append(flagArgs, arg)
+		case len(arg) > len("-setting=") && arg[:len("-setting=")] == "-setting=":
+			flagArgs = append(flagArgs, arg)
+		case hasFlagValue(arg, "-webview-provider"), hasFlagValue(arg, "-webview-network"),
+			hasFlagValue(arg, "-webview-address"), hasFlagValue(arg, "-webview-token"):
+			flagArgs = append(flagArgs, arg)
+		case len(arg) > 0 && arg[0] == '-':
+			return nil, nil, fmt.Errorf("unknown flag %q", arg)
+		default:
+			positionalArgs = append(positionalArgs, arg)
+		}
+	}
+	return flagArgs, positionalArgs, nil
+}
+
+func splitDownloadArgs(args []string) ([]string, []string, error) {
+	var flagArgs []string
+	var positionalArgs []string
+	for i := 0; i < len(args); i++ {
+		arg := args[i]
+		switch {
+		case arg == "-pretty", arg == "-verb", arg == "-verbose":
+			flagArgs = append(flagArgs, arg)
+		case arg == "-webview-provider", arg == "-webview-network", arg == "-webview-address", arg == "-webview-token":
+			if i+1 >= len(args) {
+				return nil, nil, fmt.Errorf("flag %q requires a value", arg)
+			}
+			flagArgs = append(flagArgs, arg, args[i+1])
+			i++
+		case arg == "-label":
+			if i+1 >= len(args) {
+				return nil, nil, fmt.Errorf("flag %q requires a value", arg)
+			}
+			flagArgs = append(flagArgs, arg, args[i+1])
+			i++
+		case arg == "-setting":
+			if i+1 >= len(args) {
+				return nil, nil, fmt.Errorf("flag %q requires a value", arg)
+			}
+			flagArgs = append(flagArgs, arg, args[i+1])
+			i++
+		case len(arg) > len("-label=") && arg[:len("-label=")] == "-label=":
+			flagArgs = append(flagArgs, arg)
+		case len(arg) > len("-setting=") && arg[:len("-setting=")] == "-setting=":
+			flagArgs = append(flagArgs, arg)
+		case hasFlagValue(arg, "-webview-provider"), hasFlagValue(arg, "-webview-network"),
+			hasFlagValue(arg, "-webview-address"), hasFlagValue(arg, "-webview-token"):
+			flagArgs = append(flagArgs, arg)
+		case len(arg) > 0 && arg[0] == '-':
+			return nil, nil, fmt.Errorf("unknown flag %q", arg)
+		default:
+			positionalArgs = append(positionalArgs, arg)
+		}
+	}
+	return flagArgs, positionalArgs, nil
+}
+
+func splitEvalArgs(args []string) ([]string, []string, error) {
+	var flagArgs []string
+	var positionalArgs []string
+	for i := 0; i < len(args); i++ {
+		arg := args[i]
+		switch {
+		case arg == "-pretty":
+			flagArgs = append(flagArgs, arg)
+		case arg == "-webview-provider", arg == "-webview-network", arg == "-webview-address", arg == "-webview-token":
+			if i+1 >= len(args) {
+				return nil, nil, fmt.Errorf("flag %q requires a value", arg)
+			}
+			flagArgs = append(flagArgs, arg, args[i+1])
+			i++
+		case arg == "-e", arg == "--eval":
+			if i+1 >= len(args) {
+				return nil, nil, fmt.Errorf("flag %q requires a value", arg)
+			}
+			flagArgs = append(flagArgs, arg, args[i+1])
+			i++
+		case hasFlagValue(arg, "-e"), hasFlagValue(arg, "--eval"),
+			hasFlagValue(arg, "-webview-provider"), hasFlagValue(arg, "-webview-network"),
+			hasFlagValue(arg, "-webview-address"), hasFlagValue(arg, "-webview-token"):
+			flagArgs = append(flagArgs, arg)
+		case len(arg) > 0 && arg[0] == '-':
+			return nil, nil, fmt.Errorf("unknown flag %q", arg)
+		default:
+			positionalArgs = append(positionalArgs, arg)
+		}
+	}
+	return flagArgs, positionalArgs, nil
+}
+
+func hasFlagValue(arg string, prefix string) bool {
+	return len(arg) > len(prefix)+1 && arg[:len(prefix)+1] == prefix+"="
+}
+
+func toAnyMap(values kvFlag) map[string]any {
+	result := make(map[string]any, len(values))
+	for key, value := range values {
+		result[key] = value
+	}
+	return result
+}
+
+func newExtMockDownloader(cfg webViewConfig) (*download.Downloader, func(), error) {
+	webViewProvider, err := newExtMockWebViewProvider(cfg)
+	if err != nil {
+		return nil, nil, err
+	}
+	d := download.NewDownloader(&download.DownloaderConfig{
+		Storage:         download.NewMemStorage(),
+		WebViewProvider: webViewProvider,
+	})
+	if err := d.Setup(); err != nil {
+		return nil, nil, err
+	}
+	cleanup := func() {
+		_ = d.Clear()
+	}
+	return d, cleanup, nil
+}
+
+func newExtMockExtension() *download.Extension {
+	return &download.Extension{
+		Name:    "extmock",
+		Author:  "gopeed",
+		Title:   "Gopeed ExtMock Runtime",
+		Version: "0.0.0",
+		DevMode: true,
+	}
+}
+
+func newExtMockWebViewProvider(cfg webViewConfig) (enginewebview.Provider, error) {
+	switch cfg.provider {
+	case "", "go":
+		return goprovider.New(), nil
+	case "rpc":
+		rpcCfg, err := resolveRPCConfig(cfg)
+		if err != nil {
+			return nil, err
+		}
+		return rpcprovider.New(rpcCfg), nil
+	default:
+		return nil, fmt.Errorf("unsupported webview provider %q", cfg.provider)
+	}
+}
+
+func resolveRPCConfig(cfg webViewConfig) (enginewebview.RPCConfig, error) {
+	network := cfg.network
+	address := cfg.address
+	if network == "" && address == "" {
+		defaultAddress, err := defaultWebViewRPCUnixSocket()
+		if err != nil {
+			return enginewebview.RPCConfig{}, err
+		}
+		network = "unix"
+		address = defaultAddress
+	}
+	if network == "" || address == "" {
+		return enginewebview.RPCConfig{}, fmt.Errorf("webview rpc requires both network and address")
+	}
+	return enginewebview.RPCConfig{
+		Network: network,
+		Address: address,
+		Token:   cfg.token,
+	}, nil
+}
+
+func defaultWebViewRPCUnixSocket() (string, error) {
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		return "", err
+	}
+	return filepath.Join(homeDir, "gopeed_webview.sock"), nil
+}
+
+type taskTerminalWaiter struct {
+	downloader *download.Downloader
+}
+
+func newTaskTerminalWaiter(d *download.Downloader) *taskTerminalWaiter {
+	return &taskTerminalWaiter{downloader: d}
+}
+
+func (w *taskTerminalWaiter) Register(id string) {
+}
+
+func (w *taskTerminalWaiter) Wait(id string, timeout time.Duration) (*download.Task, error) {
+	deadline := time.Now().Add(timeout)
+	for time.Now().Before(deadline) {
+		if task, ok := w.currentTerminalTask(id); ok {
+			return task, w.taskError(task)
+		}
+		time.Sleep(50 * time.Millisecond)
+	}
+	return nil, fmt.Errorf("timeout waiting for task %s", id)
+}
+
+func (w *taskTerminalWaiter) currentTerminalTask(id string) (*download.Task, bool) {
+	task := w.downloader.GetTask(id)
+	if task == nil {
+		return nil, false
+	}
+	if task.Status != base.DownloadStatusDone && task.Status != base.DownloadStatusError {
+		return nil, false
+	}
+	return task, true
+}
+
+func (w *taskTerminalWaiter) taskError(task *download.Task) error {
+	if task == nil {
+		return fmt.Errorf("task is nil")
+	}
+	if task.Status == base.DownloadStatusError {
+		return fmt.Errorf("task %s finished with status %s", task.ID, task.Status)
+	}
+	return nil
+}
+
+func startVerboseTaskListener(d *download.Downloader, files []*downloadedFileResult) func() {
+	tracked := make(map[string]string, len(files))
+	for _, file := range files {
+		tracked[file.TaskID] = file.Name
+	}
+	d.Listener(func(event *download.Event) {
+		if event == nil || event.Task == nil {
+			return
+		}
+		name, ok := tracked[event.Task.ID]
+		if !ok {
+			return
+		}
+		switch event.Key {
+		case download.EventKeyStart, download.EventKeyProgress, download.EventKeyDone, download.EventKeyError:
+			printVerboseTaskEvent(event, name)
+		}
+	})
+	return func() {}
+}
+
+func printVerboseTaskEvent(event *download.Event, name string) {
+	task := event.Task
+	ts := time.Now().Format("15:04:05.000")
+	if task == nil {
+		return
+	}
+	total := int64(0)
+	if task.Meta != nil && task.Meta.Res != nil {
+		total = task.Meta.Res.Size
+	}
+	downloaded := int64(0)
+	speed := int64(0)
+	if task.Progress != nil {
+		downloaded = task.Progress.Downloaded
+		speed = task.Progress.Speed
+	}
+	if event.Key == download.EventKeyError && event.Err != nil {
+		fmt.Fprintf(
+			os.Stderr,
+			"[%s] event=%s task=%s status=%s downloaded=%d total=%d speed=%d name=%q err=%v\n",
+			ts,
+			event.Key,
+			task.ID,
+			task.Status,
+			downloaded,
+			total,
+			speed,
+			name,
+			event.Err,
+		)
+		return
+	}
+	fmt.Fprintf(
+		os.Stderr,
+		"[%s] event=%s task=%s status=%s downloaded=%d total=%d speed=%d name=%q\n",
+		ts,
+		event.Key,
+		task.ID,
+		task.Status,
+		downloaded,
+		total,
+		speed,
+		name,
+	)
+}
+
+func printJSON(v any, pretty bool) error {
+	var (
+		data []byte
+		err  error
+	)
+	if pretty {
+		data, err = json.MarshalIndent(v, "", "  ")
+	} else {
+		data, err = json.Marshal(v)
+	}
+	if err != nil {
+		return err
+	}
+	fmt.Println(string(data))
+	return nil
+}
@@ -2,13 +2,14 @@ package main

 import (
 	"fmt"
+	"strings"
+	"sync"
+
 	"github.com/GopeedLab/gopeed/internal/fetcher"
 	"github.com/GopeedLab/gopeed/pkg/base"
 	"github.com/GopeedLab/gopeed/pkg/download"
 	"github.com/GopeedLab/gopeed/pkg/protocol/http"
 	"github.com/GopeedLab/gopeed/pkg/util"
-	"strings"
-	"sync"
 )

 const progressWidth = 20
@@ -65,6 +66,9 @@ var (

 func printProgress(task *download.Task, title string) {
 	var rate float64
+	if task.Meta.Res == nil {
+		task = emptyTask
+	}
 	if task.Meta.Res.Size <= 0 {
 		rate = 0
 	} else {
@@ -0,0 +1,19 @@
+//go:build !windows
+// +build !windows
+
+package main
+
+import (
+	"net"
+	"os"
+	"path/filepath"
+)
+
+func Dial() (net.Conn, error) {
+	// Get binary path
+	exe, err := os.Executable()
+	if err != nil {
+		return nil, err
+	}
+	return net.Dial("unix", filepath.Join(filepath.Dir(exe), "gopeed_host.sock"))
+}
@@ -0,0 +1,11 @@
+package main
+
+import (
+	"net"
+
+	"github.com/Microsoft/go-winio"
+)
+
+func Dial() (net.Conn, error) {
+	return winio.DialPipe(`\\.\pipe\gopeed_host`, nil)
+}
@@ -0,0 +1,208 @@
+package main
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"os"
+	"time"
+
+	"github.com/pkg/browser"
+)
+
+type Message struct {
+	Method string          `json:"method"`
+	Meta   map[string]any  `json:"meta"`
+	Params json.RawMessage `json:"params"`
+}
+
+type Response struct {
+	Code    int    `json:"code"`
+	Data    any    `json:"data,omitempty"`
+	Message string `json:"message,omitempty"`
+}
+
+func check() (data bool, err error) {
+	conn, err := Dial()
+	if err != nil {
+		return false, err
+	}
+	defer conn.Close()
+	return true, nil
+}
+
+func wakeup(hidden bool) error {
+	running, _ := check()
+	if running {
+		return nil
+	}
+
+	uri := "gopeed:"
+	if hidden {
+		uri = uri + "?hidden=true"
+	}
+	if err := browser.OpenURL(uri); err != nil {
+		return err
+	}
+
+	for i := 0; i < 10; i++ {
+		if ok, _ := check(); ok {
+			return nil
+		}
+		time.Sleep(1 * time.Second)
+	}
+	return fmt.Errorf("start gopeed failed")
+}
+
+// postToFlutter sends a POST request to Flutter RPC server
+func postToFlutter(path string, body []byte, headers map[string]string, timeout time.Duration) (*http.Response, error) {
+	client := &http.Client{
+		Transport: &http.Transport{
+			DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
+				return Dial()
+			},
+		},
+		Timeout: timeout,
+	}
+	req, err := http.NewRequest("POST", "http://127.0.0.1"+path, bytes.NewBuffer(body))
+	if err != nil {
+		return nil, err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	for k, v := range headers {
+		req.Header.Set(k, v)
+	}
+	return client.Do(req)
+}
+
+var apiMap = map[string]func(message *Message) (data any, err error){
+	"ping": func(message *Message) (data any, err error) {
+		return check()
+	},
+	"wakeup": func(message *Message) (data any, err error) {
+		silent := false
+		if v, ok := message.Meta["silent"]; ok {
+			silent, _ = v.(bool)
+		}
+		err = wakeup(silent)
+		return
+	},
+	"create": func(message *Message) (data any, err error) {
+		buf, err := message.Params.MarshalJSON()
+		if err != nil {
+			return
+		}
+
+		// Task creation owns its presentation: silent requests stay in the
+		// background, while non-silent requests open a dedicated create window.
+		// Always bootstrap the main process hidden so it never flashes first.
+		if err := wakeup(true); err != nil {
+			return nil, err
+		}
+
+		headers := make(map[string]string)
+		if message.Meta != nil {
+			metaJson, _ := json.Marshal(message.Meta)
+			headers["X-Gopeed-Host-Meta"] = string(metaJson)
+		}
+		_, err = postToFlutter("/create", buf, headers, 10*time.Second)
+		return
+	},
+	"forward": func(message *Message) (data any, err error) {
+		buf, err := message.Params.MarshalJSON()
+		if err != nil {
+			return
+		}
+
+		resp, err := postToFlutter("/forward", buf, nil, 60*time.Second)
+		if err != nil {
+			return
+		}
+		defer resp.Body.Close()
+
+		respBody, err := io.ReadAll(resp.Body)
+		if err != nil {
+			return nil, err
+		}
+
+		var respData map[string]json.RawMessage
+		if err := json.Unmarshal(respBody, &respData); err != nil {
+			return nil, err
+		}
+		return respData, nil
+	},
+}
+
+// go build -ldflags="-s -w" -o ui/flutter/assets/exec/ github.com/GopeedLab/gopeed/cmd/host
+
+func main() {
+	for {
+		// Read message length (first 4 bytes)
+		var length uint32
+		if err := binary.Read(os.Stdin, binary.NativeEndian, &length); err != nil {
+			if err == io.EOF {
+				return
+			}
+			sendError("Failed to read message length: " + err.Error())
+			return
+		}
+
+		// Read the message
+		input := make([]byte, length)
+		if _, err := io.ReadFull(os.Stdin, input); err != nil {
+			sendError("Failed to read message: " + err.Error())
+			return
+		}
+
+		// Parse message
+		var message Message
+		if err := json.Unmarshal(input, &message); err != nil {
+			sendError("Failed to parse message: " + err.Error())
+			return
+		}
+
+		// Handle request
+		var data any
+		var err error
+		if handler, ok := apiMap[message.Method]; ok {
+			data, err = handler(&message)
+		} else {
+			err = errors.New("Unknown method: " + message.Method)
+		}
+		if err != nil {
+			sendError(err.Error())
+			continue
+		}
+		sendResponse(0, data, "")
+	}
+}
+
+func sendResponse(code int, data interface{}, message string) {
+	response := Response{
+		Code:    code,
+		Data:    data,
+		Message: message,
+	}
+
+	// Encode response
+	responseBytes, err := json.Marshal(response)
+	if err != nil {
+		sendError("Failed to encode response: " + err.Error())
+		return
+	}
+
+	// Write message length
+	binary.Write(os.Stdout, binary.NativeEndian, uint32(len(responseBytes)))
+	// Write message
+	os.Stdout.Write(responseBytes)
+}
+
+func sendError(msg string) {
+	sendResponse(1, nil, msg)
+}
@@ -3,11 +3,14 @@ package cmd
 import (
 	_ "embed"
 	"fmt"
+	"github.com/GopeedLab/gopeed/pkg/base"
 	"github.com/GopeedLab/gopeed/pkg/rest"
 	"github.com/GopeedLab/gopeed/pkg/rest/model"
 	"net/http"
 	"os"
+	"os/signal"
 	"path/filepath"
+	"syscall"
 )

 //go:embed banner.txt
@@ -24,17 +27,46 @@ func Start(cfg *model.StartConfig) {
 		panic(err)
 	}
 	if downloadCfg.FirstLoad {
-		// Set default download dir to user download dir
-		userDir, err := os.UserHomeDir()
-		if err == nil {
-			downloadDir := filepath.Join(userDir, "Downloads")
-			downloadCfg.DownloadDir = downloadDir
-			rest.Downloader.PutConfig(downloadCfg)
+		// Set default download config
+		if cfg.DownloadConfig != nil {
+			cfg.DownloadConfig.Merge(downloadCfg)
+			// TODO Use PatchConfig
+			rest.Downloader.PutConfig(cfg.DownloadConfig)
+			downloadCfg = cfg.DownloadConfig
 		}

+		downloadDir := downloadCfg.DownloadDir
+		// Set default download dir, in docker, it will be ${exe}/Downloads, else it will be ${user}/Downloads
+		if downloadDir == "" {
+			if base.InDocker == "true" {
+				downloadDir = filepath.Join(filepath.Dir(cfg.StorageDir), "Downloads")
+			} else {
+				userDir, err := os.UserHomeDir()
+				if err == nil {
+					downloadDir = filepath.Join(userDir, "Downloads")
+				}
+			}
+			if downloadDir != "" {
+				downloadCfg.DownloadDir = downloadDir
+				rest.Downloader.PutConfig(downloadCfg)
+			}
+		}
 	}
+	watchExit()
+
 	fmt.Printf("Server start success on http://%s\n", listener.Addr().String())
 	if err := srv.Serve(listener); err != nil && err != http.ErrServerClosed {
 		panic(err)
 	}
 }
+
+func watchExit() {
+	sigs := make(chan os.Signal, 1)
+	signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
+	go func() {
+		sig := <-sigs
+		fmt.Printf("Server is shutting down due to signal: %s\n", sig)
+		rest.Downloader.Close()
+		os.Exit(0)
+	}()
+}
@@ -0,0 +1,115 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"log"
+	"os"
+	"syscall"
+	"time"
+
+	"github.com/pkg/browser"
+	"github.com/pkg/errors"
+)
+
+// go build -ldflags="-s -w" -o ui/flutter/assets/exec/ github.com/GopeedLab/gopeed/cmd/updater
+
+func main() {
+	pid := flag.Int("pid", 0, "PID of the process to update")
+	updateChannel := flag.String("channel", "", "Update channel")
+	packagePath := flag.String("asset", "", "Path to the package asset")
+	exeDir := flag.String("exeDir", "", "Directory of the entry executable")
+	logPath := flag.String("log", "", "Log file path")
+	flag.Parse()
+
+	if *pid == 0 {
+		log.Println("Invalid PID")
+		os.Exit(1)
+	}
+	if *updateChannel == "" {
+		log.Println("Invalid update channel")
+		os.Exit(1)
+	}
+
+	if *logPath != "" {
+		logFile, err := os.OpenFile(*logPath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0666)
+		if err == nil {
+			defer logFile.Close()
+			log.SetOutput(logFile)
+		}
+	}
+
+	var (
+		restart bool
+		err     error
+	)
+	if restart, err = update(*pid, *updateChannel, *packagePath, *exeDir); err != nil {
+		log.Printf("Update failed: %v\n", err)
+		os.Exit(1)
+	}
+
+	// Restart the application
+	if restart {
+		browser.OpenURL("gopeed:///")
+	}
+
+	// Delete package asset
+	if *packagePath != "" {
+		os.Remove(*packagePath)
+	}
+
+	os.Exit(0)
+}
+
+func update(pid int, updateChannel, packagePath, exeDir string) (restart bool, err error) {
+	killSignalChan := make(chan any, 1)
+
+	go func() {
+		<-killSignalChan
+
+		if err = killProcess(pid); err != nil {
+			log.Printf("Failed to kill process: %v\n", err)
+		}
+
+		if err = waitForProcessExit(pid); err != nil {
+			log.Printf("Failed to wait for process exit: %v\n", err)
+		}
+	}()
+
+	log.Printf("Updating process updateChannel=%s packagePath=%s exeDir=%s\n", updateChannel, packagePath, exeDir)
+	if restart, err = install(killSignalChan, updateChannel, packagePath, exeDir); err != nil {
+		return false, errors.Wrap(err, "failed to install package")
+	}
+
+	return
+}
+
+func waitForProcessExit(pid int) error {
+	deadline := time.Now().Add(10 * time.Second)
+	for time.Now().Before(deadline) {
+		process, err := os.FindProcess(pid)
+		if err != nil {
+			// On some systems, error is returned if process doesn't exist
+			return nil
+		}
+
+		// Send null signal to test if process exists
+		err = process.Signal(syscall.Signal(0))
+		if err != nil {
+			// If error occurs, the process no longer exists
+			return nil
+		}
+
+		time.Sleep(100 * time.Millisecond)
+	}
+	return fmt.Errorf("process %d still running after timeout", pid)
+}
+
+func killProcess(pid int) error {
+	process, err := os.FindProcess(pid)
+	if err != nil {
+		return err
+	}
+
+	return process.Kill()
+}
@@ -0,0 +1,72 @@
+//go:build darwin
+
+package main
+
+import (
+	"fmt"
+	"os/exec"
+	"path/filepath"
+	"strings"
+)
+
+func install(killSignalChan chan<- any, updateChannel, packagePath, destDir string) (bool, error) {
+	return true, installByDmg(killSignalChan, packagePath, destDir)
+}
+
+// installByDmg handles macOS dmg package installation
+func installByDmg(killSignalChan chan<- any, packagePath, destDir string) error {
+	// /Applications/Gopeed.app/Contents/MacOS -> /Applications
+	appPath := getParentDir(getParentDir(getParentDir(destDir)))
+	output, err := exec.Command("hdiutil", "attach", packagePath, "-nobrowse").Output()
+	if err != nil {
+		return err
+	}
+
+	mountPoint := ""
+	for _, line := range strings.Split(string(output), "\n") {
+		if strings.Contains(line, "/Volumes/") {
+			// Find the /Volumes/ path in the line
+			// hdiutil output format: /dev/disk4s1  Apple_HFS  /Volumes/Gopeed
+			// or with sequence number: /dev/disk4s1  Apple_HFS  /Volumes/Gopeed 1
+			idx := strings.Index(line, "/Volumes/")
+			if idx != -1 {
+				// Extract everything from /Volumes/ onwards and trim whitespace
+				mountPoint = strings.TrimSpace(line[idx:])
+				break
+			}
+		}
+	}
+
+	if mountPoint == "" {
+		return fmt.Errorf("failed to get mount point from hdiutil output: %s", string(output))
+	}
+
+	// Detach the mounted DMG
+	defer exec.Command("hdiutil", "detach", mountPoint, "-quiet").Run()
+
+	matches, err := filepath.Glob(filepath.Join(mountPoint, "*.app"))
+	if err != nil {
+		return err
+	}
+	if len(matches) == 0 {
+		return fmt.Errorf("no .app found in dmg, mountPoint: %s", mountPoint)
+	}
+
+	killSignalChan <- nil
+
+	// Copy the new app to the destination
+	// cp -Rf /Volumes/GoPeed/GoPeed.app /Applications
+	if err := exec.Command("cp", "-Rf", matches[0], appPath).Run(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// Get parent directory safely, handling trailing separators
+func getParentDir(path string) string {
+	// Remove trailing separators if they exist
+	path = strings.TrimRight(path, string(filepath.Separator))
+	// Now get the parent directory
+	return filepath.Dir(path)
+}
@@ -0,0 +1,72 @@
+//go:build linux
+
+package main
+
+import (
+	"fmt"
+	"os/exec"
+)
+
+func install(killSignalChan chan<- any, updateChannel, packagePath, destDir string) (bool, error) {
+	killSignalChan <- nil
+	switch updateChannel {
+	case "linuxDeb":
+		return true, installByDeb(packagePath)
+	case "linuxFlathub":
+		return true, installByFlathub()
+	case "linuxSnap":
+		return true, installBySnap()
+	default:
+		return false, fmt.Errorf("unsupported update channel for Linux: %s", updateChannel)
+	}
+}
+
+// executeInTerminal tries to execute a command in one of several common terminal emulators
+func executeInTerminal(command string) error {
+	terminals := []string{
+		"gnome-terminal", // GNOME
+		"konsole",        // KDE
+		"xfce4-terminal", // XFCE
+		"xterm",          // X11
+	}
+
+	command = fmt.Sprintf(`echo "Starting update..." && echo "[CMD] %s" && %s`, command, command)
+
+	for _, term := range terminals {
+		if _, err := exec.LookPath(term); err == nil {
+			var cmd *exec.Cmd
+			switch term {
+			case "gnome-terminal", "xfce4-terminal":
+				cmd = exec.Command(term, "--", "bash", "-c", command)
+			case "konsole":
+				cmd = exec.Command(term, "-e", "bash", "-c", command)
+			case "xterm":
+				cmd = exec.Command(term, "-e", command)
+			}
+
+			if err := cmd.Start(); err == nil {
+				return nil
+			}
+		}
+	}
+
+	return fmt.Errorf("no suitable terminal emulator found. Please install gnome-terminal, konsole, xfce4-terminal or xterm")
+}
+
+// installByDeb installs the .deb package
+func installByDeb(packagePath string) error {
+	command := fmt.Sprintf(`sudo dpkg -i "%s"`, packagePath)
+	return executeInTerminal(command)
+}
+
+// installByFlathub updates the application via Flathub
+func installByFlathub() error {
+	command := "flatpak update com.gopeed.Gopeed -y"
+	return executeInTerminal(command)
+}
+
+// installBySnap updates the application via Snap
+func installBySnap() error {
+	command := "sudo snap refresh gopeed"
+	return executeInTerminal(command)
+}
@@ -0,0 +1,134 @@
+//go:build windows
+
+package main
+
+import (
+	"archive/zip"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+)
+
+func install(killSignalChan chan<- any, updateChannel, packagePath, destDir string) (bool, error) {
+	switch updateChannel {
+	case "windowsInstaller":
+		return false, installByInstaller(killSignalChan, packagePath, destDir)
+	default:
+		return true, installByPortable(killSignalChan, packagePath, destDir)
+	}
+}
+
+// installByInstaller extracts the installer from the zip file and runs it
+func installByInstaller(killSignalChan chan<- any, packagePath, destDir string) error {
+	// Create a temp directory for extraction
+	tempDir, err := os.MkdirTemp("", "gopeed_update")
+	if err != nil {
+		return err
+	}
+	defer os.RemoveAll(tempDir)
+
+	// Extract the zip file
+	reader, err := zip.OpenReader(packagePath)
+	if err != nil {
+		return err
+	}
+	defer reader.Close()
+
+	// Find the installer file
+	var installerPath string
+	for _, file := range reader.File {
+		if file.FileInfo().IsDir() {
+			continue
+		}
+
+		// Extract file
+		path := filepath.Join(tempDir, file.Name)
+
+		if err := os.MkdirAll(filepath.Dir(path), os.ModePerm); err != nil {
+			return err
+		}
+
+		dstFile, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, file.Mode())
+		if err != nil {
+			return err
+		}
+
+		srcFile, err := file.Open()
+		if err != nil {
+			dstFile.Close()
+			return err
+		}
+
+		_, err = io.Copy(dstFile, srcFile)
+		srcFile.Close()
+		dstFile.Close()
+		if err != nil {
+			return err
+		}
+
+		// If this is likely an installer (.exe, .msi), save its path
+		ext := strings.ToLower(filepath.Ext(file.Name))
+		if ext == ".exe" || ext == ".msi" {
+			installerPath = path
+		}
+	}
+
+	if installerPath == "" {
+		return fmt.Errorf("no installer found in the update package")
+	}
+
+	// Run the installer
+	cmd := exec.Command(installerPath)
+	if err := cmd.Start(); err != nil {
+		return err
+	}
+
+	killSignalChan <- nil
+	return nil
+}
+
+// installByPortable extracts the portable version to the destination directory
+func installByPortable(killSignalChan chan<- any, packagePath, destDir string) error {
+	killSignalChan <- nil
+
+	reader, err := zip.OpenReader(packagePath)
+	if err != nil {
+		return err
+	}
+	defer reader.Close()
+
+	for _, file := range reader.File {
+		path := filepath.Join(destDir, file.Name)
+
+		if file.FileInfo().IsDir() {
+			os.MkdirAll(path, file.Mode())
+			continue
+		}
+
+		if err := os.MkdirAll(filepath.Dir(path), os.ModePerm); err != nil {
+			return err
+		}
+
+		dstFile, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, file.Mode())
+		if err != nil {
+			return err
+		}
+
+		srcFile, err := file.Open()
+		if err != nil {
+			dstFile.Close()
+			return err
+		}
+
+		_, err = io.Copy(dstFile, srcFile)
+		srcFile.Close()
+		dstFile.Close()
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
@@ -3,73 +3,212 @@ package main
 import (
 	"encoding/json"
 	"flag"
-	"fmt"
 	"os"
 	"path/filepath"
+	"reflect"
+	"strconv"
+	"strings"
+
+	"github.com/GopeedLab/gopeed/pkg/base"
 )

 type args struct {
-	Address  *string `json:"address"`
-	Port     *int    `json:"port"`
-	Username *string `json:"username"`
-	Password *string `json:"password"`
-	ApiToken *string `json:"apiToken"`
+	Address           *string  `json:"address"`
+	Port              *int     `json:"port"`
+	Username          *string  `json:"username"`
+	Password          *string  `json:"password"`
+	ApiToken          *string  `json:"apiToken"`
+	MCPEnable         bool     `json:"mcpEnable"`
+	StorageDir        *string  `json:"storageDir"`
+	WhiteDownloadDirs []string `json:"whiteDownloadDirs"`
+	// DownloadConfig when the first time to start the server, it will be configured as initial value
+	DownloadConfig *base.DownloaderStoreConfig `json:"downloadConfig"`

 	configPath *string
 }

 func parse() *args {
-	var cliArgs args
-	cliArgs.Address = flag.String("A", "0.0.0.0", "Bind Address")
-	cliArgs.Port = flag.Int("P", 9999, "Bind Port")
-	cliArgs.Username = flag.String("u", "gopeed", "HTTP Basic Auth Username")
-	cliArgs.Password = flag.String("p", "", "HTTP Basic Auth Pwd")
-	cliArgs.ApiToken = flag.String("T", "", "API token, that can only be used when basic authentication is enabled.")
-	cliArgs.configPath = flag.String("c", "./config.json", "Config file path")
+	cfg := &args{}
+
+	cliConfig := loadCliArgs()
+	loadConfigFile(cfg, *cliConfig.configPath)
+	loadEnvVars(cfg)
+	// override with non-default command line arguments
+	overrideWithCliArgs(cfg, cliConfig)
+	// set default values
+	setDefaults(cfg, cliConfig)
+	return cfg
+}
+
+// loadCliArgs parses command line arguments and returns initial config
+func loadCliArgs() *args {
+	cfg := &args{}
+	cfg.Address = flag.String("A", "0.0.0.0", "Bind Address")
+	flag.StringVar(cfg.Address, "address", "0.0.0.0", "Bind Address")
+	cfg.Port = flag.Int("P", 9999, "Bind Port")
+	flag.IntVar(cfg.Port, "port", 9999, "Bind Port")
+	cfg.Username = flag.String("u", "gopeed", "Web Authentication Username")
+	flag.StringVar(cfg.Username, "username", "gopeed", "Web Authentication Username")
+	cfg.Password = flag.String("p", "", "Web Authentication Password, if no password is set, web authentication will not be enabled")
+	flag.StringVar(cfg.Password, "password", "", "Web Authentication Password, if no password is set, web authentication will not be enabled")
+	cfg.ApiToken = flag.String("T", "", "API token, it must be configured when using HTTP API in the case of enabling web authentication")
+	flag.StringVar(cfg.ApiToken, "api-token", "", "API token, it must be configured when using HTTP API in the case of enabling web authentication")
+	flag.BoolVar(&cfg.MCPEnable, "mcp-enable", false, "Enable MCP endpoint")
+	cfg.StorageDir = flag.String("d", "", "Storage directory")
+	flag.StringVar(cfg.StorageDir, "storage-dir", "", "Storage directory")
+	whiteDownloadDirs := flag.String("white-download-dirs", "", "White download directories, comma-separated")
+	cfg.configPath = flag.String("c", "./config.json", "Config file path")
+	flag.StringVar(cfg.configPath, "config", "./config.json", "Config file path")
 	flag.Parse()

-	// args priority: config file > cli args
-	cfgArgs := loadConfig(*cliArgs.configPath)
-	if cfgArgs.Address == nil {
-		cfgArgs.Address = cliArgs.Address
+	// Parse white download directories from comma-separated string
+	if whiteDownloadDirs != nil && *whiteDownloadDirs != "" {
+		dirs := strings.Split(*whiteDownloadDirs, ",")
+		for i := range dirs {
+			dirs[i] = strings.TrimSpace(dirs[i])
+		}
+		cfg.WhiteDownloadDirs = dirs
 	}
-	if cfgArgs.Port == nil {
-		cfgArgs.Port = cliArgs.Port
-	}
-	if cfgArgs.Username == nil {
-		cfgArgs.Username = cliArgs.Username
-	}
-	if cfgArgs.Password == nil {
-		cfgArgs.Password = cliArgs.Password
-	}
-	if cfgArgs.ApiToken == nil {
-		cfgArgs.ApiToken = cliArgs.ApiToken
-	}
-	return cfgArgs
+
+	return cfg
 }

-func loadConfig(path string) *args {
-	var args args
-
-	if !filepath.IsAbs(path) {
-		dir, err := filepath.Abs(filepath.Dir(os.Args[0]))
-		if err != nil {
-			return &args
+// overrideWithCliArgs overrides config with non-empty command line arguments
+func overrideWithCliArgs(cfg *args, cliConfig *args) {
+	flag.Visit(func(f *flag.Flag) {
+		switch f.Name {
+		case "A", "address":
+			cfg.Address = cliConfig.Address
+		case "P", "port":
+			cfg.Port = cliConfig.Port
+		case "u", "username":
+			cfg.Username = cliConfig.Username
+		case "p", "password":
+			cfg.Password = cliConfig.Password
+		case "T", "api-token":
+			cfg.ApiToken = cliConfig.ApiToken
+		case "mcp-enable":
+			cfg.MCPEnable = cliConfig.MCPEnable
+		case "d", "storage-dir":
+			cfg.StorageDir = cliConfig.StorageDir
+		case "white-download-dirs":
+			cfg.WhiteDownloadDirs = cliConfig.WhiteDownloadDirs
+		case "c", "config":
+			cfg.configPath = cliConfig.configPath
 		}
-		path = filepath.Join(dir, path)
+	})
+}
+
+// setDefaults sets default values for any unset configuration fields
+func setDefaults(cfg *args, cliConfig *args) {
+	if cfg.Address == nil {
+		cfg.Address = cliConfig.Address
 	}
-	file, err := os.ReadFile(path)
+	if cfg.Port == nil {
+		cfg.Port = cliConfig.Port
+	}
+	if cfg.Username == nil {
+		cfg.Username = cliConfig.Username
+	}
+	if cfg.Password == nil {
+		cfg.Password = cliConfig.Password
+	}
+	if cfg.ApiToken == nil {
+		cfg.ApiToken = cliConfig.ApiToken
+	}
+	if cfg.StorageDir == nil {
+		cfg.StorageDir = cliConfig.StorageDir
+	}
+}
+
+// loadConfigFile loads configuration from file
+func loadConfigFile(cfg *args, configPath string) {
+	if !filepath.IsAbs(configPath) {
+		dir, err := os.Getwd()
+		if err != nil {
+			return
+		}
+		configPath = filepath.Join(dir, configPath)
+	}
+
+	file, err := os.ReadFile(configPath)
 	if err != nil {
 		if os.IsNotExist(err) {
-			return &args
+			return
 		}
-		fmt.Println("config file read failed, reason:" + err.Error())
-		return &args
+		return
 	}
-	if err = json.Unmarshal(file, &args); err != nil {
-		fmt.Println("config file parse failed, reason:" + err.Error())
-		return &args
+
+	if err = json.Unmarshal(file, cfg); err != nil {
+		return
+	}
+}
+
+// loadEnvVars loads configuration from environment variables with prefix GOPEED_
+func loadEnvVars(cfg *args) {
+	v := reflect.ValueOf(cfg).Elem()
+	t := reflect.TypeOf(cfg).Elem()
+
+	for i := 0; i < v.NumField(); i++ {
+		field := v.Field(i)
+		fieldType := t.Field(i)
+
+		// Get json tag as environment variable suffix
+		jsonTag := fieldType.Tag.Get("json")
+		if jsonTag == "" || jsonTag == "-" {
+			continue
+		}
+
+		// Remove options like omitempty
+		if commaIdx := strings.Index(jsonTag, ","); commaIdx != -1 {
+			jsonTag = jsonTag[:commaIdx]
+		}
+
+		// Convert to uppercase and add GOPEED_ prefix
+		envKey := "GOPEED_" + strings.ToUpper(jsonTag)
+		envValue := os.Getenv(envKey)
+
+		if envValue == "" {
+			continue
+		}
+
+		// Set value based on field type
+		if field.Kind() == reflect.Ptr {
+			if field.IsNil() {
+				// Create new pointer instance
+				newVal := reflect.New(field.Type().Elem())
+				field.Set(newVal)
+			}
+
+			switch field.Type().Elem().Kind() {
+			case reflect.String:
+				field.Elem().SetString(envValue)
+			case reflect.Int:
+				if intVal, err := strconv.Atoi(envValue); err == nil {
+					field.Elem().SetInt(int64(intVal))
+				}
+			default:
+				// For complex types like DownloadConfig, try JSON unmarshaling
+				if field.Type().Elem() == reflect.TypeOf(base.DownloaderStoreConfig{}) {
+					var config base.DownloaderStoreConfig
+					if err := json.Unmarshal([]byte(envValue), &config); err == nil {
+						field.Set(reflect.ValueOf(&config))
+					}
+				}
+			}
+		} else if field.Kind() == reflect.Slice {
+			// Handle non-pointer slice types (like []string for WhiteDownloadDirs)
+			if field.Type().Elem().Kind() == reflect.String {
+				dirs := strings.Split(envValue, ",")
+				for i := range dirs {
+					dirs[i] = strings.TrimSpace(dirs[i])
+				}
+				field.Set(reflect.ValueOf(dirs))
+			}
+		} else if field.Kind() == reflect.Bool {
+			if boolVal, err := strconv.ParseBool(envValue); err == nil {
+				field.SetBool(boolVal)
+			}
+		}
 	}
-	fmt.Printf("config file loaded: %s\n", path)
-	return &args
 }
@@ -6,11 +6,12 @@ package main
 import (
 	"embed"
 	"fmt"
-	"github.com/GopeedLab/gopeed/cmd"
-	"github.com/GopeedLab/gopeed/pkg/rest/model"
 	"io/fs"
 	"os"
 	"path/filepath"
+
+	"github.com/GopeedLab/gopeed/cmd"
+	"github.com/GopeedLab/gopeed/pkg/rest/model"
 )

 //go:embed dist/*
@@ -23,30 +24,38 @@ func main() {
 	}

 	args := parse()
-	var webBasicAuth *model.WebBasicAuth
+	var webAuth *model.WebAuth
 	if isNotBlank(args.Username) && isNotBlank(args.Password) {
-		webBasicAuth = &model.WebBasicAuth{
+		webAuth = &model.WebAuth{
 			Username: *args.Username,
 			Password: *args.Password,
 		}
 	}

-	exe, err := os.Executable()
-	if err != nil {
-		panic(err)
+	var storageDir string
+	if args.StorageDir != nil && *args.StorageDir != "" {
+		storageDir = *args.StorageDir
+	} else {
+		exe, err := os.Executable()
+		if err != nil {
+			panic(err)
+		}
+		storageDir = filepath.Join(filepath.Dir(exe), "storage")
 	}
-	dir := filepath.Dir(exe)

 	cfg := &model.StartConfig{
-		Network:        "tcp",
-		Address:        fmt.Sprintf("%s:%d", *args.Address, *args.Port),
-		Storage:        model.StorageBolt,
-		StorageDir:     filepath.Join(dir, "storage"),
-		ApiToken:       *args.ApiToken,
-		ProductionMode: true,
-		WebEnable:      true,
-		WebFS:          sub,
-		WebBasicAuth:   webBasicAuth,
+		Network:           "tcp",
+		Address:           fmt.Sprintf("%s:%d", *args.Address, *args.Port),
+		Storage:           model.StorageBolt,
+		StorageDir:        storageDir,
+		WhiteDownloadDirs: args.WhiteDownloadDirs,
+		ApiToken:          *args.ApiToken,
+		MCPEnable:         args.MCPEnable,
+		DownloadConfig:    args.DownloadConfig,
+		ProductionMode:    true,
+		WebEnable:         true,
+		WebFS:             sub,
+		WebAuth:           webAuth,
 	}
 	cmd.Start(cfg)
 }
@@ -1,12 +1,15 @@
-version: '3'
-
 services:
-  gopeed:
-    container_name: gopeed
-    ports:
-      - "9999:9999" # HTTP port (host:container)
-    image: liwei2633/gopeed
-    volumes:
-      - ~/gopeed/Downloads:/root/Downloads # mount download path
-      #- ~/gopeed/storage:/app/storage # if you need to mount storage path, uncomment this line
-    restart: unless-stopped
+    gopeed:
+      container_name: gopeed
+      ports:
+        - 9999:9999 # HTTP port (host:container)
+      environment:
+        - PUID=0
+        - PGID=0
+        - UMASK=022
+      volumes:
+        - ~/gopeed/Downloads:/app/Downloads # mount download path
+        #- ~/gopeed/storage:/app/storage # if you need to mount storage path, uncomment this line
+      restart: unless-stopped
+      image: liwei2633/gopeed
+      # command: -u Username -p Password # optional authentication
@@ -0,0 +1,7 @@
+#!/bin/sh
+
+chown -R ${PUID}:${PGID} /app
+
+umask ${UMASK}
+
+exec su-exec ${PUID}:${PGID} ./gopeed "$@"
@@ -1,108 +1,170 @@
 module github.com/GopeedLab/gopeed

-go 1.19
+go 1.25.4

 require (
-	github.com/anacrolix/missinggo/v2 v2.7.2-0.20230527121029-a582b4f397b9
-	github.com/anacrolix/torrent v1.52.5
+	github.com/GopeedLab/webview_go v0.0.0-20260423085439-7a2f88b6e9b5
+	github.com/anacrolix/torrent v1.60.1-0.20251217073903-486bcbe758e0
 	github.com/armon/go-socks5 v0.0.0-20160902184237-e75332964ef5
-	github.com/dop251/goja v0.0.0-20231027120936-b396bb4c349d
-	github.com/dop251/goja_nodejs v0.0.0-20231122114759-e84d9a924c5c
+	github.com/bodgit/sevenzip v1.6.1
+	github.com/dop251/goja v0.0.0-20260106131823-651366fbe6e3
+	github.com/dop251/goja_nodejs v0.0.0-20240728170619-29b559befffc
 	github.com/go-git/go-git/v5 v5.8.1
 	github.com/gorilla/handlers v1.5.1
 	github.com/gorilla/mux v1.8.0
+	github.com/imroc/req/v3 v3.52.2
 	github.com/matoous/go-nanoid/v2 v2.0.0
+	github.com/mattn/go-ieproxy v0.0.12
+	github.com/mholt/archives v0.1.5
+	github.com/modelcontextprotocol/go-sdk v1.7.0
+	github.com/monkeyWie/goed2k v0.0.0-20260317100435-7a7575cf2447
+	github.com/pkg/errors v0.9.1
+	github.com/rs/dnscache v0.0.0-20230804202142-fc85eb664529
 	github.com/rs/zerolog v1.31.0
-	github.com/virtuald/go-paniclog v0.0.0-20190812204905-43a7fa316459
-	go.etcd.io/bbolt v1.3.8
-	golang.org/x/exp v0.0.0-20220613132600-b0d781184e0d
-	golang.org/x/sync v0.3.0
+	github.com/xiaoqidun/setft v0.0.0-20220310121541-be86327699ad
+	go.etcd.io/bbolt v1.4.3
+	golang.org/x/exp v0.0.0-20251219203646-944ab1f22d93
+)
+
+require (
+	github.com/STARRY-S/zip v0.2.3 // indirect
+	github.com/anacrolix/btree v0.1.1 // indirect
+	github.com/anacrolix/missinggo/v2 v2.10.0 // indirect
+	github.com/andybalholm/brotli v1.2.0 // indirect
+	github.com/bodgit/plumbing v1.3.0 // indirect
+	github.com/bodgit/windows v1.0.1 // indirect
+	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/dsnet/compress v0.0.2-0.20230904184137-39efe44ab707 // indirect
+	github.com/felixge/fgprof v0.9.5 // indirect
+	github.com/go-task/slim-sprig/v3 v3.0.0 // indirect
+	github.com/google/go-cmp v0.7.0 // indirect
+	github.com/google/jsonschema-go v0.4.3 // indirect
+	github.com/hashicorp/errwrap v1.1.0 // indirect
+	github.com/hashicorp/go-multierror v1.1.1 // indirect
+	github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect
+	github.com/icholy/digest v1.1.0 // indirect
+	github.com/klauspost/compress v1.18.0 // indirect
+	github.com/klauspost/pgzip v1.2.6 // indirect
+	github.com/mikelolasagasti/xz v1.0.1 // indirect
+	github.com/minio/minlz v1.0.1 // indirect
+	github.com/nwaples/rardecode/v2 v2.2.0 // indirect
+	github.com/onsi/ginkgo/v2 v2.23.4 // indirect
+	github.com/pierrec/lz4/v4 v4.1.22 // indirect
+	github.com/pion/transport/v4 v4.0.1 // indirect
+	github.com/quic-go/qpack v0.5.1 // indirect
+	github.com/quic-go/quic-go v0.51.0 // indirect
+	github.com/refraction-networking/utls v1.6.7 // indirect
+	github.com/segmentio/asm v1.1.3 // indirect
+	github.com/segmentio/encoding v0.5.4 // indirect
+	github.com/sorairolake/lzip-go v0.3.8 // indirect
+	github.com/spf13/afero v1.15.0 // indirect
+	github.com/ulikunitz/xz v0.5.15 // indirect
+	github.com/yosida95/uritemplate/v3 v3.0.2 // indirect
+	go.opentelemetry.io/auto/sdk v1.2.1 // indirect
+	go.uber.org/automaxprocs v1.6.0 // indirect
+	go.uber.org/mock v0.5.1 // indirect
+	go4.org v0.0.0-20230225012048-214862532bf5 // indirect
+	golang.org/x/oauth2 v0.35.0 // indirect
+	golang.org/x/sync v0.20.0 // indirect
 )

 require (
-	crawshaw.io/sqlite v0.3.3-0.20220618202545-d1964889ea3c // indirect
 	dario.cat/mergo v1.0.0 // indirect
-	github.com/Microsoft/go-winio v0.6.1 // indirect
+	github.com/Microsoft/go-winio v0.6.1
 	github.com/ProtonMail/go-crypto v0.0.0-20230717121422-5aa5874ade95 // indirect
-	github.com/RoaringBitmap/roaring v1.2.3 // indirect
+	github.com/RoaringBitmap/roaring v1.9.4
 	github.com/acomagu/bufpipe v1.0.4 // indirect
-	github.com/ajwerner/btree v0.0.0-20211221152037-f427b3e689c0 // indirect
 	github.com/alecthomas/atomic v0.1.0-alpha2 // indirect
-	github.com/anacrolix/chansync v0.3.0 // indirect
-	github.com/anacrolix/dht/v2 v2.19.2-0.20221121215055-066ad8494444 // indirect
-	github.com/anacrolix/envpprof v1.2.1 // indirect
-	github.com/anacrolix/generics v0.0.0-20230428105757-683593396d68 // indirect
-	github.com/anacrolix/go-libutp v1.3.1 // indirect
-	github.com/anacrolix/log v0.14.0 // indirect
+	github.com/anacrolix/chansync v0.7.0 // indirect
+	github.com/anacrolix/dht/v2 v2.23.0 // indirect
+	github.com/anacrolix/envpprof v1.5.0 // indirect
+	github.com/anacrolix/generics v0.2.0 // indirect
+	github.com/anacrolix/go-libutp v1.3.2 // indirect
+	github.com/anacrolix/log v0.17.1-0.20251118025802-918f1157b7bb // indirect
 	github.com/anacrolix/missinggo v1.3.0 // indirect
 	github.com/anacrolix/missinggo/perf v1.0.0 // indirect
-	github.com/anacrolix/mmsg v1.0.0 // indirect
-	github.com/anacrolix/multiless v0.3.0 // indirect
-	github.com/anacrolix/stm v0.4.0 // indirect
-	github.com/anacrolix/sync v0.4.0 // indirect
-	github.com/anacrolix/upnp v0.1.3-0.20220123035249-922794e51c96 // indirect
-	github.com/anacrolix/utp v0.1.0 // indirect
+	github.com/anacrolix/mmsg v1.1.1 // indirect
+	github.com/anacrolix/multiless v0.4.0 // indirect
+	github.com/anacrolix/stm v0.5.0 // indirect
+	github.com/anacrolix/sync v0.6.0 // indirect
+	github.com/anacrolix/upnp v0.1.4 // indirect
+	github.com/anacrolix/utp v0.2.0 // indirect
 	github.com/bahlo/generic-list-go v0.2.0 // indirect
-	github.com/benbjohnson/immutable v0.3.0 // indirect
-	github.com/bits-and-blooms/bitset v1.2.2 // indirect
+	github.com/benbjohnson/immutable v0.4.3 // indirect
+	github.com/bits-and-blooms/bitset v1.24.4 // indirect
 	github.com/bradfitz/iter v0.0.0-20191230175014-e8f45d346db8 // indirect
-	github.com/cloudflare/circl v1.3.3 // indirect
+	github.com/cespare/xxhash v1.1.0 // indirect
+	github.com/cloudflare/circl v1.6.1 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
-	github.com/dlclark/regexp2 v1.10.0 // indirect
-	github.com/dustin/go-humanize v1.0.0 // indirect
-	github.com/edsrzf/mmap-go v1.1.0 // indirect
+	github.com/dlclark/regexp2 v1.11.5 // indirect
+	github.com/dustin/go-humanize v1.0.1 // indirect
+	github.com/edsrzf/mmap-go v1.2.0 // indirect
 	github.com/emirpasic/gods v1.18.1 // indirect
 	github.com/felixge/httpsnoop v1.0.1 // indirect
 	github.com/go-git/gcfg v1.5.1-0.20230307220236-3a3c6141e376 // indirect
 	github.com/go-git/go-billy/v5 v5.4.1 // indirect
-	github.com/go-logr/logr v1.2.3 // indirect
+	github.com/go-llsqlite/adapter v0.2.0 // indirect
+	github.com/go-llsqlite/crawshaw v0.6.0 // indirect
+	github.com/go-logr/logr v1.4.3 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
-	github.com/go-sourcemap/sourcemap v2.1.3+incompatible // indirect
+	github.com/go-sourcemap/sourcemap v2.1.4+incompatible // indirect
 	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
-	github.com/google/btree v1.1.2 // indirect
-	github.com/google/pprof v0.0.0-20231101202521-4ca4178f5c7a // indirect
-	github.com/google/uuid v1.3.0 // indirect
-	github.com/gorilla/websocket v1.5.0 // indirect
-	github.com/huandu/xstrings v1.3.2 // indirect
+	github.com/google/btree v1.1.3 // indirect
+	github.com/google/pprof v0.0.0-20260115054156-294ebfa9ad83 // indirect
+	github.com/google/uuid v1.6.0 // indirect
+	github.com/gorilla/websocket v1.5.3 // indirect
+	github.com/huandu/xstrings v1.5.0 // indirect
 	github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect
 	github.com/kevinburke/ssh_config v1.2.0 // indirect
-	github.com/lispad/go-generics-tools v1.1.0 // indirect
+	github.com/klauspost/cpuid/v2 v2.3.0 // indirect
 	github.com/mattn/go-colorable v0.1.13 // indirect
-	github.com/mattn/go-isatty v0.0.19 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/minio/sha256-simd v1.0.1 // indirect
+	github.com/mr-tron/base58 v1.2.0 // indirect
 	github.com/mschoch/smat v0.2.0 // indirect
-	github.com/pion/datachannel v1.5.2 // indirect
-	github.com/pion/dtls/v2 v2.2.4 // indirect
-	github.com/pion/ice/v2 v2.2.6 // indirect
-	github.com/pion/interceptor v0.1.11 // indirect
-	github.com/pion/logging v0.2.2 // indirect
-	github.com/pion/mdns v0.0.5 // indirect
+	github.com/multiformats/go-multihash v0.2.3 // indirect
+	github.com/multiformats/go-varint v0.1.0 // indirect
+	github.com/ncruces/go-strftime v1.0.0 // indirect
+	github.com/pion/datachannel v1.6.0 // indirect
+	github.com/pion/dtls/v3 v3.0.10 // indirect
+	github.com/pion/ice/v4 v4.2.0 // indirect
+	github.com/pion/interceptor v0.1.42 // indirect
+	github.com/pion/logging v0.2.4 // indirect
+	github.com/pion/mdns/v2 v2.1.0 // indirect
 	github.com/pion/randutil v0.1.0 // indirect
-	github.com/pion/rtcp v1.2.9 // indirect
-	github.com/pion/rtp v1.7.13 // indirect
-	github.com/pion/sctp v1.8.2 // indirect
-	github.com/pion/sdp/v3 v3.0.5 // indirect
-	github.com/pion/srtp/v2 v2.0.9 // indirect
-	github.com/pion/stun v0.3.5 // indirect
-	github.com/pion/transport v0.13.1 // indirect
-	github.com/pion/transport/v2 v2.0.0 // indirect
-	github.com/pion/turn/v2 v2.0.8 // indirect
-	github.com/pion/udp v0.1.4 // indirect
-	github.com/pion/webrtc/v3 v3.1.42 // indirect
+	github.com/pion/rtcp v1.2.16 // indirect
+	github.com/pion/rtp v1.10.0 // indirect
+	github.com/pion/sctp v1.9.1 // indirect
+	github.com/pion/sdp/v3 v3.0.17 // indirect
+	github.com/pion/srtp/v3 v3.0.10 // indirect
+	github.com/pion/stun/v3 v3.1.1 // indirect
+	github.com/pion/turn/v4 v4.1.4 // indirect
+	github.com/pion/webrtc/v4 v4.2.2-0.20260109001657-a5962f314db7 // indirect
 	github.com/pjbgf/sha1cd v0.3.0 // indirect
-	github.com/pkg/errors v0.9.1 // indirect
-	github.com/rs/dnscache v0.0.0-20211102005908-e0241e321417 // indirect
+	github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c
+	github.com/protolambda/ctxlock v0.1.0 // indirect
+	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
 	github.com/sergi/go-diff v1.1.0 // indirect
 	github.com/skeema/knownhosts v1.2.0 // indirect
-	github.com/tidwall/btree v1.6.0 // indirect
+	github.com/spaolacci/murmur3 v1.1.0 // indirect
+	github.com/tidwall/btree v1.8.1 // indirect
+	github.com/wlynxg/anet v0.0.5 // indirect
 	github.com/xanzy/ssh-agent v0.3.3 // indirect
-	go.opentelemetry.io/otel v1.8.0 // indirect
-	go.opentelemetry.io/otel/trace v1.8.0 // indirect
-	golang.org/x/crypto v0.14.0 // indirect
-	golang.org/x/mod v0.8.0 // indirect
-	golang.org/x/net v0.17.0 // indirect
-	golang.org/x/sys v0.14.0 // indirect
-	golang.org/x/text v0.14.0 // indirect
-	golang.org/x/time v0.0.0-20220609170525-579cf78fd858 // indirect
-	golang.org/x/tools v0.6.0 // indirect
+	go.opentelemetry.io/otel v1.39.0 // indirect
+	go.opentelemetry.io/otel/metric v1.39.0 // indirect
+	go.opentelemetry.io/otel/trace v1.39.0 // indirect
+	golang.org/x/crypto v0.48.0 // indirect
+	golang.org/x/mod v0.33.0 // indirect
+	golang.org/x/net v0.50.0
+	golang.org/x/sys v0.41.0 // indirect
+	golang.org/x/text v0.34.0
+	golang.org/x/time v0.15.0 // indirect
+	golang.org/x/tools v0.42.0 // indirect
 	gopkg.in/warnings.v0 v0.1.2 // indirect
+	lukechampine.com/blake3 v1.4.1 // indirect
+	modernc.org/libc v1.67.4 // indirect
+	modernc.org/mathutil v1.7.1 // indirect
+	modernc.org/memory v1.11.0 // indirect
+	modernc.org/sqlite v1.43.0 // indirect
+	zombiezen.com/go/sqlite v1.4.2 // indirect
 )
@@ -0,0 +1,677 @@
+package blob
+
+import (
+	"bytes"
+	"context"
+	"crypto/rand"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+	"path"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+)
+
+const urlPathPrefix = "/__blob/"
+
+const rangeSourceFailureLimit = 2
+
+// unclaimedSourceTTL bounds how long a session-backed source may keep its
+// engine alive without ever being claimed by a download task.
+var unclaimedSourceTTL = 10 * time.Minute
+
+var (
+	ErrInvalidURL      = errors.New("invalid blob url")
+	ErrInvalidOptions  = errors.New("invalid blob options")
+	ErrSourceNotFound  = errors.New("blob source not found")
+	ErrSourceRevoked   = errors.New("blob source revoked")
+	ErrSourceClosed    = errors.New("blob source closed")
+	ErrRangeNotAllowed = errors.New("blob range not allowed")
+)
+
+type SessionRef interface {
+	Retain()
+	Release()
+}
+
+type OpenRequest struct {
+	Offset int64
+	End    int64
+}
+
+type OpenFunc func(ctx context.Context, req OpenRequest) (io.ReadCloser, error)
+
+type CreateOptions struct {
+	ContentType string
+	Size        int64
+	Range       bool
+	Session     SessionRef
+}
+
+type Metadata struct {
+	ContentType string
+	Size        int64
+	Range       bool
+}
+
+type Source struct {
+	ID          string
+	URL         string
+	ContentType string
+
+	mu            sync.Mutex
+	size          int64
+	rangeEnabled  bool
+	revoked       bool
+	taskRefs      int
+	readErr       error
+	rangeFailures int
+	session       SessionRef
+	open          OpenFunc
+	unclaimed     *time.Timer
+}
+
+type Registry struct {
+	dir string
+
+	mu      sync.RWMutex
+	sources map[string]*Source
+
+	serverMu sync.Mutex
+	listener net.Listener
+	server   *http.Server
+	baseURL  string
+}
+
+func NewRegistry(dir string) *Registry {
+	return &Registry{
+		dir:     dir,
+		sources: make(map[string]*Source),
+	}
+}
+
+func (r *Registry) Dir() string {
+	if r == nil {
+		return ""
+	}
+	return r.dir
+}
+
+func (r *Registry) IsURL(raw string) bool {
+	if r == nil {
+		return false
+	}
+	src, err := r.get(raw)
+	return err == nil && src != nil
+}
+
+func (r *Registry) CreateBlob(data []byte, contentType string) (string, error) {
+	buf := append([]byte(nil), data...)
+	return r.CreateOpener(func(ctx context.Context, req OpenRequest) (io.ReadCloser, error) {
+		if req.Offset < 0 || req.Offset > int64(len(buf)) {
+			return nil, ErrSourceNotFound
+		}
+		end := int64(len(buf))
+		if req.End >= req.Offset && req.End+1 < end {
+			end = req.End + 1
+		}
+		return io.NopCloser(bytes.NewReader(buf[req.Offset:end])), nil
+	}, &CreateOptions{
+		ContentType: contentType,
+		Size:        int64(len(buf)),
+		Range:       len(buf) > 0,
+	})
+}
+
+func (r *Registry) CreateOpener(open OpenFunc, opts *CreateOptions) (string, error) {
+	if r == nil {
+		return "", ErrSourceNotFound
+	}
+	if open == nil {
+		return "", ErrInvalidOptions
+	}
+	if opts == nil {
+		opts = &CreateOptions{}
+	}
+	if opts.Size < 0 {
+		opts.Size = 0
+	}
+	if opts.Range && opts.Size <= 0 {
+		return "", fmt.Errorf("%w: range requires positive size", ErrInvalidOptions)
+	}
+	// Keep server generation selection and source insertion atomic with Close.
+	r.serverMu.Lock()
+	baseURL, err := r.ensureServerLocked()
+	if err != nil {
+		r.serverMu.Unlock()
+		return "", err
+	}
+	id, err := randomID(18)
+	if err != nil {
+		r.serverMu.Unlock()
+		return "", err
+	}
+	if opts.Session != nil {
+		opts.Session.Retain()
+	}
+	srcURL := fmt.Sprintf("%s%s", baseURL, id)
+	src := &Source{
+		ID:           id,
+		URL:          srcURL,
+		ContentType:  opts.ContentType,
+		size:         opts.Size,
+		rangeEnabled: opts.Range,
+		session:      opts.Session,
+		open:         open,
+	}
+	r.mu.Lock()
+	r.sources[id] = src
+	r.mu.Unlock()
+	r.serverMu.Unlock()
+	if opts.Session != nil && unclaimedSourceTTL > 0 {
+		src.mu.Lock()
+		if !src.revoked {
+			src.unclaimed = time.AfterFunc(unclaimedSourceTTL, func() {
+				r.expireUnclaimed(src)
+			})
+		}
+		src.mu.Unlock()
+	}
+	return src.URL, nil
+}
+
+func (r *Registry) Metadata(raw string) (Metadata, error) {
+	src, err := r.get(raw)
+	if err != nil {
+		return Metadata{}, err
+	}
+	src.mu.Lock()
+	defer src.mu.Unlock()
+	return Metadata{
+		ContentType: src.ContentType,
+		Size:        src.size,
+		Range:       src.rangeEnabled,
+	}, nil
+}
+
+// Acquire retains a source for a task. A source remains available until every
+// task that acquired it calls Release, unless it is explicitly revoked.
+func (r *Registry) Acquire(raw string) error {
+	src, err := r.get(raw)
+	if err != nil {
+		return err
+	}
+	return src.acquireTask()
+}
+
+// Release releases a task's reference to a source. Releasing the final task
+// reference revokes the source. Sources that have never been acquired remain
+// registered until Revoke or Registry.Close is called; session-backed sources
+// are also bounded by the unclaimed-source TTL.
+func (r *Registry) Release(raw string) error {
+	src, err := r.get(raw)
+	if err != nil {
+		return err
+	}
+	session, last, err := src.releaseTask()
+	if err != nil {
+		return err
+	}
+	if !last {
+		return nil
+	}
+	r.deleteSource(src)
+	if session != nil {
+		session.Release()
+	}
+	return nil
+}
+
+// SourceError returns the first error encountered while opening or reading a
+// source. Invalid and missing sources have no source error. HTTP response write
+// errors are deliberately not recorded here.
+func (r *Registry) SourceError(raw string) error {
+	src, err := r.get(raw)
+	if err != nil {
+		return nil
+	}
+	return src.sourceError()
+}
+
+func (r *Registry) Revoke(raw string) error {
+	src, err := r.get(raw)
+	if err != nil {
+		return err
+	}
+	r.removeSource(src)
+	return nil
+}
+
+func (r *Registry) Close() error {
+	if r == nil {
+		return nil
+	}
+	r.serverMu.Lock()
+	server := r.server
+	listener := r.listener
+	r.server = nil
+	r.listener = nil
+	r.baseURL = ""
+	r.mu.Lock()
+	sources := make([]*Source, 0, len(r.sources))
+	for _, src := range r.sources {
+		sources = append(sources, src)
+	}
+	r.sources = make(map[string]*Source)
+	r.mu.Unlock()
+	r.serverMu.Unlock()
+	if server != nil {
+		_ = server.Close()
+	}
+	if listener != nil {
+		_ = listener.Close()
+	}
+	for _, src := range sources {
+		src.close()
+	}
+	return nil
+}
+
+// ensureServerLocked returns the current server URL or starts a new server.
+// The caller must hold serverMu.
+func (r *Registry) ensureServerLocked() (string, error) {
+	if r.baseURL != "" {
+		return r.baseURL, nil
+	}
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		return "", err
+	}
+	r.listener = listener
+	r.baseURL = "http://" + listener.Addr().String() + urlPathPrefix
+	server := &http.Server{Handler: r}
+	r.server = server
+	go func() {
+		if err := server.Serve(listener); err != nil && !errors.Is(err, http.ErrServerClosed) {
+			_ = r.Close()
+		}
+	}()
+	return r.baseURL, nil
+}
+
+func (r *Registry) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+	if req.Method != http.MethodGet {
+		w.Header().Set("Allow", "GET")
+		http.Error(w, "method not allowed", http.StatusMethodNotAllowed)
+		return
+	}
+	id := parseRequest(req)
+	if id == "" {
+		http.NotFound(w, req)
+		return
+	}
+	src, err := r.getByID(id)
+	if err != nil {
+		http.NotFound(w, req)
+		return
+	}
+	meta, open, session := src.acquireOpen()
+	if open == nil {
+		http.NotFound(w, req)
+		return
+	}
+	if session != nil {
+		defer session.Release()
+	}
+	if src.sourceError() != nil {
+		http.Error(w, "blob source unavailable", http.StatusGone)
+		return
+	}
+	start, end, ranged, err := parseRange(req.Header.Get("Range"), meta.Size, meta.Range)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusRequestedRangeNotSatisfiable)
+		return
+	}
+	if !meta.Range {
+		start, end, ranged = 0, -1, false
+	}
+	reader, err := open(req.Context(), OpenRequest{
+		Offset: start,
+		End:    end,
+	})
+	if err != nil {
+		if req.Context().Err() == nil || !errors.Is(err, req.Context().Err()) {
+			src.recordSourceError(err, meta.Range)
+		}
+		http.Error(w, "blob source unavailable", http.StatusGone)
+		return
+	}
+	if reader == nil {
+		err = fmt.Errorf("%w: opener returned a nil reader", ErrSourceClosed)
+		src.recordSourceError(err, meta.Range)
+		http.Error(w, "blob source unavailable", http.StatusGone)
+		return
+	}
+	defer reader.Close()
+
+	writeHeaders(w, meta, start, end, ranged)
+	if ranged {
+		w.WriteHeader(http.StatusPartialContent)
+	}
+	limit := int64(-1)
+	if end >= start {
+		limit = end - start + 1
+	} else if meta.Size > 0 {
+		limit = meta.Size
+	}
+	_, readErr, writeErr := copyWithFlush(w, reader, limit)
+	if readErr != nil {
+		if ctxErr := req.Context().Err(); ctxErr == nil || !errors.Is(readErr, ctxErr) {
+			src.recordSourceError(readErr, meta.Range)
+		}
+	} else if writeErr == nil && req.Context().Err() == nil {
+		src.recordSourceSuccess(meta.Range)
+	}
+}
+
+func (s *Source) acquireOpen() (Metadata, OpenFunc, SessionRef) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if s.revoked {
+		return Metadata{}, nil, nil
+	}
+	if s.session != nil {
+		// The source's own retain guarantees that the session cannot become
+		// closed while this additional active-reader retain is acquired.
+		s.session.Retain()
+	}
+	return Metadata{
+		ContentType: s.ContentType,
+		Size:        s.size,
+		Range:       s.rangeEnabled,
+	}, s.open, s.session
+}
+
+func (s *Source) acquireTask() error {
+	s.mu.Lock()
+	if s.revoked {
+		s.mu.Unlock()
+		return ErrSourceRevoked
+	}
+	s.taskRefs++
+	timer := s.unclaimed
+	s.unclaimed = nil
+	s.mu.Unlock()
+	if timer != nil {
+		timer.Stop()
+	}
+	return nil
+}
+
+func (s *Source) releaseTask() (session SessionRef, last bool, err error) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	if s.revoked {
+		return nil, false, ErrSourceRevoked
+	}
+	if s.taskRefs == 0 {
+		return nil, false, ErrSourceClosed
+	}
+	s.taskRefs--
+	if s.taskRefs > 0 {
+		return nil, false, nil
+	}
+	s.revoked = true
+	s.open = nil
+	session = s.session
+	s.session = nil
+	return session, true, nil
+}
+
+func (s *Source) sourceError() error {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return s.readErr
+}
+
+func (s *Source) recordSourceError(err error, ranged bool) {
+	if err == nil {
+		return
+	}
+	s.mu.Lock()
+	if s.readErr == nil && ranged {
+		s.rangeFailures++
+		if s.rangeFailures < rangeSourceFailureLimit {
+			s.mu.Unlock()
+			return
+		}
+	}
+	if s.readErr == nil {
+		s.readErr = err
+	}
+	s.mu.Unlock()
+}
+
+func (s *Source) recordSourceSuccess(ranged bool) {
+	if !ranged {
+		return
+	}
+	s.mu.Lock()
+	if s.readErr == nil {
+		s.rangeFailures = 0
+	}
+	s.mu.Unlock()
+}
+
+func (s *Source) close() {
+	s.mu.Lock()
+	alreadyRevoked := s.revoked
+	s.revoked = true
+	s.open = nil
+	session := s.session
+	s.session = nil
+	timer := s.unclaimed
+	s.unclaimed = nil
+	s.mu.Unlock()
+	if timer != nil {
+		timer.Stop()
+	}
+	if !alreadyRevoked && session != nil {
+		session.Release()
+	}
+}
+
+func (s *Source) expireUnclaimed() (SessionRef, bool) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.unclaimed = nil
+	if s.revoked || s.taskRefs > 0 {
+		return nil, false
+	}
+	s.revoked = true
+	s.open = nil
+	session := s.session
+	s.session = nil
+	return session, true
+}
+
+func (r *Registry) expireUnclaimed(src *Source) {
+	session, expired := src.expireUnclaimed()
+	if !expired {
+		return
+	}
+	r.deleteSource(src)
+	if session != nil {
+		session.Release()
+	}
+}
+
+func (r *Registry) removeSource(src *Source) {
+	src.close()
+	r.deleteSource(src)
+}
+
+func (r *Registry) deleteSource(src *Source) {
+	r.mu.Lock()
+	if current := r.sources[src.ID]; current == src {
+		delete(r.sources, src.ID)
+	}
+	r.mu.Unlock()
+}
+
+func writeHeaders(w http.ResponseWriter, meta Metadata, start, end int64, ranged bool) {
+	if meta.ContentType != "" {
+		w.Header().Set("Content-Type", meta.ContentType)
+	}
+	if meta.Range {
+		w.Header().Set("Accept-Ranges", "bytes")
+	}
+	if meta.Size > 0 {
+		if ranged {
+			w.Header().Set("Content-Range", fmt.Sprintf("bytes %d-%d/%d", start, end, meta.Size))
+			w.Header().Set("Content-Length", strconv.FormatInt(end-start+1, 10))
+			return
+		}
+		w.Header().Set("Content-Length", strconv.FormatInt(meta.Size, 10))
+	}
+}
+
+func copyWithFlush(w http.ResponseWriter, reader io.Reader, limit int64) (written int64, readErr error, writeErr error) {
+	if limit >= 0 {
+		reader = io.LimitReader(reader, limit)
+	}
+	buf := make([]byte, 32*1024)
+	flusher, canFlush := w.(http.Flusher)
+	for {
+		nr, er := reader.Read(buf)
+		if er != nil && !errors.Is(er, io.EOF) {
+			readErr = er
+		}
+		if nr > 0 {
+			nw, ew := w.Write(buf[:nr])
+			if nw > 0 {
+				written += int64(nw)
+				if canFlush {
+					flusher.Flush()
+				}
+			}
+			if ew != nil {
+				return written, readErr, ew
+			}
+			if nr != nw {
+				return written, readErr, io.ErrShortWrite
+			}
+		}
+		if er != nil {
+			if errors.Is(er, io.EOF) {
+				if limit >= 0 && written < limit {
+					return written, io.ErrUnexpectedEOF, nil
+				}
+				return written, nil, nil
+			}
+			return written, readErr, nil
+		}
+	}
+}
+
+func parseRange(header string, size int64, rangeEnabled bool) (start int64, end int64, ranged bool, err error) {
+	if header == "" || !rangeEnabled {
+		return 0, -1, false, nil
+	}
+	if size <= 0 {
+		return 0, 0, false, ErrRangeNotAllowed
+	}
+	if !strings.HasPrefix(header, "bytes=") {
+		return 0, 0, false, fmt.Errorf("unsupported range")
+	}
+	parts := strings.SplitN(strings.TrimPrefix(header, "bytes="), "-", 2)
+	if len(parts) != 2 || parts[0] == "" {
+		return 0, 0, false, fmt.Errorf("unsupported range")
+	}
+	start, err = strconv.ParseInt(parts[0], 10, 64)
+	if err != nil || start < 0 {
+		return 0, 0, false, fmt.Errorf("invalid range")
+	}
+	if start >= size {
+		return 0, 0, false, fmt.Errorf("range out of bounds")
+	}
+	end = size - 1
+	if parts[1] != "" {
+		end, err = strconv.ParseInt(parts[1], 10, 64)
+		if err != nil || end < start {
+			return 0, 0, false, fmt.Errorf("invalid range")
+		}
+		if end >= size {
+			end = size - 1
+		}
+	}
+	return start, end, true, nil
+}
+
+func (r *Registry) get(raw string) (*Source, error) {
+	id, ok := r.parseURL(raw)
+	if !ok {
+		return nil, ErrInvalidURL
+	}
+	src, err := r.getByID(id)
+	if err != nil {
+		return nil, err
+	}
+	src.mu.Lock()
+	revoked := src.revoked
+	src.mu.Unlock()
+	if revoked {
+		return nil, ErrSourceRevoked
+	}
+	return src, nil
+}
+
+func (r *Registry) getByID(id string) (*Source, error) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+	src := r.sources[id]
+	if src == nil {
+		return nil, ErrSourceNotFound
+	}
+	return src, nil
+}
+
+func (r *Registry) parseURL(raw string) (id string, ok bool) {
+	u, err := url.Parse(raw)
+	if err != nil || u.Scheme != "http" || !strings.HasPrefix(u.Path, urlPathPrefix) {
+		return "", false
+	}
+	r.serverMu.Lock()
+	baseURL := r.baseURL
+	r.serverMu.Unlock()
+	if baseURL == "" || !strings.HasPrefix(raw, baseURL) {
+		return "", false
+	}
+	id = strings.TrimPrefix(u.Path, urlPathPrefix)
+	if id == "" || path.Base(id) != id {
+		return "", false
+	}
+	return id, true
+}
+
+func parseRequest(req *http.Request) string {
+	id := strings.TrimPrefix(req.URL.Path, urlPathPrefix)
+	if id == "" || id == req.URL.Path || path.Base(id) != id {
+		return ""
+	}
+	return id
+}
+
+func randomID(size int) (string, error) {
+	buf := make([]byte, size)
+	if _, err := rand.Read(buf); err != nil {
+		return "", err
+	}
+	return hex.EncodeToString(buf), nil
+}
@@ -0,0 +1,898 @@
+package blob
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"io"
+	"net/http"
+	"strings"
+	"sync"
+	"testing"
+	"time"
+)
+
+type terminalErrorReader struct {
+	err error
+}
+
+func (r *terminalErrorReader) Read([]byte) (int, error) {
+	return 0, r.err
+}
+
+type contextErrorReader struct {
+	ctx context.Context
+}
+
+func (r *contextErrorReader) Read([]byte) (int, error) {
+	<-r.ctx.Done()
+	return 0, r.ctx.Err()
+}
+
+func (r *contextErrorReader) Close() error { return nil }
+
+type failingResponseWriter struct {
+	header http.Header
+	err    error
+}
+
+func (w *failingResponseWriter) Header() http.Header {
+	return w.header
+}
+
+func (w *failingResponseWriter) Write([]byte) (int, error) {
+	return 0, w.err
+}
+
+func (w *failingResponseWriter) WriteHeader(int) {}
+
+type countingSession struct {
+	mu       sync.Mutex
+	refs     int
+	zero     chan struct{}
+	zeroOnce sync.Once
+}
+
+func newCountingSession() *countingSession {
+	return &countingSession{zero: make(chan struct{})}
+}
+
+func (s *countingSession) Retain() {
+	s.mu.Lock()
+	s.refs++
+	s.mu.Unlock()
+}
+
+func (s *countingSession) Release() {
+	s.mu.Lock()
+	s.refs--
+	refs := s.refs
+	s.mu.Unlock()
+	if refs == 0 {
+		s.zeroOnce.Do(func() { close(s.zero) })
+	}
+}
+
+func (s *countingSession) RefCount() int {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return s.refs
+}
+
+func setUnclaimedSourceTTLForTest(t *testing.T, ttl time.Duration) {
+	t.Helper()
+	previous := unclaimedSourceTTL
+	unclaimedSourceTTL = ttl
+	t.Cleanup(func() {
+		unclaimedSourceTTL = previous
+	})
+}
+
+func TestRegistryBlobHTTPGetAndRange(t *testing.T) {
+	registry := NewRegistry(t.TempDir())
+	defer registry.Close()
+
+	url, err := registry.CreateBlob([]byte("hello world"), "text/plain")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !registry.IsURL(url) {
+		t.Fatal("expected registry to recognize created url")
+	}
+
+	resp, err := http.Get(url)
+	if err != nil {
+		t.Fatal(err)
+	}
+	body, err := io.ReadAll(resp.Body)
+	_ = resp.Body.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("unexpected GET status: %d", resp.StatusCode)
+	}
+	if got := resp.Header.Get("Content-Length"); got != "11" {
+		t.Fatalf("unexpected content length: %q", got)
+	}
+	if got := resp.Header.Get("Accept-Ranges"); got != "bytes" {
+		t.Fatalf("unexpected accept ranges: %q", got)
+	}
+	if got := resp.Header.Get("Content-Type"); !strings.HasPrefix(got, "text/plain") {
+		t.Fatalf("unexpected content type: %q", got)
+	}
+	if string(body) != "hello world" {
+		t.Fatalf("unexpected GET body: %q", string(body))
+	}
+
+	req, err := http.NewRequest(http.MethodGet, url, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	req.Header.Set("Range", "bytes=6-10")
+	resp, err = http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	body, err = io.ReadAll(resp.Body)
+	_ = resp.Body.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if resp.StatusCode != http.StatusPartialContent {
+		t.Fatalf("unexpected range status: %d", resp.StatusCode)
+	}
+	if got := resp.Header.Get("Content-Range"); got != "bytes 6-10/11" {
+		t.Fatalf("unexpected content range: %q", got)
+	}
+	if string(body) != "world" {
+		t.Fatalf("unexpected range body: %q", string(body))
+	}
+}
+
+func TestRegistryEmptyBlob(t *testing.T) {
+	registry := NewRegistry(t.TempDir())
+	defer registry.Close()
+
+	url, err := registry.CreateBlob(nil, "application/octet-stream")
+	if err != nil {
+		t.Fatal(err)
+	}
+	meta, err := registry.Metadata(url)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if meta.Size != 0 || meta.Range {
+		t.Fatalf("unexpected empty blob metadata: %#v", meta)
+	}
+
+	resp, err := http.Get(url)
+	if err != nil {
+		t.Fatal(err)
+	}
+	body, readErr := io.ReadAll(resp.Body)
+	_ = resp.Body.Close()
+	if readErr != nil {
+		t.Fatal(readErr)
+	}
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("unexpected status: %d", resp.StatusCode)
+	}
+	if len(body) != 0 {
+		t.Fatalf("unexpected body: %q", body)
+	}
+	if got := resp.Header.Get("Content-Length"); got != "0" {
+		t.Fatalf("unexpected content length: %q", got)
+	}
+}
+
+func TestRegistryOpenerSizeWithoutRange(t *testing.T) {
+	registry := NewRegistry(t.TempDir())
+	defer registry.Close()
+
+	payload := []byte("hello opener")
+	url, err := registry.CreateOpener(func(ctx context.Context, req OpenRequest) (io.ReadCloser, error) {
+		if req.Offset != 0 || req.End != -1 {
+			t.Fatalf("unexpected non-range request: %#v", req)
+		}
+		return io.NopCloser(bytes.NewReader(payload)), nil
+	}, &CreateOptions{
+		ContentType: "text/plain",
+		Size:        int64(len(payload)),
+		Range:       false,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	req, err := http.NewRequest(http.MethodGet, url, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	req.Header.Set("Range", "bytes=6-11")
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	body, err := io.ReadAll(resp.Body)
+	_ = resp.Body.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if resp.StatusCode != http.StatusOK {
+		t.Fatalf("unexpected status: %d", resp.StatusCode)
+	}
+	if got := resp.Header.Get("Content-Length"); got != "12" {
+		t.Fatalf("unexpected content length: %q", got)
+	}
+	if got := resp.Header.Get("Accept-Ranges"); got != "" {
+		t.Fatalf("unexpected accept ranges: %q", got)
+	}
+	if string(body) != string(payload) {
+		t.Fatalf("unexpected body: %q", string(body))
+	}
+}
+
+func TestRegistryOpenerRangeConcurrentRequests(t *testing.T) {
+	registry := NewRegistry(t.TempDir())
+	defer registry.Close()
+
+	payload := []byte("abcdefghijklmnopqrstuvwxyz")
+	var mu sync.Mutex
+	var calls []OpenRequest
+	url, err := registry.CreateOpener(func(ctx context.Context, req OpenRequest) (io.ReadCloser, error) {
+		mu.Lock()
+		calls = append(calls, req)
+		mu.Unlock()
+
+		start := int(req.Offset)
+		end := len(payload)
+		if req.End >= 0 {
+			end = int(req.End) + 1
+		}
+		if start < 0 || start > end || end > len(payload) {
+			return nil, errors.New("bad test range")
+		}
+		return io.NopCloser(bytes.NewReader(payload[start:end])), nil
+	}, &CreateOptions{
+		Size:  int64(len(payload)),
+		Range: true,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	ranges := []struct {
+		header string
+		want   string
+	}{
+		{header: "bytes=0-4", want: "abcde"},
+		{header: "bytes=10-15", want: "klmnop"},
+		{header: "bytes=20-25", want: "uvwxyz"},
+	}
+	var wg sync.WaitGroup
+	for _, item := range ranges {
+		item := item
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			req, err := http.NewRequest(http.MethodGet, url, nil)
+			if err != nil {
+				t.Error(err)
+				return
+			}
+			req.Header.Set("Range", item.header)
+			resp, err := http.DefaultClient.Do(req)
+			if err != nil {
+				t.Error(err)
+				return
+			}
+			body, err := io.ReadAll(resp.Body)
+			_ = resp.Body.Close()
+			if err != nil {
+				t.Error(err)
+				return
+			}
+			if resp.StatusCode != http.StatusPartialContent {
+				t.Errorf("unexpected status for %s: %d", item.header, resp.StatusCode)
+			}
+			if string(body) != item.want {
+				t.Errorf("unexpected body for %s: %q", item.header, string(body))
+			}
+		}()
+	}
+	wg.Wait()
+
+	mu.Lock()
+	defer mu.Unlock()
+	if len(calls) != len(ranges) {
+		t.Fatalf("unexpected opener call count: %d", len(calls))
+	}
+	seen := map[OpenRequest]bool{}
+	for _, call := range calls {
+		seen[call] = true
+	}
+	for _, want := range []OpenRequest{{Offset: 0, End: 4}, {Offset: 10, End: 15}, {Offset: 20, End: 25}} {
+		if !seen[want] {
+			t.Fatalf("missing opener request %#v, got %#v", want, calls)
+		}
+	}
+}
+
+func TestRegistryRejectsRangeWithoutSize(t *testing.T) {
+	registry := NewRegistry(t.TempDir())
+	defer registry.Close()
+
+	_, err := registry.CreateOpener(func(ctx context.Context, req OpenRequest) (io.ReadCloser, error) {
+		return io.NopCloser(strings.NewReader("")), nil
+	}, &CreateOptions{Range: true})
+	if !errors.Is(err, ErrInvalidOptions) {
+		t.Fatalf("expected invalid options error, got %v", err)
+	}
+}
+
+func TestRegistryTracksSourceErrors(t *testing.T) {
+	t.Run("reader error", func(t *testing.T) {
+		registry := NewRegistry(t.TempDir())
+		defer registry.Close()
+
+		boom := errors.New("reader failed")
+		url, err := registry.CreateOpener(func(context.Context, OpenRequest) (io.ReadCloser, error) {
+			return io.NopCloser(io.MultiReader(strings.NewReader("partial"), &terminalErrorReader{err: boom})), nil
+		}, &CreateOptions{})
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		resp, err := http.Get(url)
+		if err != nil {
+			t.Fatal(err)
+		}
+		body, readErr := io.ReadAll(resp.Body)
+		_ = resp.Body.Close()
+		if readErr != nil {
+			t.Fatalf("the HTTP transport should end normally, got %v", readErr)
+		}
+		if string(body) != "partial" {
+			t.Fatalf("unexpected partial body: %q", body)
+		}
+		if got := registry.SourceError(url); !errors.Is(got, boom) {
+			t.Fatalf("expected source error %v, got %v", boom, got)
+		}
+	})
+
+	t.Run("short known-size reader", func(t *testing.T) {
+		registry := NewRegistry(t.TempDir())
+		defer registry.Close()
+
+		url, err := registry.CreateOpener(func(context.Context, OpenRequest) (io.ReadCloser, error) {
+			return io.NopCloser(strings.NewReader("short")), nil
+		}, &CreateOptions{Size: 10})
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		resp, err := http.Get(url)
+		if err != nil {
+			t.Fatal(err)
+		}
+		_, _ = io.ReadAll(resp.Body)
+		_ = resp.Body.Close()
+		if got := registry.SourceError(url); !errors.Is(got, io.ErrUnexpectedEOF) {
+			t.Fatalf("expected unexpected EOF, got %v", got)
+		}
+	})
+
+	t.Run("range reader error becomes terminal", func(t *testing.T) {
+		registry := NewRegistry(t.TempDir())
+		defer registry.Close()
+
+		boom := errors.New("range reader failed")
+		url, err := registry.CreateOpener(func(context.Context, OpenRequest) (io.ReadCloser, error) {
+			return io.NopCloser(io.MultiReader(strings.NewReader("partial"), &terminalErrorReader{err: boom})), nil
+		}, &CreateOptions{Size: 10, Range: true})
+		if err != nil {
+			t.Fatal(err)
+		}
+
+		for attempt := 0; attempt < rangeSourceFailureLimit; attempt++ {
+			req, err := http.NewRequest(http.MethodGet, url, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			req.Header.Set("Range", "bytes=0-9")
+			resp, err := http.DefaultClient.Do(req)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, _ = io.ReadAll(resp.Body)
+			_ = resp.Body.Close()
+		}
+		if got := registry.SourceError(url); !errors.Is(got, boom) {
+			t.Fatalf("expected range source error %v, got %v", boom, got)
+		}
+
+		resp, err := http.Get(url)
+		if err != nil {
+			t.Fatal(err)
+		}
+		_ = resp.Body.Close()
+		if resp.StatusCode != http.StatusGone {
+			t.Fatalf("expected terminal source status %d, got %d", http.StatusGone, resp.StatusCode)
+		}
+	})
+
+	t.Run("short range reader", func(t *testing.T) {
+		registry := NewRegistry(t.TempDir())
+		defer registry.Close()
+
+		url, err := registry.CreateOpener(func(context.Context, OpenRequest) (io.ReadCloser, error) {
+			return io.NopCloser(strings.NewReader("short")), nil
+		}, &CreateOptions{Size: 10, Range: true})
+		if err != nil {
+			t.Fatal(err)
+		}
+		for attempt := 0; attempt < rangeSourceFailureLimit; attempt++ {
+			req, err := http.NewRequest(http.MethodGet, url, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			req.Header.Set("Range", "bytes=0-9")
+			resp, err := http.DefaultClient.Do(req)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, _ = io.ReadAll(resp.Body)
+			_ = resp.Body.Close()
+		}
+		if got := registry.SourceError(url); !errors.Is(got, io.ErrUnexpectedEOF) {
+			t.Fatalf("expected range unexpected EOF, got %v", got)
+		}
+	})
+
+	t.Run("successful range retry clears transient failure", func(t *testing.T) {
+		registry := NewRegistry(t.TempDir())
+		defer registry.Close()
+
+		attempt := 0
+		boom := errors.New("transient range failure")
+		url, err := registry.CreateOpener(func(context.Context, OpenRequest) (io.ReadCloser, error) {
+			attempt++
+			if attempt == 1 {
+				return io.NopCloser(&terminalErrorReader{err: boom}), nil
+			}
+			return io.NopCloser(strings.NewReader("0123456789")), nil
+		}, &CreateOptions{Size: 10, Range: true})
+		if err != nil {
+			t.Fatal(err)
+		}
+		for i := 0; i < 2; i++ {
+			req, err := http.NewRequest(http.MethodGet, url, nil)
+			if err != nil {
+				t.Fatal(err)
+			}
+			req.Header.Set("Range", "bytes=0-9")
+			resp, err := http.DefaultClient.Do(req)
+			if err != nil {
+				t.Fatal(err)
+			}
+			_, _ = io.ReadAll(resp.Body)
+			_ = resp.Body.Close()
+		}
+		if got := registry.SourceError(url); got != nil {
+			t.Fatalf("successful retry left transient source error: %v", got)
+		}
+	})
+
+	t.Run("request cancellation is not a source error", func(t *testing.T) {
+		registry := NewRegistry(t.TempDir())
+		defer registry.Close()
+
+		opened := make(chan struct{})
+		url, err := registry.CreateOpener(func(ctx context.Context, _ OpenRequest) (io.ReadCloser, error) {
+			close(opened)
+			return &contextErrorReader{ctx: ctx}, nil
+		}, &CreateOptions{})
+		if err != nil {
+			t.Fatal(err)
+		}
+		ctx, cancel := context.WithCancel(context.Background())
+		req, err := http.NewRequestWithContext(ctx, http.MethodGet, url, nil)
+		if err != nil {
+			t.Fatal(err)
+		}
+		done := make(chan struct{})
+		go func() {
+			resp, _ := http.DefaultClient.Do(req)
+			if resp != nil {
+				_ = resp.Body.Close()
+			}
+			close(done)
+		}()
+		<-opened
+		cancel()
+		select {
+		case <-done:
+		case <-time.After(2 * time.Second):
+			t.Fatal("cancelled request did not finish")
+		}
+		if got := registry.SourceError(url); got != nil {
+			t.Fatalf("request cancellation was recorded as source error: %v", got)
+		}
+	})
+
+	t.Run("nil reader", func(t *testing.T) {
+		registry := NewRegistry(t.TempDir())
+		defer registry.Close()
+
+		url, err := registry.CreateOpener(func(context.Context, OpenRequest) (io.ReadCloser, error) {
+			return nil, nil
+		}, &CreateOptions{})
+		if err != nil {
+			t.Fatal(err)
+		}
+		resp, err := http.Get(url)
+		if err != nil {
+			t.Fatal(err)
+		}
+		_ = resp.Body.Close()
+		if resp.StatusCode != http.StatusGone {
+			t.Fatalf("expected nil reader status %d, got %d", http.StatusGone, resp.StatusCode)
+		}
+		if got := registry.SourceError(url); !errors.Is(got, ErrSourceClosed) {
+			t.Fatalf("expected closed source error, got %v", got)
+		}
+	})
+}
+
+func TestRegistryDoesNotRecordResponseWriteError(t *testing.T) {
+	registry := NewRegistry(t.TempDir())
+	defer registry.Close()
+
+	url, err := registry.CreateOpener(func(context.Context, OpenRequest) (io.ReadCloser, error) {
+		return io.NopCloser(strings.NewReader("payload")), nil
+	}, &CreateOptions{Size: 7})
+	if err != nil {
+		t.Fatal(err)
+	}
+	req, err := http.NewRequest(http.MethodGet, url, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	writerErr := errors.New("client connection closed")
+	registry.ServeHTTP(&failingResponseWriter{header: make(http.Header), err: writerErr}, req)
+	if got := registry.SourceError(url); got != nil {
+		t.Fatalf("response write error was recorded as a source error: %v", got)
+	}
+}
+
+func TestRegistryTaskReferencesShareSource(t *testing.T) {
+	registry := NewRegistry(t.TempDir())
+	defer registry.Close()
+
+	url, err := registry.CreateBlob([]byte("shared"), "text/plain")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := registry.Acquire(url); err != nil {
+		t.Fatal(err)
+	}
+	if err := registry.Acquire(url); err != nil {
+		t.Fatal(err)
+	}
+	if err := registry.Release(url); err != nil {
+		t.Fatal(err)
+	}
+	if !registry.IsURL(url) {
+		t.Fatal("the first task release revoked a source still used by another task")
+	}
+
+	resp, err := http.Get(url)
+	if err != nil {
+		t.Fatal(err)
+	}
+	body, readErr := io.ReadAll(resp.Body)
+	_ = resp.Body.Close()
+	if readErr != nil || string(body) != "shared" {
+		t.Fatalf("unexpected shared response body %q, error %v", body, readErr)
+	}
+
+	if err := registry.Release(url); err != nil {
+		t.Fatal(err)
+	}
+	if registry.IsURL(url) {
+		t.Fatal("the final task release did not revoke the source")
+	}
+}
+
+func TestRegistryUnclaimedSessionSourceExpires(t *testing.T) {
+	setUnclaimedSourceTTLForTest(t, 25*time.Millisecond)
+	registry := NewRegistry(t.TempDir())
+	defer registry.Close()
+
+	session := newCountingSession()
+	url, err := registry.CreateOpener(func(context.Context, OpenRequest) (io.ReadCloser, error) {
+		return io.NopCloser(strings.NewReader("unused")), nil
+	}, &CreateOptions{Size: 6, Session: session})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := session.RefCount(); got != 1 {
+		t.Fatalf("unexpected initial session ref count: %d", got)
+	}
+
+	select {
+	case <-session.zero:
+	case <-time.After(2 * time.Second):
+		t.Fatal("unclaimed source did not expire")
+	}
+	if registry.IsURL(url) {
+		t.Fatal("expired source is still registered")
+	}
+	if got := session.RefCount(); got != 0 {
+		t.Fatalf("expired source retained its session: %d", got)
+	}
+}
+
+func TestRegistryAcquireStopsUnclaimedSourceExpiration(t *testing.T) {
+	const ttl = 25 * time.Millisecond
+	setUnclaimedSourceTTLForTest(t, ttl)
+	registry := NewRegistry(t.TempDir())
+	defer registry.Close()
+
+	session := newCountingSession()
+	url, err := registry.CreateOpener(func(context.Context, OpenRequest) (io.ReadCloser, error) {
+		return io.NopCloser(strings.NewReader("claimed")), nil
+	}, &CreateOptions{Size: 7, Session: session})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := registry.Acquire(url); err != nil {
+		t.Fatal(err)
+	}
+
+	select {
+	case <-session.zero:
+		t.Fatal("claimed source expired")
+	case <-time.After(4 * ttl):
+	}
+	if !registry.IsURL(url) {
+		t.Fatal("claimed source was removed")
+	}
+	if err := registry.Release(url); err != nil {
+		t.Fatal(err)
+	}
+	select {
+	case <-session.zero:
+	case <-time.After(2 * time.Second):
+		t.Fatal("final task release did not release the session")
+	}
+}
+
+func TestRegistryUnclaimedExpirationKeepsActiveReaderSession(t *testing.T) {
+	setUnclaimedSourceTTLForTest(t, 100*time.Millisecond)
+	registry := NewRegistry(t.TempDir())
+	defer registry.Close()
+
+	session := newCountingSession()
+	reader, writer := io.Pipe()
+	opened := make(chan struct{})
+	url, err := registry.CreateOpener(func(context.Context, OpenRequest) (io.ReadCloser, error) {
+		close(opened)
+		return reader, nil
+	}, &CreateOptions{Size: 7, Session: session})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	type result struct {
+		body []byte
+		err  error
+	}
+	resultCh := make(chan result, 1)
+	go func() {
+		resp, err := http.Get(url)
+		if err != nil {
+			resultCh <- result{err: err}
+			return
+		}
+		body, err := io.ReadAll(resp.Body)
+		_ = resp.Body.Close()
+		resultCh <- result{body: body, err: err}
+	}()
+
+	select {
+	case <-opened:
+	case got := <-resultCh:
+		t.Fatalf("request ended before the opener ran: body %q, error %v", got.body, got.err)
+	case <-time.After(2 * time.Second):
+		t.Fatal("active request did not open")
+	}
+	deadline := time.NewTimer(2 * time.Second)
+	ticker := time.NewTicker(5 * time.Millisecond)
+	defer deadline.Stop()
+	defer ticker.Stop()
+	for registry.IsURL(url) {
+		select {
+		case <-ticker.C:
+		case <-deadline.C:
+			t.Fatal("unclaimed source did not expire while its reader was active")
+		}
+	}
+	if got := session.RefCount(); got != 1 {
+		t.Fatalf("expiration released the active-reader session ref: %d", got)
+	}
+	if _, err := writer.Write([]byte("payload")); err != nil {
+		t.Fatal(err)
+	}
+	_ = writer.Close()
+
+	select {
+	case got := <-resultCh:
+		if got.err != nil || string(got.body) != "payload" {
+			t.Fatalf("active response was interrupted: body %q, error %v", got.body, got.err)
+		}
+	case <-time.After(2 * time.Second):
+		t.Fatal("active response did not finish after source expiration")
+	}
+	select {
+	case <-session.zero:
+		if got := session.RefCount(); got != 0 {
+			t.Fatalf("unexpected final session ref count: %d", got)
+		}
+	case <-time.After(2 * time.Second):
+		t.Fatal("active-reader session ref was not released")
+	}
+}
+
+func TestRegistryCloseCancelsUnclaimedExpiration(t *testing.T) {
+	const ttl = 25 * time.Millisecond
+	setUnclaimedSourceTTLForTest(t, ttl)
+	registry := NewRegistry(t.TempDir())
+
+	session := newCountingSession()
+	_, err := registry.CreateOpener(func(context.Context, OpenRequest) (io.ReadCloser, error) {
+		return io.NopCloser(strings.NewReader("unused")), nil
+	}, &CreateOptions{Size: 6, Session: session})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := registry.Close(); err != nil {
+		t.Fatal(err)
+	}
+	select {
+	case <-session.zero:
+	case <-time.After(2 * time.Second):
+		t.Fatal("registry close did not release the session")
+	}
+	<-time.After(4 * ttl)
+	if got := session.RefCount(); got != 0 {
+		t.Fatalf("expiration released the session again after close: %d", got)
+	}
+}
+
+func TestRegistryRevokeKeepsActiveReaderSession(t *testing.T) {
+	registry := NewRegistry(t.TempDir())
+	defer registry.Close()
+
+	session := newCountingSession()
+	reader, writer := io.Pipe()
+	opened := make(chan struct{})
+	url, err := registry.CreateOpener(func(context.Context, OpenRequest) (io.ReadCloser, error) {
+		close(opened)
+		return reader, nil
+	}, &CreateOptions{Size: 7, Session: session})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	type result struct {
+		body []byte
+		err  error
+	}
+	resultCh := make(chan result, 1)
+	go func() {
+		resp, err := http.Get(url)
+		if err != nil {
+			resultCh <- result{err: err}
+			return
+		}
+		body, err := io.ReadAll(resp.Body)
+		_ = resp.Body.Close()
+		resultCh <- result{body: body, err: err}
+	}()
+
+	<-opened
+	if got := session.RefCount(); got != 2 {
+		t.Fatalf("expected source and active-reader session refs, got %d", got)
+	}
+	if err := registry.Revoke(url); err != nil {
+		t.Fatal(err)
+	}
+	if got := session.RefCount(); got != 1 {
+		t.Fatalf("revoke released the active-reader session ref: %d", got)
+	}
+	if _, err := writer.Write([]byte("payload")); err != nil {
+		t.Fatal(err)
+	}
+	_ = writer.Close()
+
+	select {
+	case got := <-resultCh:
+		if got.err != nil || string(got.body) != "payload" {
+			t.Fatalf("active response was interrupted: body %q, error %v", got.body, got.err)
+		}
+	case <-time.After(2 * time.Second):
+		t.Fatal("active response did not finish after revoke")
+	}
+	select {
+	case <-session.zero:
+		if got := session.RefCount(); got != 0 {
+			t.Fatalf("unexpected final session ref count: %d", got)
+		}
+	case <-time.After(2 * time.Second):
+		t.Fatal("active-reader session ref was not released")
+	}
+}
+
+func TestRegistryHTTPErrorStatuses(t *testing.T) {
+	registry := NewRegistry(t.TempDir())
+	defer registry.Close()
+
+	url, err := registry.CreateBlob([]byte("secret"), "text/plain")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	badURL := url + "-missing"
+	resp, err := http.Get(badURL)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_ = resp.Body.Close()
+	if resp.StatusCode != http.StatusNotFound {
+		t.Fatalf("unexpected missing source status: %d", resp.StatusCode)
+	}
+
+	req, err := http.NewRequest(http.MethodHead, url, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	resp, err = http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_ = resp.Body.Close()
+	if resp.StatusCode != http.StatusMethodNotAllowed {
+		t.Fatalf("unexpected method status: %d", resp.StatusCode)
+	}
+
+	req, err = http.NewRequest(http.MethodGet, url, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	req.Header.Set("Range", "bytes=99-100")
+	resp, err = http.DefaultClient.Do(req)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_ = resp.Body.Close()
+	if resp.StatusCode != http.StatusRequestedRangeNotSatisfiable {
+		t.Fatalf("unexpected invalid range status: %d", resp.StatusCode)
+	}
+
+	if err := registry.Revoke(url); err != nil {
+		t.Fatal(err)
+	}
+	resp, err = http.Get(url)
+	if err != nil {
+		t.Fatal(err)
+	}
+	_ = resp.Body.Close()
+	if resp.StatusCode != http.StatusNotFound {
+		t.Fatalf("unexpected revoked source status: %d", resp.StatusCode)
+	}
+	if registry.IsURL(url) {
+		t.Fatal("revoked source should not be usable")
+	}
+}
@@ -1,14 +1,16 @@
 package controller

 import (
+	"github.com/GopeedLab/gopeed/pkg/base"
+	"net/http"
 	"net/url"
 	"os"
 	"path/filepath"
 )

 type Controller struct {
-	GetConfig func(v any) bool
-	ProxyUrl  *url.URL
+	GetConfig func(v any)
+	GetProxy  func(requestProxy *base.RequestProxy) func(*http.Request) (*url.URL, error)
 	FileController
 	//ContextDialer() (proxy.Dialer, error)
 }
@@ -22,10 +24,11 @@ type DefaultFileController struct {

 func NewController() *Controller {
 	return &Controller{
-		FileController: &DefaultFileController{},
-		GetConfig: func(v any) bool {
-			return false
+		GetConfig: func(v any) {},
+		GetProxy: func(requestProxy *base.RequestProxy) func(*http.Request) (*url.URL, error) {
+			return requestProxy.ToHandler()
 		},
+		FileController: &DefaultFileController{},
 	}
 }

@@ -1,26 +1,29 @@
 package fetcher

 import (
+	"path"
+	"strings"
+
 	"github.com/GopeedLab/gopeed/internal/controller"
 	"github.com/GopeedLab/gopeed/pkg/base"
-	"path"
 )

 // Fetcher defines the interface for a download protocol.
-// One fetcher for each download task
+// Each download task will have a corresponding Fetcher instance for the management of the download task
 type Fetcher interface {
-	// Name return the name of the protocol.
-	Name() string
-
 	Setup(ctl *controller.Controller)
-	// Resolve resource info from request
-	Resolve(req *base.Request) error
-	// Create ready to download, but not started
-	Create(opts *base.Options) error
+	Resolve(req *base.Request, opts *base.Options) error
 	Start() error
+	// Patch modifies task-specific data based on the protocol.
+	// For HTTP: can modify Request info (URL, headers, etc.)
+	// For BT: can modify SelectFiles (via opts.SelectFiles)
+	Patch(req *base.Request, opts *base.Options) error
 	Pause() error
 	Close() error

+	// Stats returns both the durable protocol snapshot and transient runtime
+	// telemetry. Downloader persists Snapshot and keeps Runtime in memory only.
+	Stats() *Stats
 	// Meta returns the meta information of the download.
 	Meta() *FetcherMeta
 	// Progress returns the progress of the download.
@@ -29,6 +32,20 @@ type Fetcher interface {
 	Wait() error
 }

+// Stats separates protocol information that remains meaningful after a task
+// stops from telemetry that is valid only while the fetcher is active.
+// Protocols own both payload schemas; Downloader treats them as opaque values.
+type Stats struct {
+	Snapshot any `json:"snapshot"`
+	Runtime  any `json:"runtime"`
+}
+
+type Uploader interface {
+	Upload() error
+	UploadedBytes() int64
+	WaitUpload() error
+}
+
 // FetcherMeta defines the meta information of a fetcher.
 type FetcherMeta struct {
 	Req  *base.Request  `json:"req"`
@@ -66,17 +83,72 @@ func (m *FetcherMeta) RootDirPath() string {
 	}
 }

-// FetcherBuilder defines the interface for a fetcher builder.
-type FetcherBuilder interface {
-	// Schemes returns the schemes supported by the fetcher.
-	Schemes() []string
+type FilterType int
+
+const (
+	// FilterTypeUrl url type, pattern is the scheme, e.g. http://github.com -> http
+	FilterTypeUrl FilterType = iota
+	// FilterTypeFile file type, pattern is the file extension name, e.g. test.torrent -> torrent
+	FilterTypeFile
+	// FilterTypeBase64 base64 data type, pattern is the data mime type, e.g. data:application/x-bittorrent;base64 -> application/x-bittorrent
+	FilterTypeBase64
+)
+
+type SchemeFilter struct {
+	Type    FilterType
+	Pattern string
+}
+
+func (s *SchemeFilter) Match(uri string) bool {
+	uriUpper := strings.ToUpper(uri)
+	patternUpper := strings.ToUpper(s.Pattern)
+	switch s.Type {
+	case FilterTypeUrl:
+		return strings.HasPrefix(uriUpper, patternUpper+":")
+	case FilterTypeFile:
+		return strings.HasSuffix(uriUpper, "."+patternUpper)
+	case FilterTypeBase64:
+		return strings.HasPrefix(uriUpper, "DATA:"+patternUpper+";BASE64,")
+	}
+	return false
+}
+
+// FetcherManager manage and control the fetcher
+type FetcherManager interface {
+	// Name return the name of the protocol.
+	Name() string
+	// Filters registers the supported schemes.
+	Filters() []*SchemeFilter
 	// Build returns a new fetcher.
 	Build() Fetcher
+	// ParseName name displayed when the task is not yet resolved, parsed from the request URL
+	ParseName(u string) string
+	// AutoRename returns whether the fetcher need renaming the download file when has the same name file.
+	AutoRename() bool

+	// DefaultConfig returns the default configuration of the protocol.
+	DefaultConfig() any
 	// Store fetcher
 	Store(fetcher Fetcher) (any, error)
 	// Restore fetcher
 	Restore() (v any, f func(meta *FetcherMeta, v any) Fetcher)
+	// Close the fetcher manager, release resources.
+	Close() error
+}
+
+// StatefulFetcherManager is an optional extension for protocols that keep
+// shared client state outside individual task fetchers.
+type StatefulFetcherManager interface {
+	SetStateStore(store ProtocolStateStore)
+}
+
+// ProtocolStateStore persists shared protocol state for a fetcher manager.
+// Downloader provides the concrete storage backend, while the protocol decides
+// when state should be loaded or flushed.
+type ProtocolStateStore interface {
+	Load(v any) (bool, error)
+	Save(v any) error
+	Delete() error
 }

 type DefaultFetcher struct {
@@ -0,0 +1,114 @@
+package fetcher
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+func TestStatsMarshalRawSnapshotWithoutRuntime(t *testing.T) {
+	stats := &Stats{
+		Snapshot: json.RawMessage(`{"value":1}`),
+	}
+
+	data, err := json.Marshal(stats)
+	if err != nil {
+		t.Fatalf("Marshal() error = %v", err)
+	}
+	if got, want := string(data), `{"snapshot":{"value":1},"runtime":null}`; got != want {
+		t.Fatalf("Marshal() = %s, want %s", got, want)
+	}
+}
+
+func TestSchemeFilter_Match(t *testing.T) {
+	type fields struct {
+		Type    FilterType
+		Pattern string
+	}
+	type args struct {
+		uri string
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		args   args
+		want   bool
+	}{
+		{
+			name: "url match",
+			fields: fields{
+				Type:    FilterTypeUrl,
+				Pattern: "https",
+			},
+			args: args{
+				uri: "https://github.com",
+			},
+			want: true,
+		},
+		{
+			name: "url not match",
+			fields: fields{
+				Type:    FilterTypeUrl,
+				Pattern: "https",
+			},
+			args: args{
+				uri: "ftp://github.com",
+			},
+			want: false,
+		},
+		{
+			name: "file match",
+			fields: fields{
+				Type:    FilterTypeFile,
+				Pattern: "torrent",
+			},
+			args: args{
+				uri: "d:/temp/test.torrent",
+			},
+			want: true,
+		},
+		{
+			name: "file not match",
+			fields: fields{
+				Type:    FilterTypeFile,
+				Pattern: "torrent",
+			},
+			args: args{
+				uri: "d:/temp/test.txt",
+			},
+			want: false,
+		},
+		{
+			name: "base64 match",
+			fields: fields{
+				Type:    FilterTypeBase64,
+				Pattern: "application/x-bittorrent",
+			},
+			args: args{
+				uri: "data:application/x-bittorrent;base64,xxx",
+			},
+			want: true,
+		},
+		{
+			name: "base64 not match",
+			fields: fields{
+				Type:    FilterTypeBase64,
+				Pattern: "application/x-bittorrent",
+			},
+			args: args{
+				uri: "data:application/javascript;base64,xxx",
+			},
+			want: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s := &SchemeFilter{
+				Type:    tt.fields.Type,
+				Pattern: tt.fields.Pattern,
+			}
+			if got := s.Match(tt.args.uri); got != tt.want {
+				t.Errorf("Match() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
@@ -0,0 +1,346 @@
+package httpclient
+
+import (
+	"context"
+	"crypto/tls"
+	"fmt"
+	"net"
+	"net/http"
+	"net/url"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/imroc/req/v3"
+)
+
+type ImpersonationMode string
+
+const (
+	ImpersonationNative ImpersonationMode = "native"
+	ImpersonationFixed  ImpersonationMode = "fixed"
+	ImpersonationAuto   ImpersonationMode = "auto"
+)
+
+type Browser string
+
+const (
+	BrowserChrome  Browser = "chrome"
+	BrowserFirefox Browser = "firefox"
+	BrowserSafari  Browser = "safari"
+)
+
+type Options struct {
+	Client        ClientOptions
+	Transport     TransportOptions
+	Impersonation ImpersonationOptions
+}
+
+type ClientOptions struct {
+	Jar           http.CookieJar
+	CheckRedirect func(req *http.Request, via []*http.Request) error
+	Timeout       time.Duration
+}
+
+type TransportOptions struct {
+	Proxy               func(*http.Request) (*url.URL, error)
+	DialContext         func(ctx context.Context, network, address string) (net.Conn, error)
+	TLSClientConfig     *tls.Config
+	TLSHandshakeTimeout time.Duration
+}
+
+type ImpersonationOptions struct {
+	Mode    ImpersonationMode
+	Browser Browser
+	Session *ImpersonationSession
+}
+
+type ImpersonationSession struct {
+	mu         sync.RWMutex
+	selections map[string]impersonationSelection
+}
+
+type impersonationSelection struct {
+	browser          Browser
+	fallbackDisabled bool
+}
+
+func NewImpersonationSession() *ImpersonationSession {
+	return &ImpersonationSession{
+		selections: make(map[string]impersonationSelection),
+	}
+}
+
+func (s *ImpersonationSession) load(url string) (impersonationSelection, bool) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+	selection, ok := s.selections[url]
+	return selection, ok
+}
+
+func (s *ImpersonationSession) store(url string, browser Browser) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.selections[url] = impersonationSelection{browser: browser}
+}
+
+func (s *ImpersonationSession) disableFallback(url string) {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	s.selections[url] = impersonationSelection{fallbackDisabled: true}
+}
+
+func (s *ImpersonationSession) Clear() {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	clear(s.selections)
+}
+
+func NewClient(options Options) (*http.Client, error) {
+	var transport http.RoundTripper
+	switch options.Impersonation.Mode {
+	case "", ImpersonationNative:
+		transport = newNativeTransport(options.Transport)
+	case ImpersonationFixed:
+		browserTransport, err := newBrowserTransport(options.Transport, options.Impersonation.Browser)
+		if err != nil {
+			return nil, err
+		}
+		transport = browserTransport
+	case ImpersonationAuto:
+		browserTransports := make(map[Browser]http.RoundTripper, 3)
+		for _, browser := range []Browser{BrowserChrome, BrowserFirefox, BrowserSafari} {
+			browserTransport, err := newBrowserTransport(options.Transport, browser)
+			if err != nil {
+				return nil, err
+			}
+			browserTransports[browser] = browserTransport
+		}
+		transport = &adaptiveTransport{
+			native:   newNativeTransport(options.Transport),
+			browsers: browserTransports,
+			jar:      options.Client.Jar,
+			session:  options.Impersonation.Session,
+		}
+	default:
+		return nil, fmt.Errorf("unsupported impersonation mode %q", options.Impersonation.Mode)
+	}
+
+	return &http.Client{
+		Transport:     transport,
+		Jar:           options.Client.Jar,
+		CheckRedirect: options.Client.CheckRedirect,
+		Timeout:       options.Client.Timeout,
+	}, nil
+}
+
+func newNativeTransport(options TransportOptions) *http.Transport {
+	var tlsConfig *tls.Config
+	if options.TLSClientConfig != nil {
+		tlsConfig = options.TLSClientConfig.Clone()
+	}
+	return &http.Transport{
+		Proxy:               options.Proxy,
+		DialContext:         options.DialContext,
+		TLSClientConfig:     tlsConfig,
+		TLSHandshakeTimeout: options.TLSHandshakeTimeout,
+		ForceAttemptHTTP2:   true,
+	}
+}
+
+func newBrowserTransport(options TransportOptions, browser Browser) (http.RoundTripper, error) {
+	client := req.NewClient()
+	client.SetProxy(options.Proxy)
+	if options.DialContext != nil {
+		client.SetDial(options.DialContext)
+	}
+	client.SetTLSHandshakeTimeout(options.TLSHandshakeTimeout)
+	if options.TLSClientConfig != nil {
+		tlsConfig := options.TLSClientConfig.Clone()
+		if len(tlsConfig.NextProtos) == 0 {
+			tlsConfig.NextProtos = []string{"h2", "http/1.1"}
+		}
+		client.SetTLSClientConfig(tlsConfig)
+	}
+
+	switch browser {
+	case BrowserChrome:
+		client.ImpersonateChrome()
+	case BrowserFirefox:
+		client.ImpersonateFirefox()
+	case BrowserSafari:
+		client.ImpersonateSafari()
+	default:
+		return nil, fmt.Errorf("unsupported browser %q", browser)
+	}
+
+	return &defaultHeaderTransport{
+		next:     client.GetClient().Transport,
+		defaults: client.Headers.Clone(),
+	}, nil
+}
+
+type defaultHeaderTransport struct {
+	next     http.RoundTripper
+	defaults http.Header
+}
+
+func (t *defaultHeaderTransport) RoundTrip(request *http.Request) (*http.Response, error) {
+	request = request.Clone(request.Context())
+	request.Header = request.Header.Clone()
+	for key, values := range t.defaults {
+		if len(request.Header.Values(key)) == 0 {
+			request.Header[key] = append([]string(nil), values...)
+		}
+	}
+	return t.next.RoundTrip(request)
+}
+
+func (t *defaultHeaderTransport) CloseIdleConnections() {
+	closeIdleConnections(t.next)
+}
+
+type adaptiveTransport struct {
+	native   http.RoundTripper
+	browsers map[Browser]http.RoundTripper
+	jar      http.CookieJar
+	session  *ImpersonationSession
+}
+
+func (t *adaptiveTransport) RoundTrip(request *http.Request) (*http.Response, error) {
+	cacheKey := requestCacheKey(request.URL)
+	if t.session != nil {
+		if selected, ok := t.session.load(cacheKey); ok {
+			if selected.fallbackDisabled {
+				return t.native.RoundTrip(request)
+			}
+			return t.browsers[selected.browser].RoundTrip(request)
+		}
+	}
+
+	response, err := t.native.RoundTrip(request)
+	if !shouldFallback(response, err) {
+		return response, err
+	}
+
+	retry, ok := cloneRequestForRetry(request)
+	if !ok {
+		return response, err
+	}
+	if response != nil {
+		applyResponseCookies(t.jar, request, retry, response)
+		_ = response.Body.Close()
+	}
+
+	browser := browserFromUserAgent(request.UserAgent())
+	response, err = t.browsers[browser].RoundTrip(retry)
+	if t.session != nil {
+		if isSuccessfulFallback(response, err) {
+			t.session.store(cacheKey, browser)
+		} else if err == nil && response != nil {
+			t.session.disableFallback(cacheKey)
+		}
+	}
+	return response, err
+}
+
+func requestCacheKey(requestURL *url.URL) string {
+	cacheURL := *requestURL
+	cacheURL.Fragment = ""
+	cacheURL.RawFragment = ""
+	return cacheURL.String()
+}
+
+func applyResponseCookies(jar http.CookieJar, request, retry *http.Request, response *http.Response) {
+	if jar == nil {
+		return
+	}
+	jar.SetCookies(request.URL, response.Cookies())
+	jarCookies := jar.Cookies(request.URL)
+	jarCookieNames := make(map[string]struct{}, len(jarCookies))
+	for _, cookie := range jarCookies {
+		jarCookieNames[cookie.Name] = struct{}{}
+	}
+	existingCookies := retry.Cookies()
+	retry.Header.Del("Cookie")
+	for _, cookie := range existingCookies {
+		if _, replaced := jarCookieNames[cookie.Name]; !replaced {
+			retry.AddCookie(cookie)
+		}
+	}
+	for _, cookie := range jarCookies {
+		retry.AddCookie(cookie)
+	}
+}
+
+func (t *adaptiveTransport) CloseIdleConnections() {
+	closeIdleConnections(t.native)
+	for _, transport := range t.browsers {
+		closeIdleConnections(transport)
+	}
+}
+
+func closeIdleConnections(transport http.RoundTripper) {
+	if closer, ok := transport.(interface{ CloseIdleConnections() }); ok {
+		closer.CloseIdleConnections()
+	}
+}
+
+func shouldFallback(response *http.Response, err error) bool {
+	if err != nil {
+		return true
+	}
+	if response == nil {
+		return false
+	}
+	return response.StatusCode == http.StatusForbidden ||
+		strings.EqualFold(response.Header.Get("Cf-Mitigated"), "challenge")
+}
+
+func isSuccessfulFallback(response *http.Response, err error) bool {
+	return err == nil && response != nil &&
+		response.StatusCode >= http.StatusOK &&
+		response.StatusCode < http.StatusBadRequest
+}
+
+func cloneRequestForRetry(request *http.Request) (*http.Request, bool) {
+	if !isIdempotent(request) {
+		return nil, false
+	}
+	retry := request.Clone(request.Context())
+	if request.Body == nil || request.Body == http.NoBody {
+		return retry, true
+	}
+	if request.GetBody == nil {
+		return nil, false
+	}
+	body, err := request.GetBody()
+	if err != nil {
+		return nil, false
+	}
+	retry.Body = body
+	return retry, true
+}
+
+func isIdempotent(request *http.Request) bool {
+	switch request.Method {
+	case http.MethodGet, http.MethodHead, http.MethodOptions, http.MethodTrace:
+		return true
+	}
+	return request.Header.Get("Idempotency-Key") != "" ||
+		request.Header.Get("X-Idempotency-Key") != ""
+}
+
+func browserFromUserAgent(userAgent string) Browser {
+	userAgent = strings.ToLower(userAgent)
+	switch {
+	case strings.Contains(userAgent, "firefox"):
+		return BrowserFirefox
+	case strings.Contains(userAgent, "safari") &&
+		!strings.Contains(userAgent, "chrome") &&
+		!strings.Contains(userAgent, "chromium"):
+		return BrowserSafari
+	default:
+		return BrowserChrome
+	}
+}
@@ -0,0 +1,962 @@
+package httpclient_test
+
+import (
+	"context"
+	"crypto/tls"
+	"errors"
+	"io"
+	"net"
+	"net/http"
+	"net/http/cookiejar"
+	"net/http/httptest"
+	"net/url"
+	"slices"
+	"strings"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/GopeedLab/gopeed/internal/httpclient"
+	"github.com/GopeedLab/gopeed/internal/httpclient/httpclienttest"
+)
+
+func TestFixedChromeUsesBrowserTLSFingerprintAndHTTP2(t *testing.T) {
+	server := httpclienttest.NewFingerprintServer(t, httpclienttest.FingerprintServerOptions{
+		RequiredProfile: httpclienttest.ProfileAnyBrowser,
+	})
+
+	client, err := httpclient.NewClient(httpclient.Options{
+		Transport: httpclient.TransportOptions{
+			TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+		},
+		Impersonation: httpclient.ImpersonationOptions{
+			Mode:    httpclient.ImpersonationFixed,
+			Browser: httpclient.BrowserChrome,
+		},
+	})
+	if err != nil {
+		t.Fatalf("NewClient() error = %v", err)
+	}
+
+	response, err := client.Get(server.URL)
+	if err != nil {
+		t.Fatalf("Get() error = %v", err)
+	}
+	defer response.Body.Close()
+
+	if response.StatusCode != http.StatusOK {
+		t.Fatalf("status = %d, want %d", response.StatusCode, http.StatusOK)
+	}
+	if response.ProtoMajor != 2 {
+		t.Fatalf("protocol = %q, want HTTP/2", response.Proto)
+	}
+}
+
+func TestAutoFallsBackFromNativeToBrowserFingerprint(t *testing.T) {
+	server := httpclienttest.NewFingerprintServer(t, httpclienttest.FingerprintServerOptions{
+		RequiredProfile: httpclienttest.ProfileAnyBrowser,
+	})
+
+	client, err := httpclient.NewClient(httpclient.Options{
+		Transport: httpclient.TransportOptions{
+			TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+		},
+		Impersonation: httpclient.ImpersonationOptions{
+			Mode: httpclient.ImpersonationAuto,
+		},
+	})
+	if err != nil {
+		t.Fatalf("NewClient() error = %v", err)
+	}
+
+	request, err := http.NewRequest(http.MethodGet, server.URL, nil)
+	if err != nil {
+		t.Fatalf("NewRequest() error = %v", err)
+	}
+	request.Header.Set("User-Agent", "Mozilla/5.0 Chrome/120.0.0.0 Safari/537.36")
+
+	response, err := client.Do(request)
+	if err != nil {
+		t.Fatalf("Do() error = %v", err)
+	}
+	defer response.Body.Close()
+
+	if response.ProtoMajor != 2 {
+		t.Fatalf("protocol = %q, want HTTP/2", response.Proto)
+	}
+	if got, want := server.Profiles(), []httpclienttest.Profile{
+		httpclienttest.ProfileNative,
+		httpclienttest.ProfileChrome,
+	}; !slices.Equal(got, want) {
+		t.Fatalf("ClientHello profiles = %v, want %v", got, want)
+	}
+}
+
+func TestAutoChoosesBrowserFingerprintFromUserAgent(t *testing.T) {
+	tests := []struct {
+		name        string
+		userAgent   string
+		wantBrowser httpclient.Browser
+	}{
+		{
+			name:        "chrome",
+			userAgent:   "Mozilla/5.0 Chrome/120.0.0.0 Safari/537.36",
+			wantBrowser: httpclient.BrowserChrome,
+		},
+		{
+			name:        "firefox",
+			userAgent:   "Mozilla/5.0 Firefox/120.0",
+			wantBrowser: httpclient.BrowserFirefox,
+		},
+		{
+			name:        "safari",
+			userAgent:   "Mozilla/5.0 Version/16.6 Safari/605.1.15",
+			wantBrowser: httpclient.BrowserSafari,
+		},
+		{
+			name:        "unknown defaults to chrome",
+			userAgent:   "Gopeed/1.0",
+			wantBrowser: httpclient.BrowserChrome,
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			server := httpclienttest.NewFingerprintServer(t, httpclienttest.FingerprintServerOptions{
+				RequiredProfile: httpclienttest.Profile(test.wantBrowser),
+			})
+			client, err := httpclient.NewClient(httpclient.Options{
+				Transport: httpclient.TransportOptions{
+					TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+				},
+				Impersonation: httpclient.ImpersonationOptions{Mode: httpclient.ImpersonationAuto},
+			})
+			if err != nil {
+				t.Fatalf("NewClient() error = %v", err)
+			}
+
+			request, err := http.NewRequest(http.MethodGet, server.URL, nil)
+			if err != nil {
+				t.Fatalf("NewRequest() error = %v", err)
+			}
+			request.Header.Set("User-Agent", test.userAgent)
+			response, err := client.Do(request)
+			if err != nil {
+				t.Fatalf("Do() error = %v", err)
+			}
+			response.Body.Close()
+
+			if response.ProtoMajor != 2 {
+				t.Fatalf("protocol = %q, want HTTP/2", response.Proto)
+			}
+			if got, want := server.Profiles(), []httpclienttest.Profile{
+				httpclienttest.ProfileNative,
+				httpclienttest.Profile(test.wantBrowser),
+			}; !slices.Equal(got, want) {
+				t.Fatalf("profiles = %v, want %v", got, want)
+			}
+		})
+	}
+}
+
+func TestAutoFallsBackOnForbiddenAndPinsBrowserPerURL(t *testing.T) {
+	var requests atomic.Int32
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, request *http.Request) {
+		requests.Add(1)
+		if request.Header.Get("Sec-Ch-Ua") == "" {
+			http.Error(w, "browser required", http.StatusForbidden)
+			return
+		}
+		w.WriteHeader(http.StatusOK)
+	}))
+	t.Cleanup(server.Close)
+
+	client, err := httpclient.NewClient(httpclient.Options{
+		Impersonation: httpclient.ImpersonationOptions{
+			Mode:    httpclient.ImpersonationAuto,
+			Session: httpclient.NewImpersonationSession(),
+		},
+	})
+	if err != nil {
+		t.Fatalf("NewClient() error = %v", err)
+	}
+
+	for range 2 {
+		request, err := http.NewRequest(http.MethodGet, server.URL, nil)
+		if err != nil {
+			t.Fatalf("NewRequest() error = %v", err)
+		}
+		request.Header.Set("User-Agent", "Mozilla/5.0 Chrome/120.0.0.0 Safari/537.36")
+		response, err := client.Do(request)
+		if err != nil {
+			t.Fatalf("Do() error = %v", err)
+		}
+		response.Body.Close()
+		if response.StatusCode != http.StatusOK {
+			t.Fatalf("status = %d, want %d", response.StatusCode, http.StatusOK)
+		}
+	}
+
+	if requests.Load() != 3 {
+		t.Fatalf("requests = %d, want 3 (native + fallback + pinned)", requests.Load())
+	}
+}
+
+func TestAutoDisablesFallbackWhenBrowserReturnsHTTPFailure(t *testing.T) {
+	var requests atomic.Int32
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, request *http.Request) {
+		requests.Add(1)
+		if request.Header.Get("Sec-Ch-Ua") == "" {
+			w.WriteHeader(http.StatusForbidden)
+			return
+		}
+		w.WriteHeader(http.StatusNotFound)
+	}))
+	t.Cleanup(server.Close)
+
+	client, err := httpclient.NewClient(httpclient.Options{
+		Impersonation: httpclient.ImpersonationOptions{
+			Mode:    httpclient.ImpersonationAuto,
+			Session: httpclient.NewImpersonationSession(),
+		},
+	})
+	if err != nil {
+		t.Fatalf("NewClient() error = %v", err)
+	}
+
+	wantStatuses := []int{http.StatusNotFound, http.StatusForbidden}
+	for _, wantStatus := range wantStatuses {
+		response, err := client.Get(server.URL)
+		if err != nil {
+			t.Fatalf("Get() error = %v", err)
+		}
+		response.Body.Close()
+		if response.StatusCode != wantStatus {
+			t.Fatalf("status = %d, want %d", response.StatusCode, wantStatus)
+		}
+	}
+
+	if requests.Load() != 3 {
+		t.Fatalf("requests = %d, want 3 (native + one fallback + native)", requests.Load())
+	}
+}
+
+func TestAutoDoesNotDisableFallbackAfterTransportFailure(t *testing.T) {
+	server := httpclienttest.NewFingerprintServer(t, httpclienttest.FingerprintServerOptions{
+		RequiredProfile: httpclienttest.Profile("unsupported"),
+	})
+	client, err := httpclient.NewClient(httpclient.Options{
+		Transport: httpclient.TransportOptions{
+			TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+		},
+		Impersonation: httpclient.ImpersonationOptions{
+			Mode:    httpclient.ImpersonationAuto,
+			Session: httpclient.NewImpersonationSession(),
+		},
+	})
+	if err != nil {
+		t.Fatalf("NewClient() error = %v", err)
+	}
+
+	for range 2 {
+		if _, err := client.Get(server.URL); err == nil {
+			t.Fatal("Get() error = nil, want TLS failure")
+		}
+	}
+	if got, want := server.Profiles(), []httpclienttest.Profile{
+		httpclienttest.ProfileNative,
+		httpclienttest.ProfileChrome,
+		httpclienttest.ProfileNative,
+		httpclienttest.ProfileChrome,
+	}; !slices.Equal(got, want) {
+		t.Fatalf("ClientHello profiles = %v, want %v", got, want)
+	}
+}
+
+func TestAutoWithoutSessionDoesNotCacheSelectedBrowser(t *testing.T) {
+	var requests atomic.Int32
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, request *http.Request) {
+		requests.Add(1)
+		if request.Header.Get("Sec-Ch-Ua") == "" {
+			w.WriteHeader(http.StatusForbidden)
+			return
+		}
+		w.WriteHeader(http.StatusOK)
+	}))
+	t.Cleanup(server.Close)
+
+	client, err := httpclient.NewClient(httpclient.Options{
+		Impersonation: httpclient.ImpersonationOptions{Mode: httpclient.ImpersonationAuto},
+	})
+	if err != nil {
+		t.Fatalf("NewClient() error = %v", err)
+	}
+	for range 2 {
+		response, err := client.Get(server.URL)
+		if err != nil {
+			t.Fatalf("Get() error = %v", err)
+		}
+		response.Body.Close()
+	}
+
+	if requests.Load() != 4 {
+		t.Fatalf("requests = %d, want 4 (native + fallback without caching)", requests.Load())
+	}
+}
+
+func TestAutoSharesSelectedBrowserAcrossClientsInSession(t *testing.T) {
+	var requests atomic.Int32
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, request *http.Request) {
+		requests.Add(1)
+		if request.Header.Get("Sec-Ch-Ua") == "" {
+			w.WriteHeader(http.StatusForbidden)
+			return
+		}
+		w.WriteHeader(http.StatusOK)
+	}))
+	t.Cleanup(server.Close)
+	session := httpclient.NewImpersonationSession()
+
+	for range 2 {
+		client, err := httpclient.NewClient(httpclient.Options{
+			Impersonation: httpclient.ImpersonationOptions{
+				Mode:    httpclient.ImpersonationAuto,
+				Session: session,
+			},
+		})
+		if err != nil {
+			t.Fatalf("NewClient() error = %v", err)
+		}
+		request, err := http.NewRequest(http.MethodGet, server.URL, nil)
+		if err != nil {
+			t.Fatalf("NewRequest() error = %v", err)
+		}
+		request.Header.Set("User-Agent", "Mozilla/5.0 Chrome/120.0.0.0 Safari/537.36")
+		response, err := client.Do(request)
+		if err != nil {
+			t.Fatalf("Do() error = %v", err)
+		}
+		response.Body.Close()
+	}
+
+	if requests.Load() != 3 {
+		t.Fatalf("requests = %d, want 3 (native + fallback + session pinned)", requests.Load())
+	}
+}
+
+func TestAutoDoesNotShareSelectedBrowserAcrossSessions(t *testing.T) {
+	var requests atomic.Int32
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, request *http.Request) {
+		requests.Add(1)
+		if request.Header.Get("Sec-Ch-Ua") == "" {
+			w.WriteHeader(http.StatusForbidden)
+			return
+		}
+		w.WriteHeader(http.StatusOK)
+	}))
+	t.Cleanup(server.Close)
+
+	for range 2 {
+		client, err := httpclient.NewClient(httpclient.Options{
+			Impersonation: httpclient.ImpersonationOptions{
+				Mode:    httpclient.ImpersonationAuto,
+				Session: httpclient.NewImpersonationSession(),
+			},
+		})
+		if err != nil {
+			t.Fatalf("NewClient() error = %v", err)
+		}
+		response, err := client.Get(server.URL)
+		if err != nil {
+			t.Fatalf("Get() error = %v", err)
+		}
+		response.Body.Close()
+	}
+
+	if requests.Load() != 4 {
+		t.Fatalf("requests = %d, want 4 (native + fallback per session)", requests.Load())
+	}
+}
+
+func TestAutoCachesSelectedBrowserByFullURL(t *testing.T) {
+	var publicBrowserRequests atomic.Int32
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, request *http.Request) {
+		browserRequest := request.Header.Get("Sec-Ch-Ua") != ""
+		switch request.URL.Query().Get("access") {
+		case "protected":
+			if !browserRequest {
+				w.WriteHeader(http.StatusForbidden)
+				return
+			}
+		case "public":
+			if browserRequest {
+				publicBrowserRequests.Add(1)
+			}
+		}
+		w.WriteHeader(http.StatusOK)
+	}))
+	t.Cleanup(server.Close)
+
+	client, err := httpclient.NewClient(httpclient.Options{
+		Impersonation: httpclient.ImpersonationOptions{
+			Mode:    httpclient.ImpersonationAuto,
+			Session: httpclient.NewImpersonationSession(),
+		},
+	})
+	if err != nil {
+		t.Fatalf("NewClient() error = %v", err)
+	}
+
+	for range 2 {
+		response, err := client.Get(server.URL + "/file?access=protected")
+		if err != nil {
+			t.Fatalf("protected Get() error = %v", err)
+		}
+		response.Body.Close()
+	}
+	response, err := client.Get(server.URL + "/file?access=public")
+	if err != nil {
+		t.Fatalf("public Get() error = %v", err)
+	}
+	response.Body.Close()
+
+	if publicBrowserRequests.Load() != 0 {
+		t.Fatalf("public browser requests = %d, want 0", publicBrowserRequests.Load())
+	}
+}
+
+func TestImpersonationSessionClearRemovesSelections(t *testing.T) {
+	var requests atomic.Int32
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, request *http.Request) {
+		requests.Add(1)
+		if request.Header.Get("Sec-Ch-Ua") == "" {
+			w.WriteHeader(http.StatusForbidden)
+			return
+		}
+		w.WriteHeader(http.StatusOK)
+	}))
+	t.Cleanup(server.Close)
+
+	session := httpclient.NewImpersonationSession()
+	client, err := httpclient.NewClient(httpclient.Options{
+		Impersonation: httpclient.ImpersonationOptions{
+			Mode:    httpclient.ImpersonationAuto,
+			Session: session,
+		},
+	})
+	if err != nil {
+		t.Fatalf("NewClient() error = %v", err)
+	}
+	for range 2 {
+		response, err := client.Get(server.URL)
+		if err != nil {
+			t.Fatalf("Get() error = %v", err)
+		}
+		response.Body.Close()
+		session.Clear()
+	}
+
+	if requests.Load() != 4 {
+		t.Fatalf("requests = %d, want 4 (native + fallback after each clear)", requests.Load())
+	}
+}
+
+func TestGlobalAutoSelectionDoesNotAffectNativeMode(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, request *http.Request) {
+		if request.Header.Get("Sec-Ch-Ua") == "" {
+			w.WriteHeader(http.StatusForbidden)
+			return
+		}
+		w.WriteHeader(http.StatusOK)
+	}))
+	t.Cleanup(server.Close)
+
+	autoClient, err := httpclient.NewClient(httpclient.Options{
+		Impersonation: httpclient.ImpersonationOptions{Mode: httpclient.ImpersonationAuto},
+	})
+	if err != nil {
+		t.Fatalf("NewClient(auto) error = %v", err)
+	}
+	autoResponse, err := autoClient.Get(server.URL)
+	if err != nil {
+		t.Fatalf("auto Get() error = %v", err)
+	}
+	autoResponse.Body.Close()
+	if autoResponse.StatusCode != http.StatusOK {
+		t.Fatalf("auto status = %d, want %d", autoResponse.StatusCode, http.StatusOK)
+	}
+
+	nativeClient, err := httpclient.NewClient(httpclient.Options{
+		Impersonation: httpclient.ImpersonationOptions{Mode: httpclient.ImpersonationNative},
+	})
+	if err != nil {
+		t.Fatalf("NewClient(native) error = %v", err)
+	}
+	nativeResponse, err := nativeClient.Get(server.URL)
+	if err != nil {
+		t.Fatalf("native Get() error = %v", err)
+	}
+	nativeResponse.Body.Close()
+	if nativeResponse.StatusCode != http.StatusForbidden {
+		t.Fatalf("native status = %d, want %d", nativeResponse.StatusCode, http.StatusForbidden)
+	}
+}
+
+func TestAutoAppliesFallbackResponseCookiesBeforeRetry(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, request *http.Request) {
+		if request.Header.Get("Sec-Ch-Ua") == "" {
+			http.SetCookie(w, &http.Cookie{Name: "challenge", Value: "passed", Path: "/"})
+			w.WriteHeader(http.StatusForbidden)
+			return
+		}
+		cookie, err := request.Cookie("challenge")
+		if err != nil || cookie.Value != "passed" {
+			w.WriteHeader(http.StatusForbidden)
+			return
+		}
+		w.WriteHeader(http.StatusOK)
+	}))
+	t.Cleanup(server.Close)
+
+	jar, err := cookiejar.New(nil)
+	if err != nil {
+		t.Fatalf("cookiejar.New() error = %v", err)
+	}
+	client, err := httpclient.NewClient(httpclient.Options{
+		Client:        httpclient.ClientOptions{Jar: jar},
+		Impersonation: httpclient.ImpersonationOptions{Mode: httpclient.ImpersonationAuto},
+	})
+	if err != nil {
+		t.Fatalf("NewClient() error = %v", err)
+	}
+	response, err := client.Get(server.URL)
+	if err != nil {
+		t.Fatalf("Get() error = %v", err)
+	}
+	response.Body.Close()
+	if response.StatusCode != http.StatusOK {
+		t.Fatalf("status = %d, want %d", response.StatusCode, http.StatusOK)
+	}
+}
+
+func TestAutoDoesNotRetryRequestWithNonReplayableBody(t *testing.T) {
+	var requests atomic.Int32
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		requests.Add(1)
+		w.WriteHeader(http.StatusForbidden)
+	}))
+	t.Cleanup(server.Close)
+
+	client, err := httpclient.NewClient(httpclient.Options{
+		Impersonation: httpclient.ImpersonationOptions{Mode: httpclient.ImpersonationAuto},
+	})
+	if err != nil {
+		t.Fatalf("NewClient() error = %v", err)
+	}
+	bodyReader, bodyWriter := io.Pipe()
+	t.Cleanup(func() {
+		bodyReader.Close()
+		bodyWriter.Close()
+	})
+	go func() {
+		_, _ = bodyWriter.Write([]byte("payload"))
+		_ = bodyWriter.Close()
+	}()
+	request, err := http.NewRequest(http.MethodPost, server.URL, bodyReader)
+	if err != nil {
+		t.Fatalf("NewRequest() error = %v", err)
+	}
+
+	response, err := client.Do(request)
+	if err != nil {
+		t.Fatalf("Do() error = %v", err)
+	}
+	response.Body.Close()
+	if requests.Load() != 1 {
+		t.Fatalf("requests = %d, want 1", requests.Load())
+	}
+}
+
+func TestAutoDoesNotRetryReplayablePost(t *testing.T) {
+	var requests atomic.Int32
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		requests.Add(1)
+		w.WriteHeader(http.StatusForbidden)
+	}))
+	t.Cleanup(server.Close)
+
+	client, err := httpclient.NewClient(httpclient.Options{
+		Impersonation: httpclient.ImpersonationOptions{Mode: httpclient.ImpersonationAuto},
+	})
+	if err != nil {
+		t.Fatalf("NewClient() error = %v", err)
+	}
+	request, err := http.NewRequest(http.MethodPost, server.URL, strings.NewReader("payload"))
+	if err != nil {
+		t.Fatalf("NewRequest() error = %v", err)
+	}
+
+	response, err := client.Do(request)
+	if err != nil {
+		t.Fatalf("Do() error = %v", err)
+	}
+	response.Body.Close()
+	if requests.Load() != 1 {
+		t.Fatalf("requests = %d, want 1", requests.Load())
+	}
+}
+
+func TestNativeUsesStandardTransportWithHTTP2(t *testing.T) {
+	server := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	}))
+	server.EnableHTTP2 = true
+	server.StartTLS()
+	t.Cleanup(server.Close)
+
+	client, err := httpclient.NewClient(httpclient.Options{
+		Transport: httpclient.TransportOptions{
+			TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
+		},
+		Impersonation: httpclient.ImpersonationOptions{
+			Mode: httpclient.ImpersonationNative,
+		},
+	})
+	if err != nil {
+		t.Fatalf("NewClient() error = %v", err)
+	}
+
+	response, err := client.Get(server.URL)
+	if err != nil {
+		t.Fatalf("Get() error = %v", err)
+	}
+	defer response.Body.Close()
+
+	if response.ProtoMajor != 2 {
+		t.Fatalf("protocol = %q, want HTTP/2", response.Proto)
+	}
+}
+
+func TestClientOptionsPreserveCookiesAcrossRedirects(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, request *http.Request) {
+		switch request.URL.Path {
+		case "/start":
+			http.SetCookie(w, &http.Cookie{Name: "session", Value: "gopeed", Path: "/"})
+			http.Redirect(w, request, "/download", http.StatusFound)
+		case "/download":
+			cookie, err := request.Cookie("session")
+			if err != nil || cookie.Value != "gopeed" {
+				http.Error(w, "cookie missing", http.StatusBadRequest)
+				return
+			}
+			w.WriteHeader(http.StatusOK)
+		default:
+			http.NotFound(w, request)
+		}
+	}))
+	t.Cleanup(server.Close)
+
+	jar, err := cookiejar.New(nil)
+	if err != nil {
+		t.Fatalf("cookiejar.New() error = %v", err)
+	}
+	var redirects atomic.Int32
+	client, err := httpclient.NewClient(httpclient.Options{
+		Client: httpclient.ClientOptions{
+			Jar: jar,
+			CheckRedirect: func(_ *http.Request, _ []*http.Request) error {
+				redirects.Add(1)
+				return nil
+			},
+		},
+		Impersonation: httpclient.ImpersonationOptions{Mode: httpclient.ImpersonationNative},
+	})
+	if err != nil {
+		t.Fatalf("NewClient() error = %v", err)
+	}
+
+	response, err := client.Get(server.URL + "/start")
+	if err != nil {
+		t.Fatalf("Get() error = %v", err)
+	}
+	defer response.Body.Close()
+
+	if response.StatusCode != http.StatusOK {
+		t.Fatalf("status = %d, want %d", response.StatusCode, http.StatusOK)
+	}
+	if redirects.Load() != 1 {
+		t.Fatalf("redirect calls = %d, want 1", redirects.Load())
+	}
+}
+
+func TestClientTimeoutCancelsRequest(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(_ http.ResponseWriter, request *http.Request) {
+		<-request.Context().Done()
+	}))
+	t.Cleanup(server.Close)
+
+	client, err := httpclient.NewClient(httpclient.Options{
+		Client: httpclient.ClientOptions{Timeout: 50 * time.Millisecond},
+		Impersonation: httpclient.ImpersonationOptions{
+			Mode: httpclient.ImpersonationNative,
+		},
+	})
+	if err != nil {
+		t.Fatalf("NewClient() error = %v", err)
+	}
+
+	_, err = client.Get(server.URL)
+	if err == nil {
+		t.Fatal("Get() error = nil, want timeout")
+	}
+	var networkError net.Error
+	if !errors.As(err, &networkError) || !networkError.Timeout() {
+		t.Fatalf("Get() error = %v, want net.Error timeout", err)
+	}
+}
+
+func TestTransportOptionsUseProxyInNativeAndFixedModes(t *testing.T) {
+	proxy := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, request *http.Request) {
+		if request.URL.Host != "download.example" {
+			http.Error(w, "unexpected target", http.StatusBadRequest)
+			return
+		}
+		w.WriteHeader(http.StatusOK)
+	}))
+	t.Cleanup(proxy.Close)
+	proxyURL, err := url.Parse(proxy.URL)
+	if err != nil {
+		t.Fatalf("url.Parse() error = %v", err)
+	}
+
+	tests := []struct {
+		name          string
+		impersonation httpclient.ImpersonationOptions
+	}{
+		{
+			name:          "native",
+			impersonation: httpclient.ImpersonationOptions{Mode: httpclient.ImpersonationNative},
+		},
+		{
+			name: "fixed chrome",
+			impersonation: httpclient.ImpersonationOptions{
+				Mode:    httpclient.ImpersonationFixed,
+				Browser: httpclient.BrowserChrome,
+			},
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			client, err := httpclient.NewClient(httpclient.Options{
+				Transport:     httpclient.TransportOptions{Proxy: http.ProxyURL(proxyURL)},
+				Impersonation: test.impersonation,
+			})
+			if err != nil {
+				t.Fatalf("NewClient() error = %v", err)
+			}
+
+			response, err := client.Get("http://download.example/file")
+			if err != nil {
+				t.Fatalf("Get() error = %v", err)
+			}
+			defer response.Body.Close()
+			if response.StatusCode != http.StatusOK {
+				t.Fatalf("status = %d, want %d", response.StatusCode, http.StatusOK)
+			}
+		})
+	}
+}
+
+func TestTransportOptionsUseDialContextInNativeAndFixedModes(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	}))
+	t.Cleanup(server.Close)
+
+	tests := []struct {
+		name          string
+		impersonation httpclient.ImpersonationOptions
+	}{
+		{
+			name:          "native",
+			impersonation: httpclient.ImpersonationOptions{Mode: httpclient.ImpersonationNative},
+		},
+		{
+			name: "fixed chrome",
+			impersonation: httpclient.ImpersonationOptions{
+				Mode:    httpclient.ImpersonationFixed,
+				Browser: httpclient.BrowserChrome,
+			},
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			var calls atomic.Int32
+			dialer := &net.Dialer{}
+			client, err := httpclient.NewClient(httpclient.Options{
+				Transport: httpclient.TransportOptions{
+					DialContext: func(ctx context.Context, network, address string) (net.Conn, error) {
+						calls.Add(1)
+						return dialer.DialContext(ctx, network, address)
+					},
+				},
+				Impersonation: test.impersonation,
+			})
+			if err != nil {
+				t.Fatalf("NewClient() error = %v", err)
+			}
+
+			response, err := client.Get(server.URL)
+			if err != nil {
+				t.Fatalf("Get() error = %v", err)
+			}
+			response.Body.Close()
+			if calls.Load() == 0 {
+				t.Fatal("DialContext() was not called")
+			}
+		})
+	}
+}
+
+func TestTransportOptionsApplyTLSHandshakeTimeoutInNativeAndFixedModes(t *testing.T) {
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatalf("net.Listen() error = %v", err)
+	}
+	closed := make(chan struct{})
+	t.Cleanup(func() {
+		close(closed)
+		listener.Close()
+	})
+	go func() {
+		for {
+			connection, err := listener.Accept()
+			if err != nil {
+				return
+			}
+			go func() {
+				<-closed
+				connection.Close()
+			}()
+		}
+	}()
+
+	tests := []struct {
+		name          string
+		impersonation httpclient.ImpersonationOptions
+	}{
+		{
+			name:          "native",
+			impersonation: httpclient.ImpersonationOptions{Mode: httpclient.ImpersonationNative},
+		},
+		{
+			name: "fixed chrome",
+			impersonation: httpclient.ImpersonationOptions{
+				Mode:    httpclient.ImpersonationFixed,
+				Browser: httpclient.BrowserChrome,
+			},
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			client, err := httpclient.NewClient(httpclient.Options{
+				Client: httpclient.ClientOptions{Timeout: time.Second},
+				Transport: httpclient.TransportOptions{
+					TLSHandshakeTimeout: 50 * time.Millisecond,
+				},
+				Impersonation: test.impersonation,
+			})
+			if err != nil {
+				t.Fatalf("NewClient() error = %v", err)
+			}
+
+			started := time.Now()
+			_, err = client.Get("https://" + listener.Addr().String())
+			if err == nil {
+				t.Fatal("Get() error = nil, want TLS handshake timeout")
+			}
+			if elapsed := time.Since(started); elapsed >= 500*time.Millisecond {
+				t.Fatalf("TLS handshake took %s, want less than 500ms", elapsed)
+			}
+		})
+	}
+}
+
+func TestFixedBrowserAddsProfileHeadersWithoutOverwritingExplicitHeaders(t *testing.T) {
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, request *http.Request) {
+		w.Header().Set("Seen-User-Agent", request.UserAgent())
+		w.WriteHeader(http.StatusOK)
+	}))
+	t.Cleanup(server.Close)
+
+	client, err := httpclient.NewClient(httpclient.Options{
+		Impersonation: httpclient.ImpersonationOptions{
+			Mode:    httpclient.ImpersonationFixed,
+			Browser: httpclient.BrowserChrome,
+		},
+	})
+	if err != nil {
+		t.Fatalf("NewClient() error = %v", err)
+	}
+
+	response, err := client.Get(server.URL)
+	if err != nil {
+		t.Fatalf("Get() error = %v", err)
+	}
+	response.Body.Close()
+	if userAgent := response.Header.Get("Seen-User-Agent"); !strings.Contains(userAgent, "Chrome/120") {
+		t.Fatalf("profile User-Agent = %q, want Chrome/120", userAgent)
+	}
+
+	request, err := http.NewRequest(http.MethodGet, server.URL, nil)
+	if err != nil {
+		t.Fatalf("NewRequest() error = %v", err)
+	}
+	request.Header.Set("User-Agent", "Gopeed-Custom/1.0")
+	response, err = client.Do(request)
+	if err != nil {
+		t.Fatalf("Do() error = %v", err)
+	}
+	response.Body.Close()
+	if userAgent := response.Header.Get("Seen-User-Agent"); userAgent != "Gopeed-Custom/1.0" {
+		t.Fatalf("explicit User-Agent = %q, want Gopeed-Custom/1.0", userAgent)
+	}
+}
+
+func TestFixedClientCloseIdleConnectionsReachesBrowserTransport(t *testing.T) {
+	var connections atomic.Int32
+	server := httptest.NewUnstartedServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.WriteHeader(http.StatusOK)
+	}))
+	server.Config.ConnState = func(_ net.Conn, state http.ConnState) {
+		if state == http.StateNew {
+			connections.Add(1)
+		}
+	}
+	server.Start()
+	t.Cleanup(server.Close)
+
+	client, err := httpclient.NewClient(httpclient.Options{
+		Impersonation: httpclient.ImpersonationOptions{
+			Mode:    httpclient.ImpersonationFixed,
+			Browser: httpclient.BrowserChrome,
+		},
+	})
+	if err != nil {
+		t.Fatalf("NewClient() error = %v", err)
+	}
+	for attempt := range 2 {
+		response, err := client.Get(server.URL)
+		if err != nil {
+			t.Fatalf("Get() error = %v", err)
+		}
+		_, _ = io.Copy(io.Discard, response.Body)
+		response.Body.Close()
+		if attempt == 0 {
+			client.CloseIdleConnections()
+		}
+	}
+
+	if connections.Load() != 2 {
+		t.Fatalf("connections = %d, want 2", connections.Load())
+	}
+}
@@ -0,0 +1,100 @@
+package httpclienttest
+
+import (
+	"crypto/tls"
+	"errors"
+	"io"
+	"log"
+	"net/http"
+	"net/http/httptest"
+	"sync"
+	"testing"
+)
+
+type Profile string
+
+const (
+	ProfileNative     Profile = "native"
+	ProfileChrome     Profile = "chrome"
+	ProfileFirefox    Profile = "firefox"
+	ProfileSafari     Profile = "safari"
+	ProfileAnyBrowser Profile = "browser"
+)
+
+type FingerprintServerOptions struct {
+	RequiredProfile Profile
+	Handler         http.Handler
+}
+
+type FingerprintServer struct {
+	*httptest.Server
+
+	mu       sync.Mutex
+	profiles []Profile
+}
+
+func NewFingerprintServer(t testing.TB, options FingerprintServerOptions) *FingerprintServer {
+	t.Helper()
+
+	handler := options.Handler
+	if handler == nil {
+		handler = http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+			w.WriteHeader(http.StatusOK)
+		})
+	}
+	server := &FingerprintServer{
+		Server: httptest.NewUnstartedServer(handler),
+	}
+	server.EnableHTTP2 = true
+	server.Config.ErrorLog = log.New(io.Discard, "", 0)
+	server.TLS = &tls.Config{
+		GetConfigForClient: func(hello *tls.ClientHelloInfo) (*tls.Config, error) {
+			profile := classifyProfile(hello.CipherSuites)
+			server.mu.Lock()
+			server.profiles = append(server.profiles, profile)
+			server.mu.Unlock()
+			if profileMatches(profile, options.RequiredProfile) {
+				return nil, nil
+			}
+			return nil, errors.New("required TLS fingerprint was not presented")
+		},
+	}
+	server.StartTLS()
+	t.Cleanup(server.Close)
+	return server
+}
+
+func (s *FingerprintServer) Profiles() []Profile {
+	s.mu.Lock()
+	defer s.mu.Unlock()
+	return append([]Profile(nil), s.profiles...)
+}
+
+func profileMatches(actual, required Profile) bool {
+	if required == ProfileAnyBrowser {
+		return actual != ProfileNative
+	}
+	return actual == required
+}
+
+func classifyProfile(cipherSuites []uint16) Profile {
+	if len(cipherSuites) >= 5 && isGREASE(cipherSuites[0]) {
+		switch cipherSuites[4] {
+		case tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256:
+			return ProfileChrome
+		case tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384:
+			return ProfileSafari
+		}
+	}
+	if len(cipherSuites) >= 3 &&
+		cipherSuites[0] == tls.TLS_AES_128_GCM_SHA256 &&
+		cipherSuites[1] == tls.TLS_CHACHA20_POLY1305_SHA256 &&
+		cipherSuites[2] == tls.TLS_AES_256_GCM_SHA384 {
+		return ProfileFirefox
+	}
+	return ProfileNative
+}
+
+func isGREASE(value uint16) bool {
+	return value&0x0f0f == 0x0a0a && byte(value) == byte(value>>8)
+}
@@ -3,4 +3,10 @@ package bt
 type config struct {
 	ListenPort int      `json:"listenPort"`
 	Trackers   []string `json:"trackers"`
+	// SeedKeep is always keep seeding after downloading is complete, unless manually stopped.
+	SeedKeep bool `json:"seedKeep"`
+	// SeedRatio is the ratio of uploaded data to downloaded data to seed.
+	SeedRatio float64 `json:"seedRatio"`
+	// SeedTime is the time in seconds to seed after downloading is complete.
+	SeedTime int64 `json:"seedTime"`
 }
@@ -0,0 +1,49 @@
+package bt
+
+import (
+	"context"
+	"net"
+	"time"
+
+	"github.com/rs/dnscache"
+)
+
+// DnsCacheResolver resolves DNS requests for an HTTP client using an in-memory cache.
+type DnsCacheResolver struct {
+	RefreshTimeout time.Duration
+
+	resolver dnscache.Resolver
+}
+
+func (r *DnsCacheResolver) DialContext(ctx context.Context, network, address string) (net.Conn, error) {
+	host, port, err := net.SplitHostPort(address)
+	if err != nil {
+		return nil, err
+	}
+	ips, err := r.resolver.LookupHost(ctx, host)
+	if err != nil {
+		return nil, err
+	}
+	var conn net.Conn
+	for _, ip := range ips {
+		var dialer net.Dialer
+		conn, err = dialer.DialContext(ctx, network, net.JoinHostPort(ip, port))
+		if err == nil {
+			break
+		}
+	}
+	return conn, err
+}
+
+func (r *DnsCacheResolver) Run(ctx context.Context) {
+	ticker := time.NewTicker(r.RefreshTimeout)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case <-ticker.C:
+			r.resolver.Refresh(true)
+		}
+	}
+}
@@ -2,25 +2,34 @@ package bt

 import (
 	"bytes"
+	"context"
+	"fmt"
+	"io"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
 	"github.com/GopeedLab/gopeed/internal/controller"
 	"github.com/GopeedLab/gopeed/internal/fetcher"
 	"github.com/GopeedLab/gopeed/pkg/base"
 	"github.com/GopeedLab/gopeed/pkg/protocol/bt"
 	"github.com/GopeedLab/gopeed/pkg/util"
+	"github.com/RoaringBitmap/roaring"
 	"github.com/anacrolix/torrent"
 	"github.com/anacrolix/torrent/metainfo"
-	"net/http"
-	"path/filepath"
-	"sync"
-	"sync/atomic"
-	"time"
+	"github.com/anacrolix/torrent/storage"
 )

 var (
-	client        *torrent.Client
-	lock          sync.Mutex
-	torrentDirMap = make(map[string]string)
-	ftMap         = make(map[string]*fileTorrentImpl)
+	cfg       *torrent.ClientConfig
+	client    *torrent.Client
+	lock      sync.Mutex
+	closeCtx  context.Context
+	closeFunc func()
 )

 type Fetcher struct {
@@ -29,14 +38,13 @@ type Fetcher struct {

 	torrent *torrent.Torrent
 	meta    *fetcher.FetcherMeta
+	data    *fetcherData

-	torrentReady atomic.Bool
-	create       atomic.Bool
-	progress     fetcher.Progress
-}
-
-func (f *Fetcher) Name() string {
-	return "bt"
+	torrentReady    atomic.Bool
+	torrentUpload   atomic.Bool
+	torrentDropCtx  context.Context
+	torrentDropFunc func()
+	uploadDoneCh    chan any
 }

 func (f *Fetcher) Setup(ctl *controller.Controller) {
@@ -44,13 +52,12 @@ func (f *Fetcher) Setup(ctl *controller.Controller) {
 	if f.meta == nil {
 		f.meta = &fetcher.FetcherMeta{}
 	}
-	exist := f.ctl.GetConfig(&f.config)
-	if !exist {
-		f.config = &config{
-			ListenPort: 0,
-			Trackers:   []string{},
-		}
+	if f.data == nil {
+		f.data = &fetcherData{}
 	}
+	f.uploadDoneCh = make(chan any, 1)
+	f.torrentDropCtx, f.torrentDropFunc = context.WithCancel(context.Background())
+	f.ctl.GetConfig(&f.config)
 	return
 }

@@ -61,65 +68,61 @@ func (f *Fetcher) initClient() (err error) {
 	if client != nil {
 		return
 	}
-
-	cfg := torrent.NewDefaultClientConfig()
-	cfg.ListenPort = f.config.ListenPort
-	if f.ctl.ProxyUrl != nil {
-		cfg.HTTPProxy = http.ProxyURL(f.ctl.ProxyUrl)
+	if closeCtx == nil {
+		closeCtx, closeFunc = context.WithCancel(context.Background())
 	}
-	cfg.DefaultStorage = newFileOpts(newFileClientOpts{
-		ClientBaseDir: cfg.DataDir,
-		HandleFileTorrent: func(infoHash metainfo.Hash, ft *fileTorrentImpl) {
-			if dir, ok := torrentDirMap[infoHash.String()]; ok {
-				ft.setTorrentDir(dir)
-			}
-			ftMap[infoHash.String()] = ft
-		},
-	})
+
+	cfg = torrent.NewDefaultClientConfig()
+	cfg.Seed = true
+	cfg.Bep20 = fmt.Sprintf("-GP%s-", parseBep20())
+	cfg.ExtendedHandshakeClientVersion = fmt.Sprintf("Gopeed %s", base.Version)
+	cfg.ListenPort = f.config.ListenPort
+	cfg.HTTPProxy = f.ctl.GetProxy(f.meta.Req.Proxy)
+	dnsResolver := &DnsCacheResolver{RefreshTimeout: 5 * time.Minute}
+	cfg.TrackerDialContext = dnsResolver.DialContext
 	client, err = torrent.NewClient(cfg)
+	if err != nil {
+		return
+	}
+
+	closeCtx, closeFunc = context.WithCancel(context.Background())
+	go func() {
+		dnsResolver.Run(closeCtx)
+	}()
 	return
 }

-func (f *Fetcher) Resolve(req *base.Request) error {
-	if err := base.ParseReqExtra[bt.ReqExtra](req); err != nil {
-		return err
+func (f *Fetcher) Resolve(req *base.Request, opts *base.Options) error {
+	f.meta.Req = req
+	f.meta.Opts = opts
+	if f.meta.Opts == nil {
+		f.meta.Opts = &base.Options{}
 	}
-
-	if err := f.addTorrent(req); err != nil {
+	if err := f.addTorrent(req, false); err != nil {
 		return err
 	}
 	f.updateRes()
-	f.meta.Req = req
-	return nil
-}
-
-func (f *Fetcher) Create(opts *base.Options) (err error) {
-	f.create.Store(true)
-	f.meta.Opts = opts
-	if f.meta.Res != nil {
-		torrentDirMap[f.meta.Res.Hash] = f.meta.FolderPath()
-	}
 	return nil
 }

 func (f *Fetcher) Start() (err error) {
 	if !f.torrentReady.Load() {
-		if err = f.addTorrent(f.meta.Req); err != nil {
+		if err = f.addTorrent(f.meta.Req, false); err != nil {
 			return
 		}
 	}
-	if ft, ok := ftMap[f.meta.Res.Hash]; ok {
-		ft.setTorrentDir(f.meta.FolderPath())
-	}
+
 	files := f.torrent.Files()
 	// If the user does not specify the file to download, all files will be downloaded by default
-	if len(f.meta.Opts.SelectFiles) == 0 {
-		f.meta.Opts.SelectFiles = make([]int, len(files))
-		for i := range files {
-			f.meta.Opts.SelectFiles[i] = i
+	if f.data.Progress == nil {
+		if len(f.meta.Opts.SelectFiles) == 0 {
+			f.meta.Opts.SelectFiles = make([]int, len(files))
+			for i := range files {
+				f.meta.Opts.SelectFiles[i] = i
+			}
 		}
+		f.data.Progress = make(fetcher.Progress, len(f.meta.Opts.SelectFiles))
 	}
-	f.progress = make(fetcher.Progress, len(f.meta.Opts.SelectFiles))
 	if len(f.meta.Opts.SelectFiles) == len(files) {
 		f.torrent.DownloadAll()
 	} else {
@@ -128,17 +131,22 @@ func (f *Fetcher) Start() (err error) {
 			file.Download()
 		}
 	}
+	f.torrent.AllowDataDownload()
 	return
 }

 func (f *Fetcher) Pause() (err error) {
-	f.torrentReady.Store(false)
-	f.safeDrop()
+	f.torrent.DisallowDataDownload()
 	return
 }

 func (f *Fetcher) Close() (err error) {
 	f.safeDrop()
+	f.torrentDropFunc()
+	f.uploadDoneCh <- nil
+	if len(client.Torrents()) == 0 {
+		err = closeClient()
+	}
 	return nil
 }

@@ -151,66 +159,336 @@ func (f *Fetcher) safeDrop() {
 	f.torrent.Drop()
 }

-func (f *Fetcher) Wait() (err error) {
-	for {
-		if f.torrentReady.Load() && len(f.meta.Opts.SelectFiles) > 0 {
-			done := true
-			for _, selectIndex := range f.meta.Opts.SelectFiles {
-				file := f.torrent.Files()[selectIndex]
-				if file.BytesCompleted() < file.Length() {
-					done = false
-					break
-				}
-			}
-			if done {
-				// remove unselected files
-				for i, file := range f.torrent.Files() {
-					selected := false
-					for _, selectIndex := range f.meta.Opts.SelectFiles {
-						if i == selectIndex {
-							selected = true
-							break
-						}
-					}
-					if !selected {
-						util.SafeRemove(filepath.Join(f.meta.Opts.Path, f.meta.Res.Name, file.Path()))
-					}
-				}
-				break
-			}
-		}
-		time.Sleep(time.Millisecond * 500)
-	}
-	return nil
-}
-
 func (f *Fetcher) Meta() *fetcher.FetcherMeta {
 	return f.meta
 }

+func (f *Fetcher) Stats() *fetcher.Stats {
+	var stats torrent.TorrentStats
+	var pieceMap *base.PieceMap
+	pieceMapReady := false
+	peers := make([]*base.PeerStats, 0)
+	if f.torrent != nil {
+		stats = f.torrent.Stats()
+		pieceMap, pieceMapReady = buildBTPieceMap(f.torrent)
+		peers = buildBTPeers(f.torrent)
+	} else {
+		stats = torrent.TorrentStats{}
+	}
+	var snapshot any
+	if pieceMapReady {
+		snapshot = &bt.StatsSnapshot{
+			SeedBytes: f.data.SeedBytes,
+			SeedRatio: f.seedRadio(),
+			SeedTime:  f.data.SeedTime,
+			PieceMap:  pieceMap.Clone(),
+		}
+	}
+	// When completion is temporarily unknown while anacrolix restores storage
+	// or verifies pieces, the nil Snapshot tells Downloader to retain the last
+	// trusted bitset instead of replacing it with an all-empty map.
+	return &fetcher.Stats{
+		Snapshot: snapshot,
+		Runtime: &bt.StatsRuntime{
+			TotalPeers:        stats.TotalPeers,
+			ActivePeers:       stats.ActivePeers,
+			ConnectedSeeders:  stats.ConnectedSeeders,
+			ConnectedLeechers: stats.ActivePeers - stats.ConnectedSeeders,
+			Peers:             peers,
+		},
+	}
+}
+
+// buildBTPieceMap converts anacrolix's ordered completion runs to Gopeed's
+// one-bit map. ready is false until storage knows the completion state of every
+// piece; this prevents initial hash checking from briefly replacing a restored
+// map with an all-empty value.
+func buildBTPieceMap(t *torrent.Torrent) (pieceMap *base.PieceMap, ready bool) {
+	info := t.Info()
+	if info == nil {
+		return nil, false
+	}
+	pieceMap = base.NewPieceMap(info.NumPieces(), info.PieceLength)
+	ready = applyBTPieceRuns(pieceMap, t.PieceStateRuns())
+	return pieceMap, ready
+}
+
+func applyBTPieceRuns(pieceMap *base.PieceMap, runs []torrent.PieceStateRun) (ready bool) {
+	ready = true
+	pieceIndex := 0
+	for _, run := range runs {
+		if !run.Ok {
+			ready = false
+		}
+		completed := run.Ok && run.Complete
+		for range run.Length {
+			if pieceIndex >= pieceMap.PieceCount() {
+				return ready
+			}
+			_ = pieceMap.Update(pieceIndex, completed)
+			pieceIndex++
+		}
+	}
+	return ready && pieceIndex == pieceMap.PieceCount()
+}
+
+func buildBTPeers(t *torrent.Torrent) []*base.PeerStats {
+	connections := t.PeerConns()
+	totalPieces := 0
+	var missingWantedPieces *roaring.Bitmap
+	// Magnet torrents can connect to peers before their metadata arrives. Keep
+	// those runtime peer stats, but leave completion and relevance unavailable
+	// until the metadata provides a trusted total piece count.
+	if info := t.Info(); info != nil {
+		totalPieces = info.NumPieces()
+		missingWantedPieces = btMissingWantedPieces(t.PieceStateRuns(), totalPieces)
+	}
+	peers := make([]*base.PeerStats, 0, len(connections))
+	for _, connection := range connections {
+		peerStats := connection.Stats()
+		peers = append(peers, &base.PeerStats{
+			Address:       safeBTPeerAddress(connection),
+			Client:        btPeerClient(connection),
+			DownloadSpeed: int64(peerStats.DownloadRate),
+			UploadSpeed:   int64(peerStats.LastWriteUploadRate),
+			PieceCount:    peerStats.RemotePieceCount,
+			Completion:    btPeerCompletion(peerStats.RemotePieceCount, totalPieces),
+			Relevance:     btPeerRelevance(connection.PeerPieces(), missingWantedPieces),
+			Source:        normalizeBTPeerSource(connection.Discovery),
+			Transport:     normalizeBTTransport(connection.Network),
+		})
+	}
+	return peers
+}
+
+// btPeerCompletion converts anacrolix's remote piece count into the ratio the
+// API exposes. A nil value distinguishes unavailable metadata from a real 0%.
+func btPeerCompletion(pieceCount, totalPieces int) *float64 {
+	if totalPieces <= 0 {
+		return nil
+	}
+	if pieceCount < 0 {
+		pieceCount = 0
+	} else if pieceCount > totalPieces {
+		pieceCount = totalPieces
+	}
+	completion := float64(pieceCount) / float64(totalPieces)
+	return &completion
+}
+
+// btMissingWantedPieces builds the denominator used by peer relevance. Pieces
+// belonging only to skipped files are excluded because their priority is none.
+func btMissingWantedPieces(runs []torrent.PieceStateRun, totalPieces int) *roaring.Bitmap {
+	if totalPieces <= 0 {
+		return nil
+	}
+	missing := roaring.New()
+	pieceIndex := 0
+	for _, run := range runs {
+		for range run.Length {
+			if pieceIndex >= totalPieces {
+				return nil
+			}
+			if run.Priority != torrent.PiecePriorityNone && !(run.Ok && run.Complete) {
+				missing.Add(uint32(pieceIndex))
+			}
+			pieceIndex++
+		}
+	}
+	if pieceIndex != totalPieces {
+		return nil
+	}
+	return missing
+}
+
+// btPeerRelevance reports how much of the local wanted, missing set the remote
+// peer can provide. A zero value is meaningful; nil means there is no denominator.
+func btPeerRelevance(peerPieces, missingWantedPieces *roaring.Bitmap) *float64 {
+	if peerPieces == nil || missingWantedPieces == nil || missingWantedPieces.IsEmpty() {
+		return nil
+	}
+	relevantPieces := roaring.And(peerPieces, missingWantedPieces).GetCardinality()
+	relevance := float64(relevantPieces) / float64(missingWantedPieces.GetCardinality())
+	return &relevance
+}
+
+// A uTP socket may close between PeerConns and this snapshot. Some uTP address
+// implementations panic after close, so one disappearing address must not make
+// the entire stats endpoint fail.
+func safeBTPeerAddress(connection *torrent.PeerConn) (address string) {
+	defer func() {
+		if recover() != nil {
+			address = ""
+		}
+	}()
+	if connection.RemoteAddr == nil {
+		return ""
+	}
+	return connection.RemoteAddr.String()
+}
+
+func btPeerClient(connection *torrent.PeerConn) string {
+	value := connection.PeerClientName.Load()
+	if value == nil {
+		return ""
+	}
+	return fmt.Sprint(value)
+}
+
+func normalizeBTPeerSource(source torrent.PeerSource) string {
+	switch source {
+	case torrent.PeerSourceTracker:
+		return "tracker"
+	case torrent.PeerSourceDhtGetPeers, torrent.PeerSourceDhtAnnouncePeer:
+		return "dht"
+	case torrent.PeerSourcePex:
+		return "pex"
+	case torrent.PeerSourceIncoming:
+		return "incoming"
+	case torrent.PeerSourceDirect:
+		return "direct"
+	case torrent.PeerSourceUtHolepunch:
+		return "holepunch"
+	default:
+		return "unknown"
+	}
+}
+
+func normalizeBTTransport(network string) string {
+	network = strings.ToLower(network)
+	switch {
+	case strings.Contains(network, "webrtc"):
+		return "webrtc"
+	case strings.Contains(network, "udp"):
+		// anacrolix labels uTP sockets with their underlying udp network.
+		return "utp"
+	case strings.Contains(network, "tcp"):
+		return "tcp"
+	default:
+		return "unknown"
+	}
+}
+
 func (f *Fetcher) Progress() fetcher.Progress {
 	if !f.torrentReady.Load() {
-		return f.progress
+		return f.data.Progress
 	}
-	for i := range f.progress {
+	for i := range f.data.Progress {
 		selectIndex := f.meta.Opts.SelectFiles[i]
 		file := f.torrent.Files()[selectIndex]
-		f.progress[i] = file.BytesCompleted()
+		f.data.Progress[i] = file.BytesCompleted()
 	}
-	return f.progress
+	return f.data.Progress
+}
+
+func (f *Fetcher) Wait() (err error) {
+	for {
+		select {
+		case <-f.torrentDropCtx.Done():
+			return
+		case <-time.After(time.Second):
+			if f.torrentReady.Load() && len(f.meta.Opts.SelectFiles) > 0 {
+				if f.isDone() {
+					// remove unselected files
+					for i, file := range f.torrent.Files() {
+						selected := false
+						for _, selectIndex := range f.meta.Opts.SelectFiles {
+							if i == selectIndex {
+								selected = true
+								break
+							}
+						}
+						if !selected {
+							util.SafeRemove(filepath.Join(f.meta.Opts.Path, f.meta.Res.Name, file.Path()))
+						}
+					}
+					return
+				}
+			}
+		}
+	}
+}
+
+func (f *Fetcher) isDone() bool {
+	if f.meta.Opts == nil {
+		return false
+	}
+	for _, selectIndex := range f.meta.Opts.SelectFiles {
+		file := f.torrent.Files()[selectIndex]
+		if file.BytesCompleted() < file.Length() {
+			return false
+		}
+	}
+	return true
+}
+
+// Patch modifies the BT task settings.
+// Invalid file indices are silently ignored.
+func (f *Fetcher) Patch(req *base.Request, opts *base.Options) error {
+	if opts == nil {
+		return nil
+	}
+
+	if opts.SelectFiles != nil {
+		selectFiles := opts.SelectFiles
+
+		// Get file count from resource metadata
+		fileCount := 0
+		if f.meta.Res != nil {
+			fileCount = len(f.meta.Res.Files)
+		}
+
+		// Filter out invalid indices (silently ignore)
+		validSelectFiles := make([]int, 0, len(selectFiles))
+		for _, idx := range selectFiles {
+			if idx >= 0 && idx < fileCount {
+				validSelectFiles = append(validSelectFiles, idx)
+			}
+		}
+
+		if f.torrent != nil {
+			files := f.torrent.Files()
+
+			// Cancel all current file downloads first
+			f.torrent.CancelPieces(0, f.torrent.NumPieces())
+
+			// Apply new file selection
+			if len(validSelectFiles) == len(files) {
+				f.torrent.DownloadAll()
+			} else {
+				for _, selectIndex := range validSelectFiles {
+					file := files[selectIndex]
+					file.Download()
+				}
+			}
+		}
+
+		f.meta.Opts.SelectFiles = validSelectFiles
+		// Recalculate the resource size based on new selection
+		if f.meta.Res != nil {
+			f.meta.Res.CalcSize(validSelectFiles)
+		}
+		// Reset progress tracking for new file selection
+		f.data.Progress = make(fetcher.Progress, len(validSelectFiles))
+	}
+
+	return nil
 }

 func (f *Fetcher) updateRes() {
 	res := &base.Resource{
-		Name:  f.torrent.Name(),
 		Range: true,
 		Files: make([]*base.FileInfo, len(f.torrent.Files())),
 		Hash:  f.torrent.InfoHash().String(),
 	}
+	// Directory torrent
+	if f.torrent.Info().Length == 0 {
+		res.Name = f.torrent.Name()
+	}
 	for i, file := range f.torrent.Files() {
 		res.Files[i] = &base.FileInfo{
 			Name: filepath.Base(file.DisplayPath()),
-			Path: util.Dir(file.Path()),
+			Path: util.Dir(file.DisplayPath()),
 			Size: file.Length(),
 		}
 	}
@@ -221,77 +499,309 @@ func (f *Fetcher) updateRes() {
 	}
 }

-func (f *Fetcher) addTorrent(req *base.Request) (err error) {
+func (f *Fetcher) Upload() (err error) {
+	return f.addTorrent(f.meta.Req, true)
+}
+
+func (f *Fetcher) doUpload(fromUpload bool) {
+	if !f.torrentUpload.CompareAndSwap(false, true) {
+		return
+	}
+
+	// Check and update seed data
+	lastData := &fetcherData{
+		SeedBytes: f.data.SeedBytes,
+		SeedTime:  f.data.SeedTime,
+	}
+	var doneTime int64 = 0
+	for {
+		select {
+		case <-f.torrentDropCtx.Done():
+			return
+		case <-time.After(time.Second):
+			if !f.torrentReady.Load() {
+				continue
+			}
+
+			stats := f.torrentStats()
+			f.data.SeedBytes = lastData.SeedBytes + stats.BytesWrittenData.Int64()
+
+			// Check is download complete, if not don't check and stop seeding
+			if !fromUpload && !f.isDone() {
+				continue
+			}
+			if doneTime == 0 {
+				doneTime = time.Now().Unix()
+			}
+			f.data.SeedTime = lastData.SeedTime + time.Now().Unix() - doneTime
+
+			// If the seed forever is true, keep seeding
+			if f.config.SeedKeep {
+				continue
+			}
+
+			// If the seed ratio is reached, stop seeding
+			if f.config.SeedRatio > 0 {
+				seedRadio := f.seedRadio()
+				if seedRadio >= f.config.SeedRatio {
+					f.Close()
+					break
+				}
+			}
+
+			// If the seed time is reached, stop seeding
+			if f.config.SeedTime > 0 {
+				if f.data.SeedTime >= f.config.SeedTime {
+					f.Close()
+					break
+				}
+			}
+		}
+	}
+}
+
+// Get torrent stats maybe panic, see https://github.com/anacrolix/torrent/issues/972
+func (f *Fetcher) torrentStats() torrent.TorrentStats {
+	defer func() {
+		if r := recover(); r != nil {
+			// ignore panic
+		}
+	}()
+
+	return f.torrent.Stats()
+}
+
+func (f *Fetcher) UploadedBytes() int64 {
+	return f.data.SeedBytes
+}
+
+func (f *Fetcher) WaitUpload() (err error) {
+	<-f.uploadDoneCh
+	return nil
+}
+
+func (f *Fetcher) addTorrent(req *base.Request, fromUpload bool) (err error) {
+	if err = base.ParseReqExtra[bt.ReqExtra](req); err != nil {
+		return
+	}
 	if err = f.initClient(); err != nil {
 		return
 	}
 	schema := util.ParseSchema(req.URL)
+	privateTorrent := false
+	var spec *torrent.TorrentSpec
 	if schema == "MAGNET" {
-		f.torrent, err = client.AddMagnet(req.URL)
-	} else if schema == "APPLICATION/X-BITTORRENT" {
-		_, data := util.ParseDataUri(req.URL)
-		buf := bytes.NewBuffer(data)
-		var metaInfo *metainfo.MetaInfo
-		metaInfo, err = metainfo.Load(buf)
+		spec, err = torrent.TorrentSpecFromMagnetUri(req.URL)
 		if err != nil {
+			return
+		}
+	} else {
+		var reader io.Reader
+		if schema == "FILE" {
+			fileUrl, _ := url.Parse(req.URL)
+			filePath := fileUrl.Path[1:]
+			reader, err = os.Open(filePath)
+			if err != nil {
+				return
+			}
+		} else if schema == "DATA" {
+			_, data := util.ParseDataUri(req.URL)
+			reader = bytes.NewBuffer(data)
+		} else {
+			reader, err = os.Open(req.URL)
+			if err != nil {
+				return
+			}
+			defer reader.(io.Closer).Close()
+		}
+
+		var metaInfo *metainfo.MetaInfo
+		metaInfo, err = metainfo.Load(reader)
+		// Hotfix for https://github.com/anacrolix/torrent/issues/992, ignore "expected EOF" error
+		// TODO remove this after the issue is fixed
+		if err != nil && !strings.Contains(err.Error(), "expected EOF") {
 			return err
 		}
-		f.torrent, err = client.AddTorrent(metaInfo)
-	} else {
-		f.torrent, err = client.AddTorrentFromFile(req.URL)
+
+		info, er := metaInfo.UnmarshalInfo()
+		if er != nil {
+			return er
+		}
+
+		if info.Private != nil && *info.Private {
+			privateTorrent = true
+		}
+		spec, err = torrent.TorrentSpecFromMetaInfoErr(metaInfo)
+		if err != nil {
+			return
+		}
 	}
+	spec.Storage = storage.NewFileOpts(storage.NewFileClientOpts{
+		ClientBaseDir: cfg.DataDir,
+		TorrentDirMaker: func(baseDir string, info *metainfo.Info, infoHash metainfo.Hash) string {
+			return f.meta.Opts.Path
+		},
+	})
+	f.torrent, _, err = client.AddTorrentSpec(spec)
 	if err != nil {
 		return
 	}

-	// use map to deduplicate
-	trackers := make(map[string]bool)
-	if req.Extra != nil {
-		extra := req.Extra.(*bt.ReqExtra)
-		if len(extra.Trackers) > 0 {
-			for _, tracker := range extra.Trackers {
+	// Do not add external tracker to a private torrent.
+	if !privateTorrent {
+		// use map to deduplicate
+		trackers := make(map[string]bool)
+		if req.Extra != nil {
+			extra := req.Extra.(*bt.ReqExtra)
+			if len(extra.Trackers) > 0 {
+				for _, tracker := range extra.Trackers {
+					trackers[tracker] = true
+				}
+			}
+		}
+		if len(f.config.Trackers) > 0 {
+			for _, tracker := range f.config.Trackers {
 				trackers[tracker] = true
 			}
 		}
-	}
-	if len(f.config.Trackers) > 0 {
-		for _, tracker := range f.config.Trackers {
-			trackers[tracker] = true
+		if len(trackers) > 0 {
+			announceList := make([][]string, 0)
+			for tracker := range trackers {
+				announceList = append(announceList, []string{tracker})
+			}
+			f.torrent.AddTrackers(announceList)
 		}
 	}
-	if len(trackers) > 0 {
-		announceList := make([][]string, 0)
-		for tracker := range trackers {
-			announceList = append(announceList, []string{tracker})
-		}
-		f.torrent.AddTrackers(announceList)
-	}
 	<-f.torrent.GotInfo()
 	f.torrentReady.Store(true)
+
+	go f.doUpload(fromUpload)
 	return
 }

-type FetcherBuilder struct {
+func (f *Fetcher) seedRadio() float64 {
+	var bytesRead int64
+	if f.Meta().Res != nil {
+		bytesRead = f.Meta().Res.Size
+	} else {
+		bytesRead = 0
+	}
+	if bytesRead <= 0 {
+		return 0
+	}
+
+	return float64(f.data.SeedBytes) / float64(bytesRead)
 }

-var schemes = []string{"FILE", "MAGNET", "APPLICATION/X-BITTORRENT"}
-
-func (fb *FetcherBuilder) Schemes() []string {
-	return schemes
+type fetcherData struct {
+	Progress  fetcher.Progress
+	SeedBytes int64
+	// SeedTime is the time in seconds to seed after downloading is complete.
+	SeedTime int64
 }

-func (fb *FetcherBuilder) Build() fetcher.Fetcher {
+func closeClient() error {
+	lock.Lock()
+	defer lock.Unlock()
+
+	if closeFunc != nil {
+		closeFunc()
+	}
+	if client != nil {
+		errs := client.Close()
+		if len(errs) > 0 {
+			return errs[0]
+		}
+		client = nil
+		closeCtx = nil
+		closeFunc = nil
+	}
+	return nil
+}
+
+type FetcherManager struct {
+}
+
+func (fm *FetcherManager) Name() string {
+	return "bt"
+}
+
+func (fm *FetcherManager) Filters() []*fetcher.SchemeFilter {
+	return []*fetcher.SchemeFilter{
+		{
+			Type:    fetcher.FilterTypeUrl,
+			Pattern: "MAGNET",
+		},
+		{
+			Type:    fetcher.FilterTypeFile,
+			Pattern: "TORRENT",
+		},
+		{
+			Type:    fetcher.FilterTypeBase64,
+			Pattern: "APPLICATION/X-BITTORRENT",
+		},
+	}
+}
+
+func (fm *FetcherManager) Build() fetcher.Fetcher {
 	return &Fetcher{}
 }

-func (fb *FetcherBuilder) Store(f fetcher.Fetcher) (data any, err error) {
-	return nil, nil
+func (fm *FetcherManager) ParseName(u string) string {
+	var name string
+	url, err := url.Parse(u)
+	if err != nil {
+		return ""
+	}
+
+	params := url.Query()
+	if params.Get("dn") != "" {
+		return params.Get("dn")
+	}
+	if params.Get("xt") != "" {
+		xt := strings.Split(params.Get("xt"), ":")
+		return xt[len(xt)-1]
+	}
+	return name
 }

-func (fb *FetcherBuilder) Restore() (v any, f func(meta *fetcher.FetcherMeta, v any) fetcher.Fetcher) {
-	return nil, func(meta *fetcher.FetcherMeta, v any) fetcher.Fetcher {
+func (fm *FetcherManager) AutoRename() bool {
+	return false
+}
+
+func (fm *FetcherManager) DefaultConfig() any {
+	return &config{
+		ListenPort: 0,
+		Trackers:   []string{},
+		SeedKeep:   false,
+		SeedRatio:  1.0,
+		SeedTime:   120 * 60,
+	}
+}
+
+func (fm *FetcherManager) Store(f fetcher.Fetcher) (data any, err error) {
+	_f := f.(*Fetcher)
+	return _f.data, nil
+}
+
+func (fm *FetcherManager) Restore() (v any, f func(meta *fetcher.FetcherMeta, v any) fetcher.Fetcher) {
+	return &fetcherData{}, func(meta *fetcher.FetcherMeta, v any) fetcher.Fetcher {
 		return &Fetcher{
 			meta: meta,
+			data: v.(*fetcherData),
 		}
 	}
 }
+
+func (fm *FetcherManager) Close() error {
+	return closeClient()
+}
+
+// parse version to bep20 format, fixed length 4, if not enough, fill 0
+func parseBep20() string {
+	s := strings.ReplaceAll(base.Version, ".", "")
+	if len(s) < 4 {
+		s += strings.Repeat("0", 4-len(s))
+	}
+	return s
+}
@@ -3,16 +3,18 @@ package bt
 import (
 	"encoding/base64"
 	"encoding/json"
+	gohttp "net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+
 	"github.com/GopeedLab/gopeed/internal/controller"
 	"github.com/GopeedLab/gopeed/internal/fetcher"
 	"github.com/GopeedLab/gopeed/internal/test"
 	"github.com/GopeedLab/gopeed/pkg/base"
 	"github.com/GopeedLab/gopeed/pkg/protocol/bt"
-	"github.com/GopeedLab/gopeed/pkg/util"
-	"net/url"
-	"os"
-	"reflect"
-	"testing"
 )

 func TestFetcher_Resolve_Torrent(t *testing.T) {
@@ -29,13 +31,12 @@ func TestFetcher_Resolve_DataUri_Torrent(t *testing.T) {
 	dataUri := "data:application/x-bittorrent;base64," + base64.StdEncoding.EncodeToString(buf)
 	err = fetcher.Resolve(&base.Request{
 		URL: dataUri,
-	})
+	}, nil)
 	if err != nil {
 		panic(err)
 	}

 	want := &base.Resource{
-		Name:  "ubuntu-22.04-live-server-amd64.iso",
 		Size:  1466714112,
 		Range: true,
 		Files: []*base.FileInfo{
@@ -60,61 +61,308 @@ func TestFetcher_ResolveWithProxy(t *testing.T) {
 	proxyListener := test.StartSocks5Server(usr, pwd)
 	defer proxyListener.Close()

-	doResolve(t, buildConfigFetcher(util.BuildProxyUrl("socks5", proxyListener.Addr().String(), usr, pwd)))
+	doResolve(t, buildConfigFetcher(&base.DownloaderProxyConfig{
+		Enable: true,
+		System: false,
+		Scheme: "socks5",
+		Host:   proxyListener.Addr().String(),
+		Usr:    usr,
+		Pwd:    pwd,
+	}))
 }

 func doResolve(t *testing.T, fetcher fetcher.Fetcher) {
-	err := fetcher.Resolve(&base.Request{
-		URL: "./testdata/ubuntu-22.04-live-server-amd64.iso.torrent",
-		Extra: bt.ReqExtra{
-			Trackers: []string{
-				"udp://tracker.birkenwald.de:6969/announce",
-				"udp://tracker.bitsearch.to:1337/announce",
+	t.Run("Resolve Single File", func(t *testing.T) {
+		err := fetcher.Resolve(&base.Request{
+			URL: "./testdata/ubuntu-22.04-live-server-amd64.iso.torrent",
+			Extra: bt.ReqExtra{
+				Trackers: []string{
+					"udp://tracker.birkenwald.de:6969/announce",
+					"udp://tracker.bitsearch.to:1337/announce",
+				},
 			},
-		},
-	})
-	if err != nil {
-		panic(err)
-	}
+		}, nil)
+		if err != nil {
+			panic(err)
+		}

-	want := &base.Resource{
-		Name:  "ubuntu-22.04-live-server-amd64.iso",
-		Size:  1466714112,
-		Range: true,
-		Files: []*base.FileInfo{
-			{
-				Name: "ubuntu-22.04-live-server-amd64.iso",
-				Size: 1466714112,
+		want := &base.Resource{
+			Size:  1466714112,
+			Range: true,
+			Files: []*base.FileInfo{
+				{
+					Name: "ubuntu-22.04-live-server-amd64.iso",
+					Size: 1466714112,
+				},
 			},
-		},
-		Hash: "8a55cfbd5ca5d11507364765936c4f9e55b253ed",
+			Hash: "8a55cfbd5ca5d11507364765936c4f9e55b253ed",
+		}
+		if !reflect.DeepEqual(want, fetcher.Meta().Res) {
+			t.Errorf("Resolve Single File Resolve() got = %v, want %v", fetcher.Meta().Res, want)
+		}
+	})
+
+	t.Run("Resolve Multi Files", func(t *testing.T) {
+		err := fetcher.Resolve(&base.Request{
+			URL: "./testdata/test.torrent",
+			Extra: bt.ReqExtra{
+				Trackers: []string{
+					"udp://tracker.birkenwald.de:6969/announce",
+					"udp://tracker.bitsearch.to:1337/announce",
+				},
+			},
+		}, nil)
+		if err != nil {
+			panic(err)
+		}
+
+		want := &base.Resource{
+			Name:  "test",
+			Size:  107484864,
+			Range: true,
+			Files: []*base.FileInfo{
+				{
+					Name: "c.txt",
+					Path: "path",
+					Size: 98501754,
+				},
+				{
+					Name: "b.txt",
+					Size: 8904996,
+				},
+				{
+					Name: "a.txt",
+					Size: 78114,
+				},
+			},
+			Hash: "ccbc92b0cd8deec16a2ef4be242a8c9243b1cedb",
+		}
+		if !reflect.DeepEqual(want, fetcher.Meta().Res) {
+			t.Errorf("Resolve Multi Files Resolve() got = %v, want %v", fetcher.Meta().Res, want)
+		}
+	})
+
+	t.Run("Resolve Unclean Torrent", func(t *testing.T) {
+		err := fetcher.Resolve(&base.Request{
+			URL: "./testdata/test.unclean.torrent",
+		}, nil)
+		if err != nil {
+			t.Errorf("Resolve Unclean Torrent Resolve() got = %v, want nil", err)
+		}
+	})
+
+	t.Run("Resolve file scheme Torrent", func(t *testing.T) {
+		file, _ := filepath.Abs("./testdata/test.unclean.torrent")
+		uri := "file:///" + file
+		err := fetcher.Resolve(&base.Request{
+			URL: uri,
+		}, nil)
+		if err != nil {
+			t.Errorf("Resolve file scheme Torrent Resolve() got = %v, want nil", err)
+		}
+	})
+}
+
+func TestFetcherManager_ParseName(t *testing.T) {
+	type args struct {
+		u string
 	}
-	if !reflect.DeepEqual(want, fetcher.Meta().Res) {
-		t.Errorf("Resolve() got = %v, want %v", fetcher.Meta().Res, want)
+	tests := []struct {
+		name string
+		args args
+		want string
+	}{
+		{
+			name: "broken url",
+			args: args{
+				u: "magnet://!@#%github.com",
+			},
+			want: "",
+		},
+		{
+			name: "dn",
+			args: args{
+				u: "magnet:?xt=urn:btih:8a55cfbd5ca5d11507364765936c4f9e55b253ed&dn=ubuntu-22.04-live-server-amd64.iso",
+			},
+			want: "ubuntu-22.04-live-server-amd64.iso",
+		},
+		{
+			name: "no dn",
+			args: args{
+				u: "magnet:?xt=urn:btih:8a55cfbd5ca5d11507364765936c4f9e55b253ed",
+			},
+			want: "8a55cfbd5ca5d11507364765936c4f9e55b253ed",
+		},
+		{
+			name: "non standard magnet",
+			args: args{
+				u: "magnet:?xxt=abcd",
+			},
+			want: "",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			fm := &FetcherManager{}
+			if got := fm.ParseName(tt.args.u); got != tt.want {
+				t.Errorf("ParseName() = %v, want %v", got, tt.want)
+			}
+		})
 	}
 }

 func buildFetcher() fetcher.Fetcher {
-	fetcher := new(FetcherBuilder).Build()
-	fetcher.Setup(controller.NewController())
+	fb := new(FetcherManager)
+	fetcher := fb.Build()
+	newController := controller.NewController()
+	newController.GetConfig = func(v any) {
+		json.Unmarshal([]byte(test.ToJson(fb.DefaultConfig())), v)
+	}
+	fetcher.Setup(newController)
 	return fetcher
 }

-func buildConfigFetcher(proxyUrl *url.URL) fetcher.Fetcher {
-	fetcher := new(FetcherBuilder).Build()
+func buildConfigFetcher(proxyConfig *base.DownloaderProxyConfig) fetcher.Fetcher {
+	fetcher := new(FetcherManager).Build()
 	newController := controller.NewController()
 	mockCfg := config{
 		Trackers: []string{
 			"udp://tracker.birkenwald.de:6969/announce",
 			"udp://tracker.bitsearch.to:1337/announce",
 		}}
-	newController.GetConfig = func(v any) bool {
-		if err := json.Unmarshal([]byte(test.ToJson(mockCfg)), v); err != nil {
-			return false
-		}
-		return true
+	newController.GetConfig = func(v any) {
+		json.Unmarshal([]byte(test.ToJson(mockCfg)), v)
+	}
+	newController.GetProxy = func(requestProxy *base.RequestProxy) func(*gohttp.Request) (*url.URL, error) {
+		return proxyConfig.ToHandler()
 	}
-	newController.ProxyUrl = proxyUrl
 	fetcher.Setup(newController)
 	return fetcher
 }
+
+// TestFetcher_Patch tests the Patch functionality for BT fetcher.
+// It tests modifying selected files after Resolve (without downloading).
+func TestFetcher_Patch(t *testing.T) {
+	f := buildFetcher()
+
+	// Resolve a multi-file torrent
+	err := f.Resolve(&base.Request{
+		URL: "./testdata/test.torrent",
+	}, nil)
+	if err != nil {
+		t.Fatalf("Resolve failed: %v", err)
+	}
+
+	// Verify initial state: 3 files, all selected by default
+	meta := f.Meta()
+	if len(meta.Res.Files) != 3 {
+		t.Fatalf("Expected 3 files, got %d", len(meta.Res.Files))
+	}
+	if len(meta.Opts.SelectFiles) != 3 {
+		t.Fatalf("Expected 3 selected files, got %d", len(meta.Opts.SelectFiles))
+	}
+
+	// Total size of all files: 107484864
+	totalSize := int64(107484864)
+	if meta.Res.Size != totalSize {
+		t.Fatalf("Expected total size %d, got %d", totalSize, meta.Res.Size)
+	}
+
+	t.Run("Patch with valid indices", func(t *testing.T) {
+		// Select only file 0 and 2 (c.txt and a.txt)
+		err := f.Patch(nil, &base.Options{
+			SelectFiles: []int{0, 2},
+		})
+		if err != nil {
+			t.Fatalf("Patch failed: %v", err)
+		}
+
+		meta := f.Meta()
+		if !reflect.DeepEqual(meta.Opts.SelectFiles, []int{0, 2}) {
+			t.Errorf("Expected SelectFiles [0, 2], got %v", meta.Opts.SelectFiles)
+		}
+
+		// Size should be recalculated: c.txt (98501754) + a.txt (78114) = 98579868
+		expectedSize := int64(98501754 + 78114)
+		if meta.Res.Size != expectedSize {
+			t.Errorf("Expected size %d, got %d", expectedSize, meta.Res.Size)
+		}
+	})
+
+	t.Run("Patch with invalid indices are silently ignored", func(t *testing.T) {
+		// Mix of valid (0, 1) and invalid (-1, 5, 100) indices
+		err := f.Patch(nil, &base.Options{
+			SelectFiles: []int{-1, 0, 5, 1, 100},
+		})
+		if err != nil {
+			t.Fatalf("Patch should not return error for invalid indices: %v", err)
+		}
+
+		meta := f.Meta()
+		// Only valid indices 0 and 1 should remain
+		if !reflect.DeepEqual(meta.Opts.SelectFiles, []int{0, 1}) {
+			t.Errorf("Expected SelectFiles [0, 1], got %v", meta.Opts.SelectFiles)
+		}
+
+		// Size should be: c.txt (98501754) + b.txt (8904996) = 107406750
+		expectedSize := int64(98501754 + 8904996)
+		if meta.Res.Size != expectedSize {
+			t.Errorf("Expected size %d, got %d", expectedSize, meta.Res.Size)
+		}
+	})
+
+	t.Run("Patch with all invalid indices results in empty selection", func(t *testing.T) {
+		err := f.Patch(nil, &base.Options{
+			SelectFiles: []int{-5, 10, 999},
+		})
+		if err != nil {
+			t.Fatalf("Patch should not return error: %v", err)
+		}
+
+		meta := f.Meta()
+		if len(meta.Opts.SelectFiles) != 0 {
+			t.Errorf("Expected empty SelectFiles, got %v", meta.Opts.SelectFiles)
+		}
+
+		// Note: CalcSize with empty selectFiles calculates total size of all files
+		// This is by design - empty selection in CalcSize means "all files"
+		// But SelectFiles being empty means no files are selected for download
+		if meta.Res.Size != totalSize {
+			t.Errorf("Expected size %d (CalcSize with empty slice = all files), got %d", totalSize, meta.Res.Size)
+		}
+	})
+
+	t.Run("Patch with nil opts does nothing", func(t *testing.T) {
+		// First set a known state
+		f.Patch(nil, &base.Options{SelectFiles: []int{1}})
+		prevSelectFiles := f.Meta().Opts.SelectFiles
+
+		// Patch with nil opts
+		err := f.Patch(nil, nil)
+		if err != nil {
+			t.Fatalf("Patch with nil opts should not fail: %v", err)
+		}
+
+		// Should remain unchanged
+		if !reflect.DeepEqual(f.Meta().Opts.SelectFiles, prevSelectFiles) {
+			t.Errorf("SelectFiles should remain unchanged after nil opts Patch")
+		}
+	})
+
+	t.Run("Patch progress array is resized", func(t *testing.T) {
+		btFetcher := f.(*Fetcher)
+		// Initialize progress array
+		btFetcher.data.Progress = make(fetcher.Progress, 3)
+
+		err := f.Patch(nil, &base.Options{
+			SelectFiles: []int{0, 2},
+		})
+		if err != nil {
+			t.Fatalf("Patch failed: %v", err)
+		}
+
+		if len(btFetcher.data.Progress) != 2 {
+			t.Errorf("Expected Progress length 2, got %d", len(btFetcher.data.Progress))
+		}
+	})
+}
@@ -1,214 +0,0 @@
-// modify from github.com/anacrolix/torrent/storage/file.go
-
-package bt
-
-import (
-	"fmt"
-	"github.com/anacrolix/torrent/storage"
-	"io"
-	"os"
-	"path/filepath"
-
-	"github.com/anacrolix/missinggo/v2"
-
-	"github.com/anacrolix/torrent/common"
-	"github.com/anacrolix/torrent/metainfo"
-	"github.com/anacrolix/torrent/segments"
-)
-
-// File-based storage for torrents, that isn't yet bound to a particular torrent.
-type fileClientImpl struct {
-	opts newFileClientOpts
-}
-
-type newFileClientOpts struct {
-	// The base directory for all downloads.
-	ClientBaseDir     string
-	HandleFileTorrent func(infoHash metainfo.Hash, ft *fileTorrentImpl)
-	FilePathMaker     storage.FilePathMaker
-	PieceCompletion   storage.PieceCompletion
-}
-
-func newFileOpts(opts newFileClientOpts) storage.ClientImplCloser {
-	if opts.FilePathMaker == nil {
-		opts.FilePathMaker = func(opts storage.FilePathMakerOpts) string {
-			var parts []string
-			if opts.Info.Name != metainfo.NoName {
-				parts = append(parts, opts.Info.Name)
-			}
-			return filepath.Join(append(parts, opts.File.Path...)...)
-		}
-	}
-	if opts.PieceCompletion == nil {
-		ret, err := storage.NewDefaultPieceCompletionForDir(opts.ClientBaseDir)
-		if err != nil {
-			ret = storage.NewMapPieceCompletion()
-		}
-		opts.PieceCompletion = ret
-	}
-	return fileClientImpl{opts}
-}
-
-func (fs fileClientImpl) Close() error {
-	return fs.opts.PieceCompletion.Close()
-}
-
-func (fs fileClientImpl) OpenTorrent(info *metainfo.Info, infoHash metainfo.Hash) (_ storage.TorrentImpl, err error) {
-	upvertedFiles := info.UpvertedFiles()
-	files := make([]file, 0, len(upvertedFiles))
-	for _, fileInfo := range upvertedFiles {
-		filePath := filepath.Join("", fs.opts.FilePathMaker(storage.FilePathMakerOpts{
-			Info: info,
-			File: &fileInfo,
-		}))
-		f := file{
-			rawPath: filePath,
-			path:    filePath,
-			length:  fileInfo.Length,
-		}
-		if f.length == 0 {
-			err = CreateNativeZeroLengthFile(f.path)
-			if err != nil {
-				err = fmt.Errorf("creating zero length file: %w", err)
-				return
-			}
-		}
-		files = append(files, f)
-	}
-	t := &fileTorrentImpl{
-		files,
-		segments.NewIndex(common.LengthIterFromUpvertedFiles(upvertedFiles)),
-		infoHash,
-		fs.opts.PieceCompletion,
-	}
-	fs.opts.HandleFileTorrent(infoHash, t)
-	return storage.TorrentImpl{
-		Piece: t.Piece,
-		Close: t.Close,
-	}, nil
-}
-
-type file struct {
-	// The safe, OS-local file path.
-	rawPath string
-	path    string
-	length  int64
-}
-
-type fileTorrentImpl struct {
-	files          []file
-	segmentLocater segments.Index
-	infoHash       metainfo.Hash
-	completion     storage.PieceCompletion
-}
-
-func (fts *fileTorrentImpl) Piece(p metainfo.Piece) storage.PieceImpl {
-	// Create a view onto the file-based torrent storage.
-	_io := fileTorrentImplIO{fts}
-	// Return the appropriate segments of this.
-	return &filePieceImpl{
-		fts,
-		p,
-		missinggo.NewSectionWriter(_io, p.Offset(), p.Length()),
-		io.NewSectionReader(_io, p.Offset(), p.Length()),
-	}
-}
-
-func (fts *fileTorrentImpl) Close() error {
-	return nil
-}
-
-func (fts *fileTorrentImpl) setTorrentDir(dir string) {
-	for i, f := range fts.files {
-		fts.files[i].path = filepath.Join(dir, f.rawPath)
-	}
-}
-
-// A helper to create zero-length files which won't appear for file-orientated storage since no
-// writes will ever occur to them (no torrent data is associated with a zero-length file). The
-// caller should make sure the file name provided is safe/sanitized.
-func CreateNativeZeroLengthFile(name string) error {
-	os.MkdirAll(filepath.Dir(name), 0o777)
-	var f io.Closer
-	f, err := os.Create(name)
-	if err != nil {
-		return err
-	}
-	return f.Close()
-}
-
-// Exposes file-based storage of a torrent, as one big ReadWriterAt.
-type fileTorrentImplIO struct {
-	fts *fileTorrentImpl
-}
-
-// Returns EOF on short or missing file.
-func (fst *fileTorrentImplIO) readFileAt(file file, b []byte, off int64) (n int, err error) {
-	f, err := os.Open(file.path)
-	if os.IsNotExist(err) {
-		// File missing is treated the same as a short file.
-		err = io.EOF
-		return
-	}
-	if err != nil {
-		return
-	}
-	defer f.Close()
-	// Limit the read to within the expected bounds of this file.
-	if int64(len(b)) > file.length-off {
-		b = b[:file.length-off]
-	}
-	for off < file.length && len(b) != 0 {
-		n1, err1 := f.ReadAt(b, off)
-		b = b[n1:]
-		n += n1
-		off += int64(n1)
-		if n1 == 0 {
-			err = err1
-			break
-		}
-	}
-	return
-}
-
-// Only returns EOF at the end of the torrent. Premature EOF is ErrUnexpectedEOF.
-func (fst fileTorrentImplIO) ReadAt(b []byte, off int64) (n int, err error) {
-	fst.fts.segmentLocater.Locate(segments.Extent{off, int64(len(b))}, func(i int, e segments.Extent) bool {
-		n1, err1 := fst.readFileAt(fst.fts.files[i], b[:e.Length], e.Start)
-		n += n1
-		b = b[n1:]
-		err = err1
-		return err == nil // && int64(n1) == e.Length
-	})
-	if len(b) != 0 && err == nil {
-		err = io.EOF
-	}
-	return
-}
-
-func (fst fileTorrentImplIO) WriteAt(p []byte, off int64) (n int, err error) {
-	// log.Printf("write at %v: %v bytes", off, len(p))
-	fst.fts.segmentLocater.Locate(segments.Extent{off, int64(len(p))}, func(i int, e segments.Extent) bool {
-		name := fst.fts.files[i].path
-		os.MkdirAll(filepath.Dir(name), 0o777)
-		var f *os.File
-		f, err = os.OpenFile(name, os.O_WRONLY|os.O_CREATE, 0o666)
-		if err != nil {
-			return false
-		}
-		var n1 int
-		n1, err = f.WriteAt(p[:e.Length], e.Start)
-		// log.Printf("%v %v wrote %v: %v", i, e, n1, err)
-		closeErr := f.Close()
-		n += n1
-		p = p[n1:]
-		if err == nil {
-			err = closeErr
-		}
-		if err == nil && int64(n1) != e.Length {
-			err = io.ErrShortWrite
-		}
-		return err == nil
-	})
-	return
-}
@@ -1,36 +0,0 @@
-// modify from github.com/anacrolix/torrent/storage/file_misc.go
-
-package bt
-
-import "github.com/anacrolix/torrent/metainfo"
-
-type requiredLength struct {
-	fileIndex int
-	length    int64
-}
-
-func extentCompleteRequiredLengths(info *metainfo.Info, off, n int64) (ret []requiredLength) {
-	if n == 0 {
-		return
-	}
-	for i, fi := range info.UpvertedFiles() {
-		if off >= fi.Length {
-			off -= fi.Length
-			continue
-		}
-		n1 := n
-		if off+n1 > fi.Length {
-			n1 = fi.Length - off
-		}
-		ret = append(ret, requiredLength{
-			fileIndex: i,
-			length:    off + n1,
-		})
-		n -= n1
-		if n == 0 {
-			return
-		}
-		off = 0
-	}
-	return
-}
@@ -1,61 +0,0 @@
-// modify from github.com/anacrolix/torrent/storage/file_piece.go
-
-package bt
-
-import (
-	"github.com/anacrolix/torrent/metainfo"
-	"github.com/anacrolix/torrent/storage"
-	"io"
-	"log"
-	"os"
-)
-
-type filePieceImpl struct {
-	*fileTorrentImpl
-	p metainfo.Piece
-	io.WriterAt
-	io.ReaderAt
-}
-
-var _ storage.PieceImpl = (*filePieceImpl)(nil)
-
-func (fs *filePieceImpl) pieceKey() metainfo.PieceKey {
-	return metainfo.PieceKey{InfoHash: fs.infoHash, Index: fs.p.Index()}
-}
-
-func (fs *filePieceImpl) Completion() storage.Completion {
-	c, err := fs.completion.Get(fs.pieceKey())
-	if err != nil {
-		log.Printf("error getting piece completion: %s", err)
-		c.Ok = false
-		return c
-	}
-
-	verified := true
-	if c.Complete {
-		// If it's allegedly complete, check that its constituent files have the necessary length.
-		for _, fi := range extentCompleteRequiredLengths(fs.p.Info, fs.p.Offset(), fs.p.Length()) {
-			s, err := os.Stat(fs.files[fi.fileIndex].path)
-			if err != nil || s.Size() < fi.length {
-				verified = false
-				break
-			}
-		}
-	}
-
-	if !verified {
-		// The completion was wrong, fix it.
-		c.Complete = false
-		fs.completion.Set(fs.pieceKey(), false)
-	}
-
-	return c
-}
-
-func (fs *filePieceImpl) MarkComplete() error {
-	return fs.completion.Set(fs.pieceKey(), true)
-}
-
-func (fs *filePieceImpl) MarkNotComplete() error {
-	return fs.completion.Set(fs.pieceKey(), false)
-}
@@ -0,0 +1,199 @@
+package bt
+
+import (
+	"testing"
+
+	"github.com/GopeedLab/gopeed/internal/fetcher"
+	"github.com/GopeedLab/gopeed/pkg/base"
+	protocolbt "github.com/GopeedLab/gopeed/pkg/protocol/bt"
+	"github.com/RoaringBitmap/roaring"
+	"github.com/anacrolix/torrent"
+	"github.com/anacrolix/torrent/storage"
+)
+
+func TestStatsSeparatesSnapshotAndRuntime(t *testing.T) {
+	frame := (&Fetcher{
+		meta: &fetcher.FetcherMeta{Res: &base.Resource{Size: 256}},
+		data: &fetcherData{SeedBytes: 128, SeedTime: 64},
+	}).Stats()
+	if frame.Snapshot != nil {
+		t.Fatalf("snapshot = %T, want nil until piece completion is known", frame.Snapshot)
+	}
+	runtime, ok := frame.Runtime.(*protocolbt.StatsRuntime)
+	if !ok {
+		t.Fatalf("runtime type = %T", frame.Runtime)
+	}
+	if len(runtime.Peers) != 0 || runtime.TotalPeers != 0 {
+		t.Fatalf("unexpected runtime: %+v", runtime)
+	}
+}
+
+func TestStatsBeforeTorrentMetadataIsAvailable(t *testing.T) {
+	config := torrent.TestingConfig(t)
+	config.DisableTCP = true
+	config.DisableUTP = true
+	client, err := torrent.NewClient(config)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer client.Close()
+
+	torrentWithoutMetadata, err := client.AddMagnet(
+		"magnet:?xt=urn:btih:0123456789abcdef0123456789abcdef01234567",
+	)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if info := torrentWithoutMetadata.Info(); info != nil {
+		t.Fatalf("torrent info = %+v, want nil before metadata is available", info)
+	}
+
+	frame := (&Fetcher{
+		torrent: torrentWithoutMetadata,
+		meta:    &fetcher.FetcherMeta{},
+		data:    &fetcherData{},
+	}).Stats()
+	if frame.Snapshot != nil {
+		t.Fatalf("snapshot = %T, want nil before metadata is available", frame.Snapshot)
+	}
+	runtime, ok := frame.Runtime.(*protocolbt.StatsRuntime)
+	if !ok {
+		t.Fatalf("runtime type = %T", frame.Runtime)
+	}
+	if len(runtime.Peers) != 0 || runtime.TotalPeers != 0 {
+		t.Fatalf("unexpected runtime before metadata is available: %+v", runtime)
+	}
+}
+
+func TestApplyBTPieceRunsPublishesVerifiedCompletionOnly(t *testing.T) {
+	pieceMap := base.NewPieceMap(4, 1024)
+	ready := applyBTPieceRuns(pieceMap, []torrent.PieceStateRun{
+		{PieceState: torrent.PieceState{Completion: torrentCompletion(true, true)}, Length: 1},
+		{PieceState: torrent.PieceState{Completion: torrentCompletion(true, false), Partial: true}, Length: 2},
+		{PieceState: torrent.PieceState{Completion: torrentCompletion(false, false), Hashing: true}, Length: 1},
+	})
+	if ready {
+		t.Fatal("piece map became ready while one completion is unknown")
+	}
+	want := []bool{true, false, false, false}
+	for index, expected := range want {
+		got, err := pieceMap.Get(index)
+		if err != nil || got != expected {
+			t.Fatalf("piece %d = %v, %v; want %v", index, got, err, expected)
+		}
+	}
+
+	knownMap := base.NewPieceMap(2, 1024)
+	if !applyBTPieceRuns(knownMap, []torrent.PieceStateRun{
+		{PieceState: torrent.PieceState{Completion: torrentCompletion(true, true)}, Length: 1},
+		{PieceState: torrent.PieceState{Completion: torrentCompletion(true, false)}, Length: 1},
+	}) {
+		t.Fatal("fully known completion map was not ready")
+	}
+	if applyBTPieceRuns(base.NewPieceMap(2, 1024), []torrent.PieceStateRun{
+		{PieceState: torrent.PieceState{Completion: torrentCompletion(true, true)}, Length: 1},
+	}) {
+		t.Fatal("incomplete piece runs were published")
+	}
+}
+
+func torrentCompletion(ok, complete bool) storage.Completion {
+	return storage.Completion{Ok: ok, Complete: complete}
+}
+
+func TestNormalizeBTPeerMetadata(t *testing.T) {
+	if got := normalizeBTPeerSource(torrent.PeerSourceDhtGetPeers); got != "dht" {
+		t.Fatalf("DHT source = %q", got)
+	}
+	if got := normalizeBTPeerSource(torrent.PeerSourcePex); got != "pex" {
+		t.Fatalf("PEX source = %q", got)
+	}
+	transports := map[string]string{
+		"udp4":   "utp",
+		"udp6":   "utp",
+		"tcp4":   "tcp",
+		"tcp6":   "tcp",
+		"webrtc": "webrtc",
+		"unix":   "unknown",
+	}
+	for network, want := range transports {
+		if got := normalizeBTTransport(network); got != want {
+			t.Errorf("normalizeBTTransport(%q) = %q, want %q", network, got, want)
+		}
+	}
+}
+
+func TestBTPeerCompletion(t *testing.T) {
+	if got := btPeerCompletion(1, 4); got == nil || *got != 0.25 {
+		t.Fatalf("completion = %v, want 0.25", got)
+	}
+	if got := btPeerCompletion(5, 4); got == nil || *got != 1 {
+		t.Fatalf("clamped completion = %v, want 1", got)
+	}
+	if got := btPeerCompletion(-1, 4); got == nil || *got != 0 {
+		t.Fatalf("negative completion = %v, want 0", got)
+	}
+	if got := btPeerCompletion(0, 0); got != nil {
+		t.Fatalf("completion without metadata = %v, want nil", *got)
+	}
+}
+
+func TestBTPeerRelevanceUsesWantedMissingPieces(t *testing.T) {
+	missing := btMissingWantedPieces([]torrent.PieceStateRun{
+		{
+			PieceState: torrent.PieceState{
+				Completion: torrentCompletion(true, true),
+				Priority:   torrent.PiecePriorityNormal,
+			},
+			Length: 2,
+		},
+		{
+			PieceState: torrent.PieceState{
+				Completion: torrentCompletion(true, false),
+				Priority:   torrent.PiecePriorityNormal,
+			},
+			Length: 2,
+		},
+		{
+			PieceState: torrent.PieceState{
+				Completion: torrentCompletion(true, false),
+				Priority:   torrent.PiecePriorityNone,
+			},
+			Length: 2,
+		},
+	}, 6)
+	if missing == nil || !missing.Equals(roaring.BitmapOf(2, 3)) {
+		t.Fatalf("missing wanted pieces = %v, want {2, 3}", missing)
+	}
+
+	if got := btPeerRelevance(roaring.BitmapOf(0, 2, 4), missing); got == nil || *got != 0.5 {
+		t.Fatalf("relevance = %v, want 0.5", got)
+	}
+	if got := btPeerRelevance(roaring.BitmapOf(0, 1, 4), missing); got == nil || *got != 0 {
+		t.Fatalf("zero relevance = %v, want 0", got)
+	}
+	if got := btPeerRelevance(roaring.BitmapOf(2, 3), roaring.New()); got != nil {
+		t.Fatalf("relevance with no missing pieces = %v, want nil", *got)
+	}
+	if got := btMissingWantedPieces(nil, 6); got != nil {
+		t.Fatalf("incomplete piece states = %v, want nil", got)
+	}
+}
+
+func TestBTPeerRelevanceTracksRemainingDownload(t *testing.T) {
+	missing := roaring.BitmapOf(90, 91, 92, 93, 94, 95, 96, 97, 98, 99)
+	if got := btPeerRelevance(missing.Clone(), missing); got == nil || *got != 1 {
+		t.Fatalf("peer covering every missing piece = %v, want 1", got)
+	}
+
+	oneRelevantPiece := roaring.BitmapOf(90)
+	if got := btPeerRelevance(oneRelevantPiece, missing); got == nil || *got != 0.1 {
+		t.Fatalf("peer covering one of ten missing pieces = %v, want 0.1", got)
+	}
+
+	missingAfterTransfer := missing.Clone()
+	missingAfterTransfer.Remove(90)
+	if got := btPeerRelevance(oneRelevantPiece, missingAfterTransfer); got == nil || *got != 0 {
+		t.Fatalf("peer after transferring its only relevant piece = %v, want 0", got)
+	}
+}
@@ -0,0 +1,15 @@
+package ed2k
+
+const (
+	defaultServerList = "45.82.80.155:5687,176.123.5.89:4725,85.121.5.137:4232,176.123.2.239:4232,145.239.2.134:4661,91.208.162.87:4232,37.15.61.236:4232"
+	defaultServerMet  = "ed2k://|serverlist|http://upd.emule-security.org/server.met|/"
+	defaultNodesDat   = "https://upd.emule-security.org/nodes.dat"
+)
+
+type config struct {
+	ListenPort int    `json:"listenPort"`
+	UDPPort    int    `json:"udpPort"`
+	ServerAddr string `json:"serverAddr"`
+	ServerMet  string `json:"serverMet"`
+	NodesDat   string `json:"nodesDat"`
+}
@@ -0,0 +1,558 @@
+package ed2k
+
+import (
+	"context"
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/GopeedLab/gopeed/internal/controller"
+	"github.com/GopeedLab/gopeed/internal/fetcher"
+	"github.com/GopeedLab/gopeed/pkg/base"
+	ped2k "github.com/GopeedLab/gopeed/pkg/protocol/ed2k"
+	"github.com/monkeyWie/goed2k"
+	gprotocol "github.com/monkeyWie/goed2k/protocol"
+)
+
+type clientStateStore struct {
+	store fetcher.ProtocolStateStore
+}
+
+func (s *clientStateStore) Load() (*goed2k.ClientState, error) {
+	if s == nil || s.store == nil {
+		return nil, nil
+	}
+	var state goed2k.ClientState
+	exist, err := s.store.Load(&state)
+	if err != nil {
+		return nil, err
+	}
+	if !exist {
+		return nil, nil
+	}
+	return &state, nil
+}
+
+func (s *clientStateStore) Save(state *goed2k.ClientState) error {
+	if s == nil || s.store == nil {
+		return nil
+	}
+	if state == nil {
+		return s.store.Delete()
+	}
+	return s.store.Save(state)
+}
+
+type Fetcher struct {
+	ctl    *controller.Controller
+	config *config
+
+	manager *FetcherManager
+	meta    *fetcher.FetcherMeta
+	handle  goed2k.TransferHandle
+
+	waitCtx    context.Context
+	waitCancel context.CancelFunc
+}
+
+func (f *Fetcher) Setup(ctl *controller.Controller) {
+	f.ctl = ctl
+	if f.meta == nil {
+		f.meta = &fetcher.FetcherMeta{}
+	}
+	f.waitCtx, f.waitCancel = context.WithCancel(context.Background())
+	f.ctl.GetConfig(&f.config)
+}
+
+func (f *Fetcher) Resolve(req *base.Request, opts *base.Options) error {
+	link, err := parseLink(req.URL)
+	if err != nil {
+		return err
+	}
+
+	f.meta.Req = req
+	f.meta.Opts = opts
+	if f.meta.Opts == nil {
+		f.meta.Opts = &base.Options{}
+	}
+	f.meta.Res = buildResource(link)
+	return nil
+}
+
+func (f *Fetcher) Start() error {
+	link, err := parseLink(f.meta.Req.URL)
+	if err != nil {
+		return err
+	}
+	if f.meta.Res == nil {
+		f.meta.Res = buildResource(link)
+	}
+
+	client, err := f.getClient()
+	if err != nil {
+		return err
+	}
+
+	targetPath := f.meta.SingleFilepath()
+	if err := os.MkdirAll(filepath.Dir(targetPath), 0o755); err != nil {
+		return err
+	}
+
+	handle := client.FindTransfer(link.Hash)
+	if handle.IsValid() {
+		f.handle = handle
+		if handle.IsPaused() {
+			if err := client.ResumeTransfer(handle.GetHash()); err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+
+	atp := goed2k.AddTransferParams{
+		Hash:       link.Hash,
+		CreateTime: time.Now().UnixMilli(),
+		Size:       link.NumberValue,
+		FilePath:   targetPath,
+	}
+	handle, err = client.AddTransfer(atp)
+	if err != nil {
+		return err
+	}
+	f.handle = handle
+	if handle.IsValid() && handle.IsPaused() {
+		if err := client.ResumeTransfer(handle.GetHash()); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (f *Fetcher) Patch(req *base.Request, opts *base.Options) error {
+	handle := f.currentHandle()
+
+	if opts != nil && (opts.Name != "" || opts.Path != "") && handle.IsValid() {
+		return errors.New("cannot change ed2k target path after transfer started")
+	}
+	if req != nil && req.URL != "" && handle.IsValid() {
+		return errors.New("cannot change ed2k link after transfer started")
+	}
+
+	if req != nil {
+		if req.URL != "" {
+			link, err := parseLink(req.URL)
+			if err != nil {
+				return err
+			}
+			f.meta.Req.URL = req.URL
+			f.meta.Res = buildResource(link)
+		}
+		if req.Labels != nil {
+			if f.meta.Req.Labels == nil {
+				f.meta.Req.Labels = make(map[string]string)
+			}
+			for k, v := range req.Labels {
+				f.meta.Req.Labels[k] = v
+			}
+		}
+		if req.Proxy != nil {
+			f.meta.Req.Proxy = req.Proxy
+		}
+	}
+
+	if opts != nil {
+		if opts.Name != "" {
+			f.meta.Opts.Name = opts.Name
+		}
+		if opts.Path != "" {
+			f.meta.Opts.Path = opts.Path
+		}
+	}
+	return nil
+}
+
+func (f *Fetcher) Pause() error {
+	handle := f.currentHandle()
+	if !handle.IsValid() {
+		return nil
+	}
+	client, err := f.getClient()
+	if err != nil {
+		return err
+	}
+	if err := client.PauseTransfer(handle.GetHash()); err != nil {
+		return err
+	}
+	f.handle = handle
+	return nil
+}
+
+func (f *Fetcher) Close() error {
+	if f.waitCancel != nil {
+		f.waitCancel()
+	}
+	handle := f.currentHandle()
+	if !handle.IsValid() {
+		return nil
+	}
+	client, err := f.getClient()
+	if err != nil {
+		return err
+	}
+	f.handle = handle
+	return client.RemoveTransfer(handle.GetHash(), false)
+}
+
+func (f *Fetcher) Meta() *fetcher.FetcherMeta {
+	return f.meta
+}
+
+func (f *Fetcher) Stats() *fetcher.Stats {
+	handle := f.currentHandle()
+	if !handle.IsValid() {
+		return &fetcher.Stats{
+			Runtime: &ped2k.StatsRuntime{
+				Peers: make([]*base.PeerStats, 0),
+			},
+		}
+	}
+	status := handle.GetStatus()
+	pieceMap := buildED2KPieceMap(handle.PieceSnapshots())
+	mapReady := pieceMap != nil && status.State != goed2k.LoadingResumeData && status.State != goed2k.Verifying
+	var snapshot any
+	if mapReady {
+		snapshot = &ped2k.StatsSnapshot{
+			Upload:        status.Upload,
+			TotalDone:     status.TotalDone,
+			TotalReceived: status.TotalReceived,
+			TotalWanted:   status.TotalWanted,
+			PieceMap:      pieceMap.Clone(),
+		}
+	}
+	// Resume loading and verification are transitional. A nil Snapshot retains
+	// the last trusted completion bitset until goed2k publishes a stable map.
+	return &fetcher.Stats{
+		Snapshot: snapshot,
+		Runtime: &ped2k.StatsRuntime{
+			State:        string(status.State),
+			Paused:       status.Paused,
+			ActivePeers:  handle.ActiveConnections(),
+			TotalPeers:   status.NumPeers,
+			DownloadRate: status.DownloadRate,
+			UploadRate:   status.UploadRate,
+			Peers:        buildED2KPeers(handle.GetPeersInfo()),
+		},
+	}
+}
+
+func buildED2KPieceMap(snapshots []goed2k.PieceSnapshot) *base.PieceMap {
+	if len(snapshots) == 0 {
+		return nil
+	}
+	pieceMap := base.NewPieceMap(len(snapshots), goed2k.PieceSize)
+	for _, snapshot := range snapshots {
+		if snapshot.Index < 0 || snapshot.Index >= pieceMap.PieceCount() {
+			continue
+		}
+		_ = pieceMap.Update(snapshot.Index, snapshot.State == goed2k.PieceSnapshotFinished)
+	}
+	return pieceMap
+}
+
+func buildED2KPeers(peerInfos []goed2k.PeerInfo) []*base.PeerStats {
+	peers := make([]*base.PeerStats, 0, len(peerInfos))
+	for _, peerInfo := range peerInfos {
+		peers = append(peers, &base.PeerStats{
+			Address:       peerInfo.Endpoint.String(),
+			Client:        ed2kPeerClient(peerInfo),
+			DownloadSpeed: int64(peerInfo.PayloadDownloadSpeed),
+			UploadSpeed:   int64(peerInfo.PayloadUploadSpeed),
+			PieceCount:    peerInfo.RemotePieces.Count(),
+			Source:        peerInfo.SourceString(),
+			Transport:     "tcp",
+		})
+	}
+	return peers
+}
+
+func ed2kPeerClient(peerInfo goed2k.PeerInfo) string {
+	return strings.TrimSpace(peerInfo.ModName + " " + peerInfo.StrModVersion)
+}
+
+func (f *Fetcher) Progress() fetcher.Progress {
+	handle := f.currentHandle()
+	if !handle.IsValid() {
+		return fetcher.Progress{0}
+	}
+	return fetcher.Progress{handle.GetStatus().TotalReceived}
+}
+
+func (f *Fetcher) Wait() error {
+	client, err := f.getClient()
+	if err != nil {
+		return err
+	}
+
+	hash, err := f.hash()
+	if err != nil {
+		return err
+	}
+
+	handle := f.currentHandle()
+	if handle.IsValid() && handle.IsFinished() {
+		return nil
+	}
+
+	progressCh, cancel := client.SubscribeTransferProgress()
+	defer cancel()
+
+	for {
+		select {
+		case <-f.waitCtx.Done():
+			return nil
+		case event, ok := <-progressCh:
+			if !ok {
+				return nil
+			}
+			for _, transfer := range event.Transfers {
+				if transfer.Hash.Compare(hash) != 0 {
+					continue
+				}
+				// Removal can happen during task deletion or client shutdown, both of
+				// which should unblock Wait without treating it as a download failure.
+				if transfer.Removed || transfer.State == goed2k.Finished {
+					return nil
+				}
+			}
+		}
+	}
+}
+
+func (f *Fetcher) getClient() (*goed2k.Client, error) {
+	if f.manager == nil {
+		f.manager = &FetcherManager{}
+	}
+	return f.manager.initClient(f.config)
+}
+
+func (f *Fetcher) currentHandle() goed2k.TransferHandle {
+	if f.handle.IsValid() {
+		return f.handle
+	}
+	if f.manager == nil {
+		return f.handle
+	}
+	client := f.manager.currentClient()
+	if client == nil {
+		return f.handle
+	}
+	hash, err := f.hash()
+	if err != nil {
+		return f.handle
+	}
+	handle := client.FindTransfer(hash)
+	if handle.IsValid() {
+		f.handle = handle
+	}
+	return f.handle
+}
+
+func (f *Fetcher) hash() (gprotocol.Hash, error) {
+	if f.meta == nil || f.meta.Req == nil {
+		return gprotocol.Invalid, errors.New("ed2k link is empty")
+	}
+	link, err := parseLink(f.meta.Req.URL)
+	if err != nil {
+		return gprotocol.Invalid, err
+	}
+	return link.Hash, nil
+}
+
+type FetcherManager struct {
+	mu         sync.Mutex
+	client     *goed2k.Client
+	stateStore *clientStateStore
+}
+
+func (fm *FetcherManager) SetStateStore(store fetcher.ProtocolStateStore) {
+	fm.mu.Lock()
+	defer fm.mu.Unlock()
+
+	if fm.stateStore == nil {
+		fm.stateStore = &clientStateStore{}
+	}
+	fm.stateStore.store = store
+	if fm.client != nil {
+		fm.client.SetStateStore(fm.stateStore)
+	}
+}
+
+func (fm *FetcherManager) Name() string {
+	return "ed2k"
+}
+
+func (fm *FetcherManager) Filters() []*fetcher.SchemeFilter {
+	return []*fetcher.SchemeFilter{
+		{
+			Type:    fetcher.FilterTypeUrl,
+			Pattern: "ED2K",
+		},
+	}
+}
+
+func (fm *FetcherManager) Build() fetcher.Fetcher {
+	return &Fetcher{manager: fm}
+}
+
+func (fm *FetcherManager) ParseName(u string) string {
+	link, err := parseLink(u)
+	if err != nil {
+		return ""
+	}
+	return link.StringValue
+}
+
+func (fm *FetcherManager) AutoRename() bool {
+	return true
+}
+
+func (fm *FetcherManager) DefaultConfig() any {
+	return &config{
+		ListenPort: 0,
+		UDPPort:    0,
+		ServerAddr: defaultServerList,
+		ServerMet:  defaultServerMet,
+		NodesDat:   defaultNodesDat,
+	}
+}
+
+func (fm *FetcherManager) Store(f fetcher.Fetcher) (any, error) {
+	return nil, nil
+}
+
+func (fm *FetcherManager) Restore() (v any, f func(meta *fetcher.FetcherMeta, v any) fetcher.Fetcher) {
+	return nil, func(meta *fetcher.FetcherMeta, v any) fetcher.Fetcher {
+		return &Fetcher{
+			manager: fm,
+			meta:    meta,
+		}
+	}
+}
+
+func (fm *FetcherManager) Close() error {
+	fm.mu.Lock()
+	defer fm.mu.Unlock()
+
+	if fm.client != nil {
+		fm.client.Close()
+		fm.client = nil
+	}
+	return nil
+}
+
+func parseLink(raw string) (goed2k.EMuleLink, error) {
+	link, err := goed2k.ParseEMuleLink(raw)
+	if err != nil {
+		return goed2k.EMuleLink{}, err
+	}
+	if link.Type != goed2k.LinkFile {
+		return goed2k.EMuleLink{}, errors.New("unsupported ed2k link type")
+	}
+	return link, nil
+}
+
+func buildResource(link goed2k.EMuleLink) *base.Resource {
+	return &base.Resource{
+		Size:  link.NumberValue,
+		Range: false,
+		Hash:  link.Hash.String(),
+		Files: []*base.FileInfo{
+			{
+				Name: link.StringValue,
+				Size: link.NumberValue,
+			},
+		},
+	}
+}
+
+func splitCommaList(value string) []string {
+	if strings.TrimSpace(value) == "" {
+		return nil
+	}
+	parts := strings.Split(value, ",")
+	out := make([]string, 0, len(parts))
+	for _, part := range parts {
+		part = strings.TrimSpace(part)
+		if part != "" {
+			out = append(out, part)
+		}
+	}
+	return out
+}
+
+func (fm *FetcherManager) getStateStoreLocked() *clientStateStore {
+	if fm.stateStore == nil {
+		fm.stateStore = &clientStateStore{}
+	}
+	return fm.stateStore
+}
+
+func (fm *FetcherManager) currentClient() *goed2k.Client {
+	fm.mu.Lock()
+	defer fm.mu.Unlock()
+	return fm.client
+}
+
+func (fm *FetcherManager) initClient(cfg *config) (*goed2k.Client, error) {
+	fm.mu.Lock()
+	defer fm.mu.Unlock()
+
+	if fm.client != nil {
+		return fm.client, nil
+	}
+	if cfg == nil {
+		cfg = fm.DefaultConfig().(*config)
+	}
+
+	settings := goed2k.NewSettings()
+	settings.ListenPort = cfg.ListenPort
+	settings.UDPPort = cfg.UDPPort
+	settings.EnableDHT = true
+	settings.EnableUPnP = true
+	settings.ReconnectToServer = true
+
+	client := goed2k.NewClient(settings)
+	client.SetStateStore(fm.getStateStoreLocked())
+	if err := client.LoadState(""); err != nil {
+		return nil, err
+	}
+	if err := client.Start(); err != nil {
+		return nil, err
+	}
+	fm.client = client
+	// Bootstrap is best-effort: downloads can still proceed later even if
+	// server list or DHT initialization fails during startup.
+	bootstrapClient(client, cfg)
+	return fm.client, nil
+}
+
+func bootstrapClient(client *goed2k.Client, cfg *config) {
+	for _, serverAddr := range splitCommaList(cfg.ServerAddr) {
+		go func(serverAddr string) {
+			_ = client.Connect(serverAddr)
+		}(serverAddr)
+	}
+	for _, source := range splitCommaList(cfg.ServerMet) {
+		go func(source string) {
+			_ = client.ConnectServerMet(source)
+		}(source)
+	}
+	if cfg.NodesDat != "" {
+		go func() {
+			_ = client.LoadDHTNodesDat(cfg.NodesDat)
+		}()
+	}
+}
@@ -0,0 +1,42 @@
+package ed2k
+
+import (
+	"testing"
+
+	"github.com/GopeedLab/gopeed/internal/controller"
+	"github.com/GopeedLab/gopeed/pkg/base"
+)
+
+const testLink = "ed2k://|file|cn_windows_10_multi-edition_vl_version_1709_updated_sept_2017_x64_dvd_100090774.iso|4630972416|8867C5E54405FF9452225B66EFEE690A|/"
+
+func TestFetcher_Resolve(t *testing.T) {
+	f := (&FetcherManager{}).Build()
+	f.Setup(controller.NewController())
+
+	err := f.Resolve(&base.Request{URL: testLink}, &base.Options{Path: t.TempDir()})
+	if err != nil {
+		t.Fatalf("Resolve() error = %v", err)
+	}
+
+	meta := f.Meta()
+	if meta.Res == nil {
+		t.Fatal("Resolve() resource is nil")
+	}
+	if got, want := meta.Res.Hash, "8867C5E54405FF9452225B66EFEE690A"; got != want {
+		t.Fatalf("Resolve() hash = %s, want %s", got, want)
+	}
+	if got, want := meta.Res.Size, int64(4630972416); got != want {
+		t.Fatalf("Resolve() size = %d, want %d", got, want)
+	}
+	if got, want := meta.Res.Files[0].Name, "cn_windows_10_multi-edition_vl_version_1709_updated_sept_2017_x64_dvd_100090774.iso"; got != want {
+		t.Fatalf("Resolve() name = %q, want %q", got, want)
+	}
+}
+
+func TestFetcherManager_ParseName(t *testing.T) {
+	got := (&FetcherManager{}).ParseName(testLink)
+	want := "cn_windows_10_multi-edition_vl_version_1709_updated_sept_2017_x64_dvd_100090774.iso"
+	if got != want {
+		t.Fatalf("ParseName() = %q, want %q", got, want)
+	}
+}
@@ -0,0 +1,72 @@
+package ed2k
+
+import (
+	"testing"
+
+	ped2k "github.com/GopeedLab/gopeed/pkg/protocol/ed2k"
+	"github.com/monkeyWie/goed2k"
+	"github.com/monkeyWie/goed2k/protocol"
+)
+
+func TestStatsSeparatesSnapshotAndRuntimeWithoutHandle(t *testing.T) {
+	frame := (&Fetcher{}).Stats()
+	if frame.Snapshot != nil {
+		t.Fatalf("snapshot = %T, want nil without a valid handle", frame.Snapshot)
+	}
+	runtime, ok := frame.Runtime.(*ped2k.StatsRuntime)
+	if !ok {
+		t.Fatalf("runtime type = %T", frame.Runtime)
+	}
+	if runtime.Peers == nil || len(runtime.Peers) != 0 {
+		t.Fatalf("unexpected runtime peers: %+v", runtime.Peers)
+	}
+}
+
+func TestBuildED2KPieceMapPreservesIndexes(t *testing.T) {
+	snapshots := []goed2k.PieceSnapshot{
+		{Index: 0, State: goed2k.PieceSnapshotFinished},
+		{Index: 1, State: goed2k.PieceSnapshotMissing},
+		{Index: 2, State: goed2k.PieceSnapshotDownloading},
+		{Index: 3, State: goed2k.PieceSnapshotFinished},
+	}
+	pieceMap := buildED2KPieceMap(snapshots)
+	if pieceMap == nil {
+		t.Fatal("buildED2KPieceMap returned nil")
+	}
+	want := []bool{true, false, false, true}
+	for index, expected := range want {
+		got, err := pieceMap.Get(index)
+		if err != nil || got != expected {
+			t.Fatalf("piece %d = %v, %v; want %v", index, got, err, expected)
+		}
+	}
+	if pieceMap.CompletedPieces() != 2 {
+		t.Fatalf("CompletedPieces() = %d, want 2", pieceMap.CompletedPieces())
+	}
+}
+
+func TestBuildED2KPeers(t *testing.T) {
+	remotePieces := protocol.NewBitField(4)
+	remotePieces.SetBit(0)
+	remotePieces.SetBit(2)
+	endpoint, err := protocol.EndpointFromString("127.0.0.1", 4662)
+	if err != nil {
+		t.Fatalf("EndpointFromString: %v", err)
+	}
+	peers := buildED2KPeers([]goed2k.PeerInfo{{
+		PayloadDownloadSpeed: 2048,
+		PayloadUploadSpeed:   1024,
+		RemotePieces:         remotePieces,
+		Endpoint:             endpoint,
+		ModName:              "aMule",
+		StrModVersion:        "2.3.3",
+		SourceFlag:           int(goed2k.PeerServer | goed2k.PeerDHT),
+	}})
+	if len(peers) != 1 {
+		t.Fatalf("len(peers) = %d, want 1", len(peers))
+	}
+	peer := peers[0]
+	if peer.Client != "aMule 2.3.3" || peer.PieceCount != 2 || peer.Source != "server|kad" || peer.Transport != "tcp" {
+		t.Fatalf("unexpected peer: %+v", peer)
+	}
+}
@@ -1,6 +1,7 @@
 package http

 type config struct {
-	UserAgent   string `json:"userAgent"`
-	Connections int    `json:"connections"`
+	UserAgent      string `json:"userAgent"`
+	Connections    int    `json:"connections"`
+	UseServerCtime bool   `json:"useServerCtime"`
 }
@@ -0,0 +1,189 @@
+package http
+
+import (
+	"net/url"
+	"path"
+
+	"github.com/GopeedLab/gopeed/internal/fetcher"
+	"github.com/GopeedLab/gopeed/pkg/base"
+	fhttp "github.com/GopeedLab/gopeed/pkg/protocol/http"
+)
+
+// ============================================================================
+// Fetcher Data (for Store/Restore)
+// ============================================================================
+
+type fetcherData struct {
+	Connections           []*connection
+	RedirectURL           string // Saved redirect URL for resume
+	IfRange               string // Strong ETag or Last-Modified validator for safe resume
+	RangeReprobeEligible  bool   // Origin advertised Range before falling back to sequential mode
+	RangeValidatorPinned  bool   // Recovered Range mode must keep the same If-Range validator
+	SequentialSizeUnknown bool   // Interrupted chunked restart must retry from byte zero
+	Range                 *bool  // Authoritative Range mode; nil for records saved by older versions
+	ResourceSize          *int64 // Authoritative resource size from the same snapshot as Connections
+	FileSize              *int64 // Authoritative single-file size; nil for older records
+}
+
+// ============================================================================
+// Fetcher Manager
+// ============================================================================
+
+type FetcherManager struct {
+}
+
+func (fm *FetcherManager) Name() string {
+	return "http"
+}
+
+func (fm *FetcherManager) Filters() []*fetcher.SchemeFilter {
+	return []*fetcher.SchemeFilter{
+		{
+			Type:    fetcher.FilterTypeUrl,
+			Pattern: "HTTP",
+		},
+		{
+			Type:    fetcher.FilterTypeUrl,
+			Pattern: "HTTPS",
+		},
+	}
+}
+
+func (fm *FetcherManager) Build() fetcher.Fetcher {
+	return &Fetcher{}
+}
+
+func (fm *FetcherManager) ParseName(u string) string {
+	var name string
+	url, err := url.Parse(u)
+	if err != nil {
+		return ""
+	}
+	name = path.Base(url.Path)
+	if name == "" || name == "/" || name == "." {
+		name = url.Hostname()
+	}
+	return name
+}
+
+func (fm *FetcherManager) AutoRename() bool {
+	return true
+}
+
+func (fm *FetcherManager) DefaultConfig() any {
+	return &config{
+		UserAgent:   "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36",
+		Connections: 16,
+	}
+}
+
+func (fm *FetcherManager) Store(f fetcher.Fetcher) (data any, err error) {
+	_f := f.(*Fetcher)
+	_f.redirectLock.Lock()
+	redirectURL := _f.redirectURL
+	_f.redirectLock.Unlock()
+
+	// Build an immutable snapshot while holding the same lock used by download
+	// workers to update Range mode and connection progress. The storage layer
+	// marshals this value after Store returns, so returning live pointers would
+	// otherwise race with the active download and could persist a mixed state.
+	_f.connMu.Lock()
+	connections := snapshotConnectionsLocked(_f.connections)
+	ifRange := _f.ifRange
+	rangeReprobeEligible := _f.rangeReprobeEligible
+	rangeValidatorPinned := _f.rangeValidatorPinned
+	sequentialSizeUnknown := _f.sequentialSizeUnknown
+	var rangeMode *bool
+	var resourceSize *int64
+	var fileSize *int64
+	if _f.meta != nil && _f.meta.Res != nil {
+		value := _f.meta.Res.Range
+		rangeMode = &value
+		size := _f.meta.Res.Size
+		resourceSize = &size
+		if len(_f.meta.Res.Files) > 0 && _f.meta.Res.Files[0] != nil {
+			size := _f.meta.Res.Files[0].Size
+			fileSize = &size
+		}
+	}
+	_f.connMu.Unlock()
+
+	return &fetcherData{
+		Connections:           connections,
+		RedirectURL:           redirectURL,
+		IfRange:               ifRange,
+		RangeReprobeEligible:  rangeReprobeEligible,
+		RangeValidatorPinned:  rangeValidatorPinned,
+		SequentialSizeUnknown: sequentialSizeUnknown,
+		Range:                 rangeMode,
+		ResourceSize:          resourceSize,
+		FileSize:              fileSize,
+	}, nil
+}
+
+// snapshotConnectionsLocked copies only the serialized connection state and
+// deep-copies chunks. The caller must hold the fetcher's connMu.
+func snapshotConnectionsLocked(connections []*connection) []*connection {
+	snapshot := make([]*connection, len(connections))
+	for i, conn := range connections {
+		if conn == nil {
+			continue
+		}
+		copyConn := &connection{
+			ID:         conn.ID,
+			Role:       conn.Role,
+			State:      conn.State,
+			Downloaded: conn.Downloaded,
+			Completed:  conn.Completed,
+		}
+		if conn.Chunk != nil {
+			copyChunk := *conn.Chunk
+			if conn.Chunk.End != nil {
+				end := *conn.Chunk.End
+				copyChunk.End = &end
+			}
+			copyConn.Chunk = &copyChunk
+		}
+		snapshot[i] = copyConn
+	}
+	return snapshot
+}
+
+func (fm *FetcherManager) Restore() (v any, f func(meta *fetcher.FetcherMeta, v any) fetcher.Fetcher) {
+	return &fetcherData{}, func(meta *fetcher.FetcherMeta, v any) fetcher.Fetcher {
+		fd := v.(*fetcherData)
+		fb := &FetcherManager{}
+		fetcher := fb.Build().(*Fetcher)
+		fetcher.meta = meta
+		base.ParseReqExtra[fhttp.ReqExtra](fetcher.meta.Req)
+		base.ParseOptExtra[fhttp.OptsExtra](fetcher.meta.Opts)
+		if len(fd.Connections) > 0 {
+			fetcher.connections = fd.Connections
+		}
+		// Restore redirect URL for resume
+		if fd.RedirectURL != "" {
+			fetcher.redirectURL = fd.RedirectURL
+		}
+		fetcher.ifRange = fd.IfRange
+		fetcher.rangeReprobeEligible = fd.RangeReprobeEligible
+		fetcher.rangeValidatorPinned = fd.RangeValidatorPinned
+		fetcher.sequentialSizeUnknown = fd.SequentialSizeUnknown
+		if fd.Range != nil && fetcher.meta.Res != nil {
+			// Recovery-critical resource fields live in the same persisted snapshot
+			// as Connections, making them authoritative over task metadata that may
+			// have been saved just before or after this record.
+			fetcher.meta.Res.Range = *fd.Range
+		}
+		if fd.ResourceSize != nil && fetcher.meta.Res != nil {
+			fetcher.meta.Res.Size = *fd.ResourceSize
+		}
+		if fd.FileSize != nil && fetcher.meta.Res != nil && len(fetcher.meta.Res.Files) > 0 && fetcher.meta.Res.Files[0] != nil {
+			fetcher.meta.Res.Files[0].Size = *fd.FileSize
+		}
+		return fetcher
+	}
+}
+
+func (fm *FetcherManager) Close() error {
+	return nil
+}
@@ -0,0 +1,187 @@
+package http
+
+import (
+	"testing"
+)
+
+// TestParseFilenameWithAmpersand tests the fix for filenames containing & character
+// Issue: filenames with & are HTML-encoded as &amp; and then truncated at the semicolon
+func TestParseFilenameWithAmpersand(t *testing.T) {
+	tests := []struct {
+		name        string
+		disposition string
+		want        string
+	}{
+		{
+			name:        "quoted filename with &amp;",
+			disposition: `attachment; filename="查询处理&amp;优化.pptx"`,
+			want:        "查询处理&优化.pptx",
+		},
+		{
+			name:        "unquoted filename with &amp;",
+			disposition: `attachment; filename=test&amp;file.txt`,
+			want:        "test&file.txt",
+		},
+		{
+			name:        "quoted filename with &amp; and extra params",
+			disposition: `attachment; filename="test&amp;file.txt"; charset=utf-8`,
+			want:        "test&file.txt",
+		},
+		{
+			name:        "filename with multiple HTML entities",
+			disposition: `attachment; filename="test&amp;&lt;&gt;.txt"`,
+			want:        "test&<>.txt",
+		},
+		{
+			name:        "normal filename without entities",
+			disposition: `attachment; filename="normal.txt"`,
+			want:        "normal.txt",
+		},
+		{
+			name:        "filename with actual ampersand (no encoding)",
+			disposition: `attachment; filename="test&file.txt"`,
+			want:        "test&file.txt",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := parseFilename(tt.disposition)
+			if got != tt.want {
+				t.Errorf("parseFilename() = %q, want %q", got, tt.want)
+			}
+		})
+	}
+}
+
+// TestFindParamValueEnd tests the helper function for finding parameter value boundaries
+func TestFindParamValueEnd(t *testing.T) {
+	tests := []struct {
+		name  string
+		value string
+		want  int
+	}{
+		{
+			name:  "quoted value with semicolon inside",
+			value: `"test&amp;file.txt"; charset=utf-8`,
+			want:  19, // Position of semicolon after closing quote
+		},
+		{
+			name:  "quoted value without semicolon after",
+			value: `"test.txt"`,
+			want:  -1,
+		},
+		{
+			name:  "unquoted value with semicolon",
+			value: `test.txt; charset=utf-8`,
+			want:  8,
+		},
+		{
+			name:  "unquoted value without semicolon",
+			value: `test.txt`,
+			want:  -1,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := findParamValueEnd(tt.value)
+			if got != tt.want {
+				t.Errorf("findParamValueEnd() = %d, want %d", got, tt.want)
+			}
+		})
+	}
+}
+
+// TestUnescapeHTMLEntities tests HTML entity unescaping
+func TestUnescapeHTMLEntities(t *testing.T) {
+	tests := []struct {
+		name string
+		in   string
+		want string
+	}{
+		{
+			name: "ampersand",
+			in:   "test&amp;file.txt",
+			want: "test&file.txt",
+		},
+		{
+			name: "less than and greater than",
+			in:   "&lt;test&gt;.txt",
+			want: "<test>.txt",
+		},
+		{
+			name: "quote",
+			in:   "test&quot;file.txt",
+			want: "test\"file.txt",
+		},
+		{
+			name: "multiple entities",
+			in:   "a&amp;b&lt;c&gt;d&quot;e",
+			want: "a&b<c>d\"e",
+		},
+		{
+			name: "no entities",
+			in:   "normal.txt",
+			want: "normal.txt",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := unescapeHTMLEntities(tt.in)
+			if got != tt.want {
+				t.Errorf("unescapeHTMLEntities() = %q, want %q", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestAppendFilenameExtension(t *testing.T) {
+	tests := []struct {
+		name        string
+		filename    string
+		contentType string
+		want        string
+	}{
+		{
+			name:        "adds extension from content type",
+			filename:    "download",
+			contentType: "image/png",
+			want:        "download.png",
+		},
+		{
+			name:        "parses MIME parameters",
+			filename:    "download",
+			contentType: "image/png; charset=binary",
+			want:        "download.png",
+		},
+		{
+			name:        "preserves existing extension",
+			filename:    "download.zip",
+			contentType: "application/zip",
+			want:        "download.zip",
+		},
+		{
+			name:        "ignores invalid content type",
+			filename:    "download",
+			contentType: "not a content type",
+			want:        "download",
+		},
+		{
+			name:        "ignores unknown content type",
+			filename:    "download",
+			contentType: "application/x-gopeed-unknown",
+			want:        "download",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := appendFilenameExtension(tt.filename, tt.contentType)
+			if got != tt.want {
+				t.Errorf("appendFilenameExtension() = %q, want %q", got, tt.want)
+			}
+		})
+	}
+}
@@ -0,0 +1,555 @@
+package http
+
+import (
+	"bytes"
+	"context"
+	"crypto/tls"
+	"errors"
+	"fmt"
+	"io"
+	"mime"
+	"net"
+	"net/http"
+	"net/http/cookiejar"
+	"net/url"
+	"path"
+	"strings"
+	"time"
+	"unicode/utf8"
+
+	"github.com/GopeedLab/gopeed/internal/httpclient"
+	"github.com/GopeedLab/gopeed/pkg/base"
+	fhttp "github.com/GopeedLab/gopeed/pkg/protocol/http"
+	"github.com/GopeedLab/gopeed/pkg/util"
+	"golang.org/x/text/encoding/simplifiedchinese"
+)
+
+type RequestError struct {
+	Code int
+}
+
+// extractIfRangeValidator returns only validators that are strong enough for
+// If-Range. Any entity-tag header blocks Last-Modified fallback: a weak or
+// malformed ETag does not make the date validator strong.
+func extractIfRangeValidator(header http.Header) string {
+	etag := strings.TrimSpace(header.Get(base.HttpHeaderETag))
+	if etag != "" {
+		if isStrongETag(etag) {
+			return etag
+		}
+		return ""
+	}
+
+	lastModified := strings.TrimSpace(header.Get(base.HttpHeaderLastModified))
+	date := strings.TrimSpace(header.Get("Date"))
+	if lastModified == "" || date == "" {
+		return ""
+	}
+	modifiedAt, modifiedErr := http.ParseTime(lastModified)
+	responseAt, responseErr := http.ParseTime(date)
+	if modifiedErr != nil || responseErr != nil || responseAt.Sub(modifiedAt) < time.Second {
+		return ""
+	}
+	return lastModified
+}
+
+func isStrongETag(value string) bool {
+	if len(value) < 2 || value[0] != '"' || value[len(value)-1] != '"' {
+		return false
+	}
+	for i := 1; i < len(value)-1; i++ {
+		b := value[i]
+		if b == 0x21 || (b >= 0x23 && b <= 0x7e) || b >= 0x80 {
+			continue
+		}
+		return false
+	}
+	return true
+}
+
+func NewRequestError(code int) *RequestError {
+	return &RequestError{Code: code}
+}
+
+func (re *RequestError) Error() string {
+	return fmt.Sprintf("http request fail, code:%d", re.Code)
+}
+
+func isFailureExemptHTTPCode(code int) bool {
+	if code >= 500 && code <= 599 {
+		return true
+	}
+
+	switch code {
+	case 429, 408, 440, 499:
+		return true
+	default:
+		return false
+	}
+}
+
+func shouldCountHTTPFailure(err error) bool {
+	var re *RequestError
+	if !errors.As(err, &re) {
+		return false
+	}
+
+	return !isFailureExemptHTTPCode(re.Code)
+}
+
+func extractRequestError(err error) *RequestError {
+	var re *RequestError
+	if errors.As(err, &re) {
+		return re
+	}
+
+	return nil
+}
+
+// buildRequest creates an HTTP request using the redirect URL if available.
+func (f *Fetcher) buildRequest(ctx context.Context, req *base.Request) (httpReq *http.Request, err error) {
+	return f.buildRequestWithURL(ctx, req, true)
+}
+
+// buildRequestWithOriginalURL creates an HTTP request using the original URL.
+// This is used for retrying when the redirect URL has expired.
+func (f *Fetcher) buildRequestWithOriginalURL(ctx context.Context, req *base.Request) (httpReq *http.Request, err error) {
+	return f.buildRequestWithURL(ctx, req, false)
+}
+
+// buildRequestWithURL creates an HTTP request.
+// If useRedirect is true and a redirect URL exists, it will be used; otherwise the original URL is used.
+func (f *Fetcher) buildRequestWithURL(ctx context.Context, req *base.Request, useRedirect bool) (httpReq *http.Request, err error) {
+	var reqUrl string
+	f.redirectLock.Lock()
+	if useRedirect && f.redirectURL != "" {
+		reqUrl = f.redirectURL
+	} else {
+		reqUrl = req.URL
+	}
+	f.redirectLock.Unlock()
+
+	var (
+		method string
+		body   io.Reader
+	)
+	headers := http.Header{}
+	if req.Extra == nil {
+		method = http.MethodGet
+	} else {
+		extra := req.Extra.(*fhttp.ReqExtra)
+		if extra.Method != "" {
+			method = extra.Method
+		} else {
+			method = http.MethodGet
+		}
+		if len(extra.Header) > 0 {
+			for k, v := range extra.Header {
+				headers.Set(k, strings.TrimSpace(v))
+			}
+		}
+		if extra.Body != "" {
+			body = bytes.NewBufferString(extra.Body)
+		}
+	}
+	if _, ok := headers[base.HttpHeaderUserAgent]; !ok {
+		headers.Set(base.HttpHeaderUserAgent, strings.TrimSpace(f.config.UserAgent))
+	}
+
+	if ctx != nil {
+		httpReq, err = http.NewRequestWithContext(ctx, method, reqUrl, body)
+	} else {
+		httpReq, err = http.NewRequest(method, reqUrl, body)
+	}
+	if err != nil {
+		return
+	}
+	httpReq.Header = headers
+	if host := headers.Get(base.HttpHeaderHost); host != "" {
+		httpReq.Host = host
+	}
+	return httpReq, nil
+}
+
+// updateRedirectURL updates the redirect URL from the response.
+// This is called when a request using the original URL succeeds after the redirect URL expired.
+func (f *Fetcher) updateRedirectURL(url string) {
+	f.redirectLock.Lock()
+	f.redirectURL = url
+	f.redirectLock.Unlock()
+}
+
+// hasRedirectURL checks if a redirect URL exists and is different from the original URL.
+func (f *Fetcher) hasRedirectURL() bool {
+	f.redirectLock.Lock()
+	defer f.redirectLock.Unlock()
+	return f.redirectURL != "" && f.redirectURL != f.meta.Req.URL
+}
+
+// isRedirectExpiredError checks if the error indicates that the redirect URL may have expired.
+// This includes 403 (Forbidden), 401 (Unauthorized), 410 (Gone), and network errors.
+func isRedirectExpiredError(err error) bool {
+	if err == nil {
+		return false
+	}
+
+	// Check for specific HTTP error codes that might indicate URL expiration
+	if re := extractRequestError(err); re != nil {
+		switch re.Code {
+		case 401, 403, 404, 410:
+			return true
+		}
+	}
+
+	return false
+}
+
+// tryFallbackToOriginalURL attempts to make a request using the original URL
+// when the redirect URL has expired. Returns the response if successful.
+func (f *Fetcher) tryFallbackToOriginalURL(ctx context.Context, client *http.Client, rangeStart int64, rangeEnd *int64, rangeRequested bool, ifRange string) (*http.Response, error) {
+	httpReq, err := f.buildRequestWithOriginalURL(ctx, f.meta.Req)
+	if err != nil {
+		return nil, err
+	}
+
+	if rangeRequested {
+		httpReq.Header.Set(base.HttpHeaderRange, formatRangeHeader(rangeStart, rangeEnd))
+		if ifRange != "" {
+			httpReq.Header.Set(base.HttpHeaderIfRange, ifRange)
+		}
+	}
+
+	resp, err := client.Do(httpReq)
+	if err != nil {
+		return nil, err
+	}
+
+	if resp.StatusCode != base.HttpCodeOK && resp.StatusCode != base.HttpCodePartialContent {
+		resp.Body.Close()
+		return nil, NewRequestError(resp.StatusCode)
+	}
+
+	return resp, nil
+}
+
+func formatRangeHeader(start int64, end *int64) string {
+	if end == nil {
+		return fmt.Sprintf("bytes=%d-", start)
+	}
+	return fmt.Sprintf(base.HttpHeaderRangeFormat, start, *end)
+}
+
+// buildClient creates an HTTP client with the default connection timeout.
+// Used for resolve phase where we don't have connection time data yet.
+func (f *Fetcher) buildClient() *http.Client {
+	return f.buildClientWithTimeout(connectTimeout)
+}
+
+// buildFastFailClient creates an HTTP client with fast-fail timeout.
+// Uses max(minFastFailTimeout, maxConnTime) for fast-fail retry during download phase.
+func (f *Fetcher) buildFastFailClient() *http.Client {
+	maxConn := f.maxConnTime.Load()
+	if maxConn == 0 {
+		// No successful connection yet, use default timeout
+		return f.buildClientWithTimeout(connectTimeout)
+	}
+
+	timeout := maxConn
+	if timeout >= minFastFailTimeout {
+		// If greater than minFastFailTimeout, increase by 50% for safety margin
+		timeout = int64(float64(timeout) * 1.5)
+	} else {
+		timeout = minFastFailTimeout
+	}
+	return f.buildClientWithTimeout(time.Duration(timeout))
+}
+
+// buildClientWithTimeout creates an HTTP client with the specified connection timeout.
+func (f *Fetcher) buildClientWithTimeout(timeout time.Duration) *http.Client {
+	jar, _ := cookiejar.New(nil)
+	client, err := httpclient.NewClient(httpclient.Options{
+		Client: httpclient.ClientOptions{
+			Jar: jar,
+		},
+		Transport: httpclient.TransportOptions{
+			DialContext: (&net.Dialer{
+				Timeout: timeout,
+			}).DialContext,
+			Proxy: f.ctl.GetProxy(f.meta.Req.Proxy),
+			TLSClientConfig: &tls.Config{
+				InsecureSkipVerify: f.meta.Req.SkipVerifyCert,
+			},
+			TLSHandshakeTimeout: timeout,
+		},
+		Impersonation: httpclient.ImpersonationOptions{
+			Mode:    httpclient.ImpersonationAuto,
+			Session: f.impersonationSession,
+		},
+	})
+	if err != nil {
+		panic(fmt.Sprintf("build HTTP client: %v", err))
+	}
+	return client
+}
+
+// ============================================================================
+// Filename Parsing
+// ============================================================================
+
+// parseFilename extracts filename from Content-Disposition header
+func parseFilename(contentDisposition string) string {
+	// Try RFC 5987 extended notation first (filename*=)
+	if filename := parseFilenameExtended(contentDisposition); filename != "" {
+		return filename
+	}
+
+	// Try standard MIME parsing
+	_, params, err := mime.ParseMediaType(contentDisposition)
+	if err == nil {
+		if filename := params["filename"]; filename != "" {
+			return decodeFilenameParam(filename)
+		}
+	}
+
+	// Fallback to manual parsing
+	return parseFilenameFallback(contentDisposition)
+}
+
+// appendFilenameExtension adds a MIME-derived extension when the resolved
+// filename has no usable extension. Some image hosts use opaque path segments
+// that look like extensions, even though the response Content-Type is the
+// only reliable source for the file type.
+func appendFilenameExtension(filename, contentType string) string {
+	mediaType, _, err := mime.ParseMediaType(contentType)
+	if err != nil {
+		return filename
+	}
+
+	extensions, err := mime.ExtensionsByType(mediaType)
+	if err != nil || len(extensions) == 0 {
+		return filename
+	}
+
+	ext := path.Ext(filename)
+	if len(ext) > 1 && len(ext) <= 20 {
+		return filename
+	}
+	return filename + extensions[0]
+}
+
+// parseFilenameExtended handles RFC 5987 extended notation (filename*=)
+// Format: filename*=charset'language'value (e.g., UTF-8”%E6%B5%8B%E8%AF%95.zip)
+func parseFilenameExtended(cd string) string {
+	lower := strings.ToLower(cd)
+	idx := strings.Index(lower, "filename*=")
+	if idx == -1 {
+		return ""
+	}
+
+	value := cd[idx+len("filename*="):]
+
+	// Find the end of the value using proper quote handling
+	endIdx := findParamValueEnd(value)
+	if endIdx != -1 {
+		value = value[:endIdx]
+	}
+	value = strings.TrimSpace(value)
+
+	// Try charset''encoded format (e.g., UTF-8''%E4%B8%AD%E6%96%87.txt)
+	parts := strings.SplitN(value, "''", 2)
+	if len(parts) == 2 {
+		// Use PathUnescape to handle %2B correctly (should decode to +, not space)
+		decoded, err := url.PathUnescape(parts[1])
+		if err == nil {
+			return decoded
+		}
+	}
+
+	// Try charset'language'encoded format
+	parts = strings.SplitN(value, "'", 3)
+	if len(parts) >= 3 {
+		// Use PathUnescape to handle %2B correctly (should decode to +, not space)
+		decoded, err := url.PathUnescape(parts[2])
+		if err == nil {
+			return decoded
+		}
+	}
+
+	return ""
+}
+
+// decodeFilenameParam decodes filename parameter value
+// Handles HTML entities, MIME encoded-word, URL encoding, and GBK encoding fallback
+func decodeFilenameParam(filename string) string {
+	// First, unescape HTML entities (e.g., &amp; -> &, &lt; -> <, &gt; -> >)
+	// This must be done before other decoding to handle cases where servers
+	// HTML-encode special characters in filenames
+	filename = unescapeHTMLEntities(filename)
+
+	// Handle RFC 2047 encoded word (=?charset?encoding?text?=)
+	if strings.HasPrefix(filename, "=?") {
+		decoder := new(mime.WordDecoder)
+		normalizedFilename := strings.Replace(filename, "UTF8", "UTF-8", 1)
+		if decoded, err := decoder.Decode(normalizedFilename); err == nil {
+			return decoded
+		}
+	}
+
+	// Try URL decoding - use PathUnescape for filenames to handle %2B correctly
+	decoded := util.TryUrlPathUnescape(filename)
+
+	// If not valid UTF-8, try GBK decoding (common for Chinese websites)
+	if !utf8.ValidString(decoded) {
+		if gbkDecoded := tryDecodeGBK(decoded); gbkDecoded != "" {
+			return gbkDecoded
+		}
+	}
+
+	return decoded
+}
+
+// unescapeHTMLEntities unescapes common HTML entities in filenames
+// This handles cases where servers HTML-encode special characters like & to &amp;
+func unescapeHTMLEntities(s string) string {
+	// Common HTML entities that might appear in filenames
+	replacements := map[string]string{
+		"&amp;":  "&",
+		"&lt;":   "<",
+		"&gt;":   ">",
+		"&quot;": "\"",
+		"&#39;":  "'",
+		"&apos;": "'",
+	}
+
+	result := s
+	for entity, char := range replacements {
+		result = strings.ReplaceAll(result, entity, char)
+	}
+	return result
+}
+
+// tryDecodeGBK attempts to decode string as GBK encoding
+func tryDecodeGBK(s string) string {
+	if len(s) == 0 {
+		return ""
+	}
+
+	decoder := simplifiedchinese.GBK.NewDecoder()
+	decoded, err := decoder.Bytes([]byte(s))
+	if err != nil {
+		return ""
+	}
+	result := string(decoded)
+	if utf8.ValidString(result) {
+		return result
+	}
+	return ""
+}
+
+// parseFilenameFallback is a fallback parser for non-standard Content-Disposition
+func parseFilenameFallback(cd string) string {
+	lower := strings.ToLower(cd)
+	idx := strings.Index(lower, "filename=")
+	if idx == -1 {
+		return ""
+	}
+
+	value := cd[idx+len("filename="):]
+
+	// Find the end of the value using proper quote handling
+	endIdx := findParamValueEnd(value)
+	if endIdx != -1 {
+		value = value[:endIdx]
+	}
+	value = strings.TrimSpace(value)
+
+	// Remove surrounding quotes
+	if len(value) >= 2 {
+		if (value[0] == '"' && value[len(value)-1] == '"') ||
+			(value[0] == '\'' && value[len(value)-1] == '\'') {
+			value = value[1 : len(value)-1]
+		}
+	}
+
+	return decodeFilenameParam(value)
+}
+
+// findParamValueEnd finds the end position of a parameter value in a Content-Disposition header.
+// It correctly handles quoted values where semicolons inside quotes should not be treated as delimiters.
+// It also handles HTML entities in unquoted values (e.g., &amp; should not be split at the semicolon).
+// Returns the end index (exclusive) of the value, or -1 if it extends to the end of the string.
+func findParamValueEnd(value string) int {
+	value = strings.TrimSpace(value)
+	if len(value) == 0 {
+		return 0
+	}
+
+	// If the value starts with a quote, find the matching closing quote
+	if value[0] == '"' || value[0] == '\'' {
+		quote := value[0]
+		// Find the closing quote, handling escaped quotes
+		for i := 1; i < len(value); i++ {
+			if value[i] == quote {
+				// Check if it's escaped
+				if i > 0 && value[i-1] == '\\' {
+					continue
+				}
+				// Found closing quote, now look for ; after it
+				remaining := value[i+1:]
+				if semiIdx := strings.Index(remaining, ";"); semiIdx != -1 {
+					return i + 1 + semiIdx
+				}
+				return -1 // No semicolon after closing quote
+			}
+		}
+		// No closing quote found, treat rest of string as value
+		return -1
+	}
+
+	// Unquoted value - find the next semicolon that's not part of an HTML entity
+	// HTML entities have the pattern &...;  (e.g., &amp; &lt; &gt; &quot; &#39;)
+	for i := 0; i < len(value); i++ {
+		if value[i] == ';' {
+			// Check if this semicolon is part of an HTML entity
+			// Look backwards for an & character
+			isEntity := false
+			if i > 0 {
+				// Look for & before this semicolon (within reasonable distance, max 10 chars)
+				for j := i - 1; j >= 0 && j >= i-10; j-- {
+					if value[j] == '&' {
+						// Found &, this semicolon might be part of an HTML entity
+						// Check if there are only alphanumeric or # between & and ;
+						entityChars := value[j+1 : i]
+						if len(entityChars) > 0 && isValidHTMLEntityChars(entityChars) {
+							isEntity = true
+						}
+						break
+					}
+					// If we hit whitespace or another special char, stop looking
+					if value[j] == ' ' || value[j] == '"' || value[j] == '\'' {
+						break
+					}
+				}
+			}
+
+			if !isEntity {
+				return i
+			}
+		}
+	}
+	return -1 // No semicolon, extends to end
+}
+
+// isValidHTMLEntityChars checks if a string contains only valid HTML entity characters
+// (alphanumeric and #, typically for entities like &amp; &lt; &#39; etc.)
+func isValidHTMLEntityChars(s string) bool {
+	if len(s) == 0 {
+		return false
+	}
+	for _, c := range s {
+		if !((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '#') {
+			return false
+		}
+	}
+	return true
+}
@@ -0,0 +1,40 @@
+package http
+
+import (
+	"context"
+	"io"
+	"time"
+)
+
+type TimeoutReader struct {
+	reader  io.Reader
+	timeout time.Duration
+}
+
+func NewTimeoutReader(r io.Reader, timeout time.Duration) *TimeoutReader {
+	return &TimeoutReader{
+		reader:  r,
+		timeout: timeout,
+	}
+}
+
+func (tr *TimeoutReader) Read(p []byte) (n int, err error) {
+	ctx, cancel := context.WithTimeout(context.Background(), tr.timeout)
+	defer cancel()
+
+	done := make(chan struct{})
+	var readErr error
+	var bytesRead int
+
+	go func() {
+		bytesRead, readErr = tr.reader.Read(p)
+		close(done)
+	}()
+
+	select {
+	case <-done:
+		return bytesRead, readErr
+	case <-ctx.Done():
+		return 0, ctx.Err()
+	}
+}
@@ -0,0 +1,51 @@
+package http
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"io"
+	"testing"
+	"time"
+)
+
+func TestTimeoutReader_Read(t *testing.T) {
+	data := []byte("Hello, World!")
+	reader := bytes.NewReader(data)
+	timeoutReader := NewTimeoutReader(reader, 1*time.Second)
+
+	buf := make([]byte, len(data))
+	n, err := timeoutReader.Read(buf)
+	if err != nil {
+		t.Fatalf("expected no error, got %v", err)
+	}
+	if n != len(data) {
+		t.Fatalf("expected to read %d bytes, read %d", len(data), n)
+	}
+	if !bytes.Equal(buf, data) {
+		t.Fatalf("expected %s, got %s", data, buf)
+	}
+}
+
+func TestTimeoutReader_ReadTimeout(t *testing.T) {
+	reader := &slowReader{delay: 2 * time.Second}
+	timeoutReader := NewTimeoutReader(reader, 1*time.Second)
+
+	buf := make([]byte, 8192)
+	_, err := timeoutReader.Read(buf)
+	if err == nil {
+		t.Fatal("expected timeout error, got nil")
+	}
+	if !errors.Is(err, context.DeadlineExceeded) {
+		t.Fatalf("expected %v, got %v", context.DeadlineExceeded, err)
+	}
+}
+
+type slowReader struct {
+	delay time.Duration
+}
+
+func (sr *slowReader) Read(p []byte) (n int, err error) {
+	time.Sleep(sr.delay)
+	return 0, io.EOF
+}
@@ -2,18 +2,23 @@ package test

 import (
 	"context"
+	"crypto/rand"
 	"encoding/json"
+	"errors"
 	"fmt"
-	"github.com/armon/go-socks5"
 	"io"
-	"math/rand"
 	"net"
 	"net/http"
 	"os"
+	"reflect"
 	"strconv"
 	"strings"
 	"sync/atomic"
 	"time"
+
+	"github.com/GopeedLab/gopeed/pkg/base"
+	"github.com/armon/go-socks5"
+	"golang.org/x/text/encoding/simplifiedchinese"
 )

 const (
@@ -22,14 +27,23 @@ const (
 	Dir       = "./"
 	BuildFile = Dir + BuildName

+	ExternalDownloadUrl  = "https://raw.githubusercontent.com/GopeedLab/gopeed/v1.5.6/_docs/img/banner.png"
+	ExternalDownloadName = "banner.png"
+	ExternalDownloadSize = 26416
+	//ExternalDownloadMd5 = "c67c6e3cae79a95342485676571e8a5c"
+
 	DownloadName       = "download.data"
 	DownloadRename     = "download (1).data"
 	DownloadFile       = Dir + DownloadName
 	DownloadRenameFile = Dir + DownloadRename
+
+	// TestChineseFileName is a common test filename with Chinese characters
+	// Used to test Content-Disposition parsing with various encodings
+	TestChineseFileName = "测试.zip"
 )

 func StartTestFileServer() net.Listener {
-	return startTestServer(func() http.Handler {
+	return startTestServer(func(sl *shutdownListener) http.Handler {
 		return http.FileServer(http.Dir(Dir))
 	})
 }
@@ -45,7 +59,7 @@ func (s *SlowFileServer) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 }

 func StartTestSlowFileServer(delay time.Duration) net.Listener {
-	return startTestServer(func() http.Handler {
+	return startTestServer(func(sl *shutdownListener) http.Handler {
 		return &SlowFileServer{
 			delay:   delay,
 			handler: http.FileServer(http.Dir(Dir)),
@@ -54,8 +68,11 @@ func StartTestSlowFileServer(delay time.Duration) net.Listener {
 }

 func StartTestCustomServer() net.Listener {
-	return startTestServer(func() http.Handler {
+	return startTestServer(func(sl *shutdownListener) http.Handler {
 		mux := http.NewServeMux()
+		mux.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
+			writer.WriteHeader(200)
+		})
 		mux.HandleFunc("/"+BuildName, func(writer http.ResponseWriter, request *http.Request) {
 			file, err := os.Open(BuildFile)
 			if err != nil {
@@ -75,13 +92,168 @@ func StartTestCustomServer() net.Listener {
 			defer file.Close()
 			io.Copy(writer, file)
 		})
+		mux.HandleFunc("/encoded-word", func(writer http.ResponseWriter, request *http.Request) {
+			writer.Header().Set("Content-Disposition", "attachment; filename=\"=?UTF8?B?5rWL6K+VLnppcA==?=\"")
+			writer.Header().Set("Content-Type", "application/octet-stream")
+			writer.Header().Set("Content-Length", fmt.Sprintf("%d", BuildSize))
+			file, err := os.Open(BuildFile)
+			if err != nil {
+				panic(err)
+			}
+			defer file.Close()
+			io.Copy(writer, file)
+		})
+		mux.HandleFunc("/%E6%B5%8B%E8%AF%95.zip", func(writer http.ResponseWriter, request *http.Request) {
+			file, err := os.Open(BuildFile)
+			if err != nil {
+				panic(err)
+			}
+			defer file.Close()
+			io.Copy(writer, file)
+		})
+		mux.HandleFunc("/no-encode", func(writer http.ResponseWriter, request *http.Request) {
+			writer.Header().Set("Content-Disposition", "attachment; filename="+TestChineseFileName)
+			writer.Header().Set("Content-Type", "application/octet-stream")
+			writer.Header().Set("Content-Length", fmt.Sprintf("%d", BuildSize))
+			file, err := os.Open(BuildFile)
+			if err != nil {
+				panic(err)
+			}
+			defer file.Close()
+			io.Copy(writer, file)
+		})
+		// Test endpoint for mixed encoding: filename= with garbled characters (including special chars)
+		// and filename*= with proper UTF-8. This tests the case where mime.ParseMediaType fails
+		// due to invalid characters like <a> tags in the filename.
+		mux.HandleFunc("/mixed-encoding", func(writer http.ResponseWriter, request *http.Request) {
+			// This simulates a server that sends a garbled filename= with special chars that cause
+			// mime.ParseMediaType to fail, plus a proper filename*=UTF-8''...
+			// The filename*= should be preferred and correctly parsed.
+			writer.Header().Set("Content-Disposition", `attachment;filename="garbled<invalid>chars.zip";filename*=UTF-8''%E6%B5%8B%E8%AF%95.zip`)
+			writer.Header().Set("Content-Type", "application/octet-stream")
+			writer.Header().Set("Content-Length", fmt.Sprintf("%d", BuildSize))
+			file, err := os.Open(BuildFile)
+			if err != nil {
+				panic(err)
+			}
+			defer file.Close()
+			io.Copy(writer, file)
+		})
+		// Test endpoint for filename*= only (RFC 5987 format)
+		mux.HandleFunc("/filename-star", func(writer http.ResponseWriter, request *http.Request) {
+			// URL-encoded TestChineseFileName: 测试.zip -> %E6%B5%8B%E8%AF%95.zip
+			writer.Header().Set("Content-Disposition", `attachment; filename*=UTF-8''%E6%B5%8B%E8%AF%95.zip`)
+			writer.Header().Set("Content-Type", "application/octet-stream")
+			writer.Header().Set("Content-Length", fmt.Sprintf("%d", BuildSize))
+			file, err := os.Open(BuildFile)
+			if err != nil {
+				panic(err)
+			}
+			defer file.Close()
+			io.Copy(writer, file)
+		})
+		// Test endpoint for GBK-encoded filename (common on Chinese Windows servers)
+		// This simulates the case where Chinese characters are sent as GBK bytes
+		// which appear as garbled characters when interpreted as UTF-8.
+		// For example, "测试" in GBK is [B2 E2 CA D4] which is invalid UTF-8.
+		// Our fix detects invalid UTF-8 and attempts GBK decoding.
+		mux.HandleFunc("/gbk-encoded", func(writer http.ResponseWriter, request *http.Request) {
+			// Encode TestChineseFileName as GBK
+			gbkEncoder := simplifiedchinese.GBK.NewEncoder()
+			gbkBytes, _ := gbkEncoder.Bytes([]byte(TestChineseFileName))
+			// Send GBK bytes directly in filename (simulating broken server behavior)
+			writer.Header().Set("Content-Disposition", `attachment; filename="`+string(gbkBytes)+`"`)
+			writer.Header().Set("Content-Type", "application/octet-stream")
+			writer.Header().Set("Content-Length", fmt.Sprintf("%d", BuildSize))
+			file, err := os.Open(BuildFile)
+			if err != nil {
+				panic(err)
+			}
+			defer file.Close()
+			io.Copy(writer, file)
+		})
+		// Test endpoint for filenames with plus signs (C++ files, etc.)
+		// This tests that %2B decodes to + not space
+		mux.HandleFunc("/plus-sign-encoded", func(writer http.ResponseWriter, request *http.Request) {
+			// Use filename*= format with %2B encoding for plus signs
+			writer.Header().Set("Content-Disposition", `attachment; filename*=UTF-8''C%2B%2B%20%20Primer%20%20Plus.mobi`)
+			writer.Header().Set("Content-Type", "application/octet-stream")
+			writer.Header().Set("Content-Length", fmt.Sprintf("%d", BuildSize))
+			file, err := os.Open(BuildFile)
+			if err != nil {
+				panic(err)
+			}
+			defer file.Close()
+			io.Copy(writer, file)
+		})
+		// Test endpoint for plus sign in URL path
+		mux.HandleFunc("/C%2B%2B%20Primer.txt", func(writer http.ResponseWriter, request *http.Request) {
+			file, err := os.Open(BuildFile)
+			if err != nil {
+				panic(err)
+			}
+			defer file.Close()
+			io.Copy(writer, file)
+		})
+		// Test endpoint for filename with HTML-encoded ampersand (&amp;)
+		// This tests the case from the bug report where filenames containing & are
+		// HTML-encoded as &amp; by the server, causing truncation at the semicolon.
+		// Example: "查询处理&优化.pptx" -> "查询处理&amp;优化.pptx"
+		mux.HandleFunc("/ampersand-encoded", func(writer http.ResponseWriter, request *http.Request) {
+			// Simulate server sending filename with HTML-encoded ampersand
+			writer.Header().Set("Content-Disposition", `attachment; filename="查询处理&amp;优化.pptx"`)
+			writer.Header().Set("Content-Type", "application/octet-stream")
+			writer.Header().Set("Content-Length", fmt.Sprintf("%d", BuildSize))
+			file, err := os.Open(BuildFile)
+			if err != nil {
+				panic(err)
+			}
+			defer file.Close()
+			io.Copy(writer, file)
+		})
+		// Test endpoint for unquoted filename with HTML-encoded ampersand
+		// Some servers might send unquoted filenames with HTML entities
+		mux.HandleFunc("/ampersand-unquoted", func(writer http.ResponseWriter, request *http.Request) {
+			writer.Header().Set("Content-Disposition", `attachment; filename=test&amp;file.txt`)
+			writer.Header().Set("Content-Type", "application/octet-stream")
+			writer.Header().Set("Content-Length", fmt.Sprintf("%d", BuildSize))
+			file, err := os.Open(BuildFile)
+			if err != nil {
+				panic(err)
+			}
+			defer file.Close()
+			io.Copy(writer, file)
+		})
+		// Test 403 Forbidden endpoint
+		mux.HandleFunc("/forbidden", func(writer http.ResponseWriter, request *http.Request) {
+			writer.WriteHeader(403)
+		})
+		return mux
+	})
+}
+
+// StartTestHostHeaderServer starts a server that validates the Host header
+// Returns 400 Bad Request if the Host header value equals "test"
+func StartTestHostHeaderServer() net.Listener {
+	return startTestServer(func(sl *shutdownListener) http.Handler {
+		mux := http.NewServeMux()
+		mux.HandleFunc("/", func(writer http.ResponseWriter, request *http.Request) {
+			// If the Host header is "test", return 400 (simulating server that validates Host)
+			if request.Host == "test" {
+				writer.WriteHeader(400)
+				writer.Write([]byte("Bad Request: Invalid Host header"))
+				return
+			}
+			writer.WriteHeader(200)
+			writer.Write([]byte("OK"))
+		})
 		return mux
 	})
 }

 func StartTestRetryServer() net.Listener {
 	counter := 0
-	return startTestServer(func() http.Handler {
+	return startTestServer(func(sl *shutdownListener) http.Handler {
 		mux := http.NewServeMux()
 		mux.HandleFunc("/"+BuildName, func(writer http.ResponseWriter, request *http.Request) {
 			counter++
@@ -101,7 +273,7 @@ func StartTestRetryServer() net.Listener {
 }

 func StartTestPostServer() net.Listener {
-	return startTestServer(func() http.Handler {
+	return startTestServer(func(sl *shutdownListener) http.Handler {
 		mux := http.NewServeMux()
 		mux.HandleFunc("/"+BuildName, func(writer http.ResponseWriter, request *http.Request) {
 			if request.Method == "POST" && request.Header.Get("Authorization") != "" {
@@ -124,25 +296,237 @@ func StartTestPostServer() net.Listener {
 }

 func StartTestErrorServer() net.Listener {
-	counter := 0
-	return startTestServer(func() http.Handler {
+	return startTestServer(func(sl *shutdownListener) http.Handler {
 		mux := http.NewServeMux()
 		mux.HandleFunc("/"+BuildName, func(writer http.ResponseWriter, request *http.Request) {
-			counter++
-			if counter != 1 {
-				writer.WriteHeader(500)
+			// Always return 404 error to test error handling
+			writer.WriteHeader(404)
+			return
+		})
+		return mux
+	})
+}
+
+// StartTestOneTimeServer creates a server where the URL can only be downloaded once
+// The first non-probe request succeeds, all subsequent requests return 404
+// This simulates one-time download URLs (e.g., signed URLs that expire after first use)
+func StartTestOneTimeServer() net.Listener {
+	var accessed atomic.Bool
+
+	return startTestServer(func(sl *shutdownListener) http.Handler {
+		mux := http.NewServeMux()
+		mux.HandleFunc("/"+BuildName, func(writer http.ResponseWriter, request *http.Request) {
+			// First full download request succeeds, subsequent requests fail
+			if accessed.Swap(true) {
+				writer.WriteHeader(404)
 				return
 			}
+
+			// First request - return full file without Range support
+			writer.Header().Set("Content-Length", fmt.Sprintf("%d", BuildSize))
+			file, err := os.Open(BuildFile)
+			if err != nil {
+				return
+			}
+			defer file.Close()
+			io.Copy(writer, file)
+		})
+		return mux
+	})
+}
+
+// StartTestNoRangeSlowServer creates a server that always returns the full file
+// with Content-Length but does not support Range requests.
+func StartTestNoRangeSlowServer(delayPerChunk time.Duration) net.Listener {
+	return startTestServer(func(sl *shutdownListener) http.Handler {
+		mux := http.NewServeMux()
+		mux.HandleFunc("/"+BuildName, func(writer http.ResponseWriter, request *http.Request) {
+			writer.Header().Set("Content-Length", fmt.Sprintf("%d", BuildSize))
+
+			file, err := os.Open(BuildFile)
+			if err != nil {
+				return
+			}
+			defer file.Close()
+
+			buf := make([]byte, 256*1024)
+			for !sl.isShutdown {
+				n, readErr := file.Read(buf)
+				if n > 0 {
+					if _, writeErr := writer.Write(buf[:n]); writeErr != nil {
+						return
+					}
+					if flusher, ok := writer.(http.Flusher); ok {
+						flusher.Flush()
+					}
+					if delayPerChunk > 0 {
+						time.Sleep(delayPerChunk)
+					}
+				}
+				if readErr != nil {
+					return
+				}
+			}
 		})
 		return mux
 	})
 }

-// StartTestLimitServer connections limit server
-func StartTestLimitServer(maxConnections int32, delay int64) net.Listener {
+// StartTestIgnoredRangeServer advertises byte-range support but ignores Range
+// requests and always returns the full representation with 200 OK.
+func StartTestIgnoredRangeServer(delayPerChunk time.Duration) net.Listener {
+	return startTestServer(func(sl *shutdownListener) http.Handler {
+		mux := http.NewServeMux()
+		mux.HandleFunc("/"+BuildName, func(writer http.ResponseWriter, request *http.Request) {
+			writer.Header().Set("Content-Length", fmt.Sprintf("%d", BuildSize))
+			writer.Header().Set("Accept-Ranges", "bytes")
+			writer.WriteHeader(http.StatusOK)
+			if flusher, ok := writer.(http.Flusher); ok {
+				flusher.Flush()
+			}
+
+			file, err := os.Open(BuildFile)
+			if err != nil {
+				return
+			}
+			defer file.Close()
+
+			buf := make([]byte, 256*1024)
+			for !sl.isShutdown {
+				n, readErr := file.Read(buf)
+				if n > 0 {
+					if _, writeErr := writer.Write(buf[:n]); writeErr != nil {
+						return
+					}
+					if delayPerChunk > 0 {
+						time.Sleep(delayPerChunk)
+					}
+				}
+				if readErr != nil {
+					return
+				}
+			}
+		})
+		return mux
+	})
+}
+
+// StartTestExpiringRedirectServer creates a server that simulates expiring redirect URLs.
+// The original URL redirects to a temporary URL that expires after a specified number of requests.
+// When the temporary URL expires (returns 403), the client should retry with the original URL
+// to get a new redirect URL.
+// Parameters:
+//   - requestsBeforeExpire: number of requests the temporary URL accepts before expiring
+//   - delayPerByte: optional delay per byte for slow transfer (use 0 for no delay)
+func StartTestExpiringRedirectServer(requestsBeforeExpire int32, delayPerByte time.Duration) net.Listener {
+	var redirectVersion atomic.Int32
+	var requestCount atomic.Int32
+	redirectVersion.Store(1)
+
+	return startTestServer(func(sl *shutdownListener) http.Handler {
+		return http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
+			path := request.URL.Path
+
+			// Original URL - redirects to current version of temporary URL
+			if path == "/"+BuildName {
+				// Reset request count when original URL is accessed
+				requestCount.Store(0)
+				// Redirect to versioned temporary URL
+				version := redirectVersion.Load()
+				redirectURL := fmt.Sprintf("/redirect-v%d/%s", version, BuildName)
+				http.Redirect(writer, request, redirectURL, http.StatusFound)
+				return
+			}
+
+			// Temporary URL handler - matches /redirect-v{N}/... pattern
+			if strings.HasPrefix(path, "/redirect-v") {
+				// Check if the redirect has expired
+				count := requestCount.Add(1)
+				if count > requestsBeforeExpire {
+					// Redirect expired - increment version for next redirect
+					redirectVersion.Add(1)
+					writer.WriteHeader(403)
+					writer.Write([]byte("Redirect URL expired"))
+					return
+				}
+
+				// Serve the file with range support
+				rangeFileHandle(
+					writer,
+					request,
+					nil,
+					func(file *os.File, n int64) {
+						if delayPerByte > 0 {
+							slowCopyNWithDelay(sl, writer, file, n, delayPerByte)
+						} else {
+							io.CopyN(writer, file, n)
+						}
+					},
+				)
+				return
+			}
+
+			// Not found
+			writer.WriteHeader(404)
+		})
+	})
+}
+
+// StartTestLowSpeedServer creates a server with configurable delay per request
+func StartTestLowSpeedServer(delayPerByte time.Duration) net.Listener {
+	return startTestServer(func(sl *shutdownListener) http.Handler {
+		mux := http.NewServeMux()
+		mux.HandleFunc("/"+BuildName, func(writer http.ResponseWriter, request *http.Request) {
+			rangeFileHandle(
+				writer,
+				request,
+				nil,
+				func(file *os.File, n int64) {
+					slowCopyNWithDelay(sl, writer, file, n, delayPerByte)
+				},
+			)
+		})
+		return mux
+	})
+}
+
+// slowCopyNWithDelay copies n bytes from src to dst with a delay per byte
+func slowCopyNWithDelay(sl *shutdownListener, dst io.Writer, src io.Reader, n int64, delayPerByte time.Duration) {
+	buf := make([]byte, 32*1024)
+	remaining := n
+	for remaining > 0 {
+		if sl.isShutdown {
+			return
+		}
+		toRead := int64(len(buf))
+		if toRead > remaining {
+			toRead = remaining
+		}
+		nr, er := src.Read(buf[:toRead])
+		if nr > 0 {
+			nw, ew := dst.Write(buf[0:nr])
+			if nw > 0 {
+				remaining -= int64(nw)
+				// Add delay based on bytes written
+				if delayPerByte > 0 {
+					time.Sleep(delayPerByte * time.Duration(nw))
+				}
+			}
+			if ew != nil {
+				break
+			}
+		}
+		if er != nil {
+			break
+		}
+	}
+}
+
+// StartTestConLimitServer connections limit server
+func StartTestConLimitServer(maxConnections int32) net.Listener {
 	var connections atomic.Int32

-	return startTestServer(func() http.Handler {
+	return startTestServer(func(sl *shutdownListener) http.Handler {
 		mux := http.NewServeMux()
 		mux.HandleFunc("/"+BuildName, func(writer http.ResponseWriter, request *http.Request) {
 			defer func() {
@@ -153,68 +537,254 @@ func StartTestLimitServer(maxConnections int32, delay int64) net.Listener {
 				writer.WriteHeader(403)
 				return
 			}
-
-			r := request.Header.Get("Range")
-			if r == "" {
-				writer.Header().Set("Content-Length", fmt.Sprintf("%d", BuildSize))
-				writer.WriteHeader(200)
-				file, err := os.Open(BuildFile)
-				if err != nil {
-					panic(err)
-				}
-				defer file.Close()
-				slowCopy(writer, file, delay)
-			} else {
-				// split range
-				s := strings.Split(r, "=")
-				if len(s) != 2 {
-					writer.WriteHeader(400)
-					return
-				}
-				s = strings.Split(s[1], "-")
-				if len(s) != 2 {
-					writer.WriteHeader(400)
-					return
-				}
-				start, err := strconv.ParseInt(s[0], 10, 64)
-				if err != nil {
-					writer.WriteHeader(400)
-					return
-				}
-				end, err := strconv.ParseInt(s[1], 10, 64)
-				if err != nil {
-					writer.WriteHeader(400)
-					return
-				}
-				if start < 0 || end < 0 || start > end {
-					writer.WriteHeader(400)
-					return
-				}
-				if end >= BuildSize {
-					end = BuildSize - 1
-				}
-				writer.Header().Set("Content-Length", fmt.Sprintf("%d", end-start+1))
-				writer.Header().Set("Content-Range", fmt.Sprintf("bytes %d-%d/%d", start, end, BuildSize))
-				writer.Header().Set("Accept-Ranges", "bytes")
-				writer.WriteHeader(206)
-				file, err := os.Open(BuildFile)
-				if err != nil {
-					writer.WriteHeader(500)
-					return
-				}
-				defer file.Close()
-				file.Seek(start, 0)
-				slowCopyN(writer, file, end-start+1, delay)
-			}
+			rangeFileHandle(
+				writer,
+				request,
+				nil,
+				func(file *os.File, n int64) {
+					slowCopyN(sl, writer, file, n, 0)
+				},
+			)
 		})
 		return mux
 	})
 }

+// StartTestTimeoutOnceServer creates a server that times out on first request, then works normally
+func StartTestTimeoutOnceServer(delay int64) net.Listener {
+	var timeoutOnce atomic.Bool
+
+	return startTestServer(func(sl *shutdownListener) http.Handler {
+		mux := http.NewServeMux()
+		mux.HandleFunc("/"+BuildName, func(writer http.ResponseWriter, request *http.Request) {
+			// First request delays to trigger timeout, subsequent requests respond normally
+			useInitialDelay := delay > 0 && !timeoutOnce.Swap(true)
+			rangeFileHandle(
+				writer,
+				request,
+				nil,
+				func(file *os.File, n int64) {
+					if useInitialDelay {
+						slowCopyAfterDelay(sl, writer, file, n, delay)
+						return
+					}
+					slowCopyN(sl, writer, file, n, 0)
+				},
+			)
+		})
+		return mux
+	})
+}
+
+// StartTestTemporary500Server creates a server that returns 500 for a duration, then recovers
+// Uses slow transfer to ensure the file isn't fully downloaded during resolve phase
+func StartTestTemporary500Server(errorDuration time.Duration) net.Listener {
+	startTime := time.Now()
+	var requestCount atomic.Int32
+
+	return startTestServer(func(sl *shutdownListener) http.Handler {
+		mux := http.NewServeMux()
+		mux.HandleFunc("/"+BuildName, func(writer http.ResponseWriter, request *http.Request) {
+			reqNum := requestCount.Add(1)
+
+			// First request (Resolve) succeeds with slow transfer to prevent full download
+			// Subsequent requests return 500 for the specified duration, then recover
+			if reqNum == 1 {
+				// Slow transfer for resolve: 50 microsecond per byte (~20MB/s)
+				// This ensures resolve doesn't complete the full 200MB file
+				rangeFileHandle(
+					writer,
+					request,
+					nil,
+					func(file *os.File, n int64) {
+						slowCopyNWithDelay(sl, writer, file, n, 50*time.Microsecond)
+					},
+				)
+				return
+			}
+
+			// Subsequent requests: return 500 for errorDuration, then normal
+			if time.Since(startTime) < errorDuration {
+				writer.WriteHeader(500)
+				writer.Write([]byte("Internal Server Error"))
+				return
+			}
+
+			rangeFileHandle(
+				writer,
+				request,
+				nil,
+				func(file *os.File, n int64) {
+					slowCopyN(sl, writer, file, n, 0)
+				},
+			)
+		})
+		return mux
+	})
+}
+
+// StartTestFailThenRecoverServer creates a server that fails all connections initially,
+// then recovers after a specified number of failed requests.
+// This tests the retry functionality when calling Start() again after a download fails.
+// Parameters:
+//   - failedRequestsBeforeRecover: number of requests that will fail before server recovers
+//
+// Note: Uses 416 (Range Not Satisfiable) instead of 500 because 5xx errors are exempt
+// from failure counting and will retry indefinitely. 416 is counted as a failure.
+func StartTestFailThenRecoverServer(failedRequestsBeforeRecover int32) net.Listener {
+	var requestCount atomic.Int32
+
+	return startTestServer(func(sl *shutdownListener) http.Handler {
+		mux := http.NewServeMux()
+		mux.HandleFunc("/"+BuildName, func(writer http.ResponseWriter, request *http.Request) {
+			reqNum := requestCount.Add(1)
+
+			// First request (Resolve) always succeeds
+			if reqNum == 1 {
+				rangeFileHandle(
+					writer,
+					request,
+					nil,
+					func(file *os.File, n int64) {
+						io.CopyN(writer, file, n)
+					},
+				)
+				return
+			}
+
+			// Subsequent requests fail until we've had enough failures
+			// Use 416 Range Not Satisfiable - this error is counted towards failure limit
+			if reqNum <= failedRequestsBeforeRecover+1 { // +1 because first request is resolve
+				writer.WriteHeader(416)
+				writer.Write([]byte("Range Not Satisfiable"))
+				return
+			}
+
+			// After enough failures, server recovers
+			rangeFileHandle(
+				writer,
+				request,
+				nil,
+				func(file *os.File, n int64) {
+					io.CopyN(writer, file, n)
+				},
+			)
+		})
+		return mux
+	})
+}
+
+// StartTestRangeBugServer simulate bug server:
+// Don't follow Range request rules, always return more data than range, e.g. Range: bytes=0-100, return 150 bytes
+func StartTestRangeBugServer() net.Listener {
+	return startTestServer(func(sl *shutdownListener) http.Handler {
+		mux := http.NewServeMux()
+		mux.HandleFunc("/"+BuildName, func(writer http.ResponseWriter, request *http.Request) {
+			rangeFileHandle(
+				writer,
+				request,
+				func(end int64) int64 {
+					var bugEnd = end
+					if end != 0 {
+						bugEnd = end + 50
+						if bugEnd >= BuildSize {
+							bugEnd = end
+						}
+					}
+					return bugEnd
+				},
+				func(file *os.File, n int64) {
+					io.CopyN(writer, file, n)
+				},
+			)
+		})
+		return mux
+	})
+}
+
+func rangeFileHandle(writer http.ResponseWriter, request *http.Request, modifyEnd func(end int64) int64, iocpN func(file *os.File, n int64)) {
+	r := request.Header.Get("Range")
+
+	// If no Range header, return full file with Accept-Ranges header
+	if r == "" {
+		// Open file first to ensure it exists
+		file, err := os.Open(BuildFile)
+		if err != nil {
+			writer.WriteHeader(500)
+			return
+		}
+		defer file.Close()
+
+		writer.Header().Set("Content-Length", fmt.Sprintf("%d", BuildSize))
+		writer.Header().Set("Accept-Ranges", "bytes")
+		writer.WriteHeader(200)
+		(writer.(http.Flusher)).Flush()
+
+		iocpN(file, BuildSize)
+		return
+	}
+
+	// split range
+	s := strings.Split(r, "=")
+	if len(s) != 2 {
+		writer.WriteHeader(400)
+		return
+	}
+	s = strings.Split(s[1], "-")
+	if len(s) != 2 {
+		writer.WriteHeader(400)
+		return
+	}
+	start, err := strconv.ParseInt(s[0], 10, 64)
+	if err != nil {
+		writer.WriteHeader(400)
+		return
+	}
+	end := int64(BuildSize - 1)
+	if s[1] != "" {
+		end, err = strconv.ParseInt(s[1], 10, 64)
+		if err != nil {
+			writer.WriteHeader(400)
+			return
+		}
+	}
+	if start < 0 || end < 0 || start > end {
+		writer.WriteHeader(400)
+		return
+	}
+	if end >= BuildSize {
+		end = BuildSize - 1
+	}
+
+	if modifyEnd != nil {
+		end = modifyEnd(end)
+	}
+
+	// Open file before sending headers to ensure it exists
+	file, err := os.Open(BuildFile)
+	if err != nil {
+		writer.WriteHeader(500)
+		return
+	}
+	defer file.Close()
+	file.Seek(start, 0)
+
+	writer.Header().Set("Content-Length", fmt.Sprintf("%d", end-start+1))
+	writer.Header().Set("Content-Range", fmt.Sprintf("bytes %d-%d/%d", start, end, BuildSize))
+	writer.Header().Set("Accept-Ranges", "bytes")
+	writer.WriteHeader(206)
+	(writer.(http.Flusher)).Flush()
+
+	iocpN(file, end-start+1)
+}
+
 // slowCopyN copies n bytes from src to dst, speed limit is bytes per second
-func slowCopy(dst io.Writer, src io.Reader, delay int64) (written int64, err error) {
+func slowCopy(sl *shutdownListener, dst io.Writer, src io.Reader, delay int64) (written int64, err error) {
 	buf := make([]byte, 32*1024)
 	for {
+		if sl.isShutdown {
+			return 0, errors.New("server shutdown")
+		}
 		nr, er := src.Read(buf)
 		if nr > 0 {
 			nw, ew := dst.Write(buf[0:nr])
@@ -243,8 +813,8 @@ func slowCopy(dst io.Writer, src io.Reader, delay int64) (written int64, err err
 	return written, err
 }

-func slowCopyN(dst io.Writer, src io.Reader, n int64, delay int64) (written int64, err error) {
-	written, err = slowCopy(dst, io.LimitReader(src, n), delay)
+func slowCopyN(sl *shutdownListener, dst io.Writer, src io.Reader, n int64, delay int64) (written int64, err error) {
+	written, err = slowCopy(sl, dst, io.LimitReader(src, n), delay)
 	if written == n {
 		return n, nil
 	}
@@ -255,7 +825,15 @@ func slowCopyN(dst io.Writer, src io.Reader, n int64, delay int64) (written int6
 	return
 }

-func startTestServer(serverHandle func() http.Handler) net.Listener {
+// slowCopyAfterDelay sleeps once before performing a normal copy to simulate a single timeout.
+func slowCopyAfterDelay(sl *shutdownListener, dst io.Writer, src io.Reader, n int64, delay int64) (written int64, err error) {
+	if delay > 0 {
+		time.Sleep(time.Millisecond * time.Duration(delay))
+	}
+	return slowCopyN(sl, dst, src, n, 0)
+}
+
+func startTestServer(serverHandle func(sl *shutdownListener) http.Handler) net.Listener {
 	listener, err := net.Listen("tcp", "127.0.0.1:0")
 	if err != nil {
 		panic(err)
@@ -265,7 +843,7 @@ func startTestServer(serverHandle func() http.Handler) net.Listener {
 		panic(err)
 	}
 	defer file.Close()
-	// 随机生成一个文件
+	// Write random data
 	l := int64(8192)
 	buf := make([]byte, l)
 	size := int64(0)
@@ -282,22 +860,26 @@ func startTestServer(serverHandle func() http.Handler) net.Listener {
 		size += l
 	}
 	server := &http.Server{}
-	server.Handler = serverHandle()
-	go server.Serve(listener)
-
-	return &shutdownListener{
+	sl := &shutdownListener{
 		server:   server,
 		Listener: listener,
 	}
+	server.Handler = serverHandle(sl)
+	go server.Serve(listener)
+
+	return sl
 }

 type shutdownListener struct {
-	server *http.Server
+	server     *http.Server
+	isShutdown bool
 	net.Listener
 }

 func (c *shutdownListener) Close() error {
+	// Shutdown server first (waits for in-flight requests), then set isShutdown
 	closeErr := c.server.Shutdown(context.Background())
+	c.isShutdown = true
 	if err := ifExistAndRemove(BuildFile); err != nil {
 		fmt.Println(err)
 	}
@@ -330,10 +912,101 @@ func StartSocks5Server(usr, pwd string) net.Listener {
 		panic(err)
 	}

-	listener, err := net.Listen("tcp", "127.0.0.1:0") // 你可以根据需要更改监听地址
+	listener, err := net.Listen("tcp", "127.0.0.1:0")
 	if err != nil {
 		panic(err)
 	}
 	go server.Serve(listener)
 	return listener
 }
+
+// StartTestPatchURLServer creates a server with two endpoints:
+// - /bad-url: always returns 404 (simulates a broken download link)
+// - /good-url: returns the file successfully (simulates a working download link)
+// This is used to test the Patch functionality where a failed download URL can be
+// replaced with a working one.
+func StartTestPatchURLServer() net.Listener {
+	return startTestServer(func(sl *shutdownListener) http.Handler {
+		mux := http.NewServeMux()
+		// Bad URL - always fails with 404
+		mux.HandleFunc("/bad-url", func(writer http.ResponseWriter, request *http.Request) {
+			writer.WriteHeader(404)
+			writer.Write([]byte("Not Found"))
+		})
+		// Good URL - returns the file successfully with range support
+		mux.HandleFunc("/good-url", func(writer http.ResponseWriter, request *http.Request) {
+			rangeFileHandle(
+				writer,
+				request,
+				nil,
+				func(file *os.File, n int64) {
+					io.CopyN(writer, file, n)
+				},
+			)
+		})
+		return mux
+	})
+}
+
+// StartTestCookieExpiringServer creates a server that simulates cookie expiration during download.
+// - First request (Resolve): accepts "session=old_token" and succeeds
+// - Subsequent requests: "session=old_token" is expired (returns 401), only "session=new_token" works
+// This is used to test the Patch functionality where a cookie expires mid-download,
+// requiring the user to patch with a new cookie to resume.
+func StartTestCookieExpiringServer() net.Listener {
+	var requestCount atomic.Int32
+
+	return startTestServer(func(sl *shutdownListener) http.Handler {
+		mux := http.NewServeMux()
+		mux.HandleFunc("/"+BuildName, func(writer http.ResponseWriter, request *http.Request) {
+			reqNum := requestCount.Add(1)
+			cookie := request.Header.Get("Cookie")
+
+			// First request (Resolve): accept old_token
+			if reqNum == 1 {
+				if !strings.Contains(cookie, "session=old_token") {
+					writer.WriteHeader(401)
+					writer.Write([]byte("Unauthorized: Invalid cookie"))
+					return
+				}
+				// Return file info for resolve (with range support)
+				rangeFileHandle(
+					writer,
+					request,
+					nil,
+					func(file *os.File, n int64) {
+						io.CopyN(writer, file, n)
+					},
+				)
+				return
+			}
+
+			// Subsequent requests: old_token is expired, only new_token works
+			if strings.Contains(cookie, "session=new_token") {
+				// New token is valid - return the file with range support
+				rangeFileHandle(
+					writer,
+					request,
+					nil,
+					func(file *os.File, n int64) {
+						io.CopyN(writer, file, n)
+					},
+				)
+				return
+			}
+
+			// Old token or invalid token - return 401
+			writer.WriteHeader(401)
+			writer.Write([]byte("Unauthorized: Cookie expired"))
+		})
+		return mux
+	})
+}
+
+func AssertResourceEqual(want, got *base.Resource) bool {
+	// Ignore ctime
+	if got != nil && len(got.Files) > 0 {
+		got.Files[0].Ctime = nil
+	}
+	return reflect.DeepEqual(want, got)
+}
@@ -0,0 +1,36 @@
+//go:build darwin
+
+package goprovider
+
+var mainThreadTasks chan func()
+
+func RunMainThreadLoop(run func() int) int {
+	if mainThreadTasks != nil {
+		return run()
+	}
+
+	mainThreadTasks = make(chan func())
+	resultCh := make(chan int, 1)
+
+	go func() {
+		resultCh <- run()
+	}()
+
+	for {
+		select {
+		case task := <-mainThreadTasks:
+			task()
+		case code := <-resultCh:
+			mainThreadTasks = nil
+			return code
+		}
+	}
+}
+
+func postMainThreadTask(task func()) bool {
+	if mainThreadTasks == nil {
+		return false
+	}
+	mainThreadTasks <- task
+	return true
+}
@@ -0,0 +1,11 @@
+//go:build !darwin
+
+package goprovider
+
+func RunMainThreadLoop(run func() int) int {
+	return run()
+}
+
+func postMainThreadTask(func()) bool {
+	return false
+}
@@ -0,0 +1,612 @@
+//go:build cgo
+
+package goprovider
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/url"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	runtimepkg "runtime"
+
+	enginewebview "github.com/GopeedLab/gopeed/pkg/download/engine/webview"
+	webview "github.com/GopeedLab/webview_go"
+)
+
+type Provider struct{}
+
+func New() enginewebview.Provider {
+	return &Provider{}
+}
+
+func (p *Provider) IsAvailable() bool {
+	return webview.IsAvailable()
+}
+
+func (p *Provider) Open(opts enginewebview.OpenOptions) (enginewebview.Page, error) {
+	pw := newPageWrapper(opts)
+	if err := pw.start(); err != nil {
+		return nil, err
+	}
+	return pw, nil
+}
+
+type pageWrapper struct {
+	opts enginewebview.OpenOptions
+
+	callbackName string
+	readyID      string
+
+	view webview.WebView
+
+	mu      sync.Mutex
+	pending map[string]chan evalResult
+	url     string
+	closed  bool
+
+	ready chan error
+	done  chan struct{}
+	loads chan string
+}
+
+type evalMessage struct {
+	ID    string `json:"id"`
+	Ready bool   `json:"ready,omitempty"`
+	Load  bool   `json:"load,omitempty"`
+	URL   string `json:"url,omitempty"`
+	OK    bool   `json:"ok,omitempty"`
+	Value any    `json:"value,omitempty"`
+	Error string `json:"error,omitempty"`
+}
+
+type evalResult struct {
+	value any
+	err   error
+}
+
+type nativeCookieJSON struct {
+	Name     string `json:"name"`
+	Value    string `json:"value"`
+	Domain   string `json:"domain"`
+	Path     string `json:"path"`
+	Expires  string `json:"expires"`
+	Secure   bool   `json:"secure"`
+	HTTPOnly bool   `json:"httpOnly"`
+}
+
+var providerSeq atomic.Uint64
+
+// Keep native page creation aligned with the provider availability budget used
+// by the integration contract. Cold WebView2 startup can exceed ten seconds.
+const startupTimeout = time.Minute
+
+func newPageWrapper(opts enginewebview.OpenOptions) *pageWrapper {
+	seq := providerSeq.Add(1)
+	return &pageWrapper{
+		opts:         opts,
+		callbackName: fmt.Sprintf("__gopeedWebViewCallback_%d", seq),
+		readyID:      fmt.Sprintf("__ready__%d", seq),
+		pending:      make(map[string]chan evalResult),
+		ready:        make(chan error, 1),
+		done:         make(chan struct{}),
+		loads:        make(chan string, 8),
+	}
+}
+
+func (p *pageWrapper) start() error {
+	startedAt := time.Now()
+	run := func() {
+		runtimepkg.LockOSThread()
+		defer runtimepkg.UnlockOSThread()
+
+		var w webview.WebView
+		if p.opts.Headless {
+			w = webview.NewHeadless(p.opts.Debug)
+		} else {
+			w = webview.New(p.opts.Debug)
+		}
+		p.view = w
+		w.SetTitle(firstNonEmpty(p.opts.Title, "Gopeed WebView"))
+		w.SetSize(defaultWindowDimension(p.opts.Width, 1280), defaultWindowDimension(p.opts.Height, 800), webview.HintNone)
+
+		if p.opts.UserAgent != "" {
+			type userAgentSetter interface {
+				SetUserAgent(userAgent string)
+			}
+			if setter, ok := w.(userAgentSetter); ok {
+				setter.SetUserAgent(p.opts.UserAgent)
+			}
+		}
+		w.Init(buildLoadNotifyScript(p.callbackName))
+
+		if err := w.Bind(p.callbackName, func(payload string) error {
+			return p.handleCallback(payload)
+		}); err != nil {
+			p.ready <- err
+			return
+		}
+
+		applyWindowOptions(w, p.opts)
+		w.SetHtml(buildBootstrapHTML(p.callbackName, p.readyID))
+		w.Run()
+		w.Destroy()
+		close(p.done)
+	}
+
+	if !postMainThreadTask(run) {
+		go run()
+	}
+
+	select {
+	case err := <-p.ready:
+		p.tracef("open %dms", time.Since(startedAt).Milliseconds())
+		return err
+	case <-time.After(startupTimeout):
+		p.tracef("open timeout %dms", time.Since(startedAt).Milliseconds())
+		return fmt.Errorf("webview startup timeout")
+	}
+}
+
+func (p *pageWrapper) AddInitScript(script string) error {
+	return p.dispatch(func(w webview.WebView) error {
+		w.Init(script)
+		return nil
+	})
+}
+
+func (p *pageWrapper) Goto(url string, opts enginewebview.GotoOptions) error {
+	startedAt := time.Now()
+	p.drainLoads()
+	if err := p.dispatch(func(w webview.WebView) error {
+		p.mu.Lock()
+		p.url = url
+		p.mu.Unlock()
+		w.Navigate(url)
+		return nil
+	}); err != nil {
+		return err
+	}
+	timeout := 30 * time.Second
+	if opts.TimeoutMS > 0 {
+		timeout = time.Duration(opts.TimeoutMS) * time.Millisecond
+	}
+	waitUntil := opts.WaitUntil
+	if waitUntil == "" {
+		waitUntil = "load"
+	}
+	err := p.waitForNavigation(url, timeout, waitUntil)
+	if err != nil {
+		p.tracef("goto failed %dms url=%s err=%v", time.Since(startedAt).Milliseconds(), url, err)
+		return err
+	}
+	p.tracef("goto %dms url=%s", time.Since(startedAt).Milliseconds(), url)
+	return nil
+}
+
+func (p *pageWrapper) Execute(expression string, args ...any) (any, error) {
+	startedAt := time.Now()
+	if args == nil {
+		args = []any{}
+	}
+	argsJSON, err := json.Marshal(args)
+	if err != nil {
+		return nil, err
+	}
+	reqID := fmt.Sprintf("req-%d", providerSeq.Add(1))
+	ch := make(chan evalResult, 1)
+
+	p.mu.Lock()
+	if p.closed {
+		p.mu.Unlock()
+		return nil, fmt.Errorf("webview page is closed")
+	}
+	p.pending[reqID] = ch
+	p.mu.Unlock()
+
+	script := buildExecuteScript(p.callbackName, reqID, expression, string(argsJSON))
+	if err := p.dispatch(func(w webview.WebView) error {
+		w.Eval(script)
+		return nil
+	}); err != nil {
+		p.mu.Lock()
+		delete(p.pending, reqID)
+		p.mu.Unlock()
+		return nil, err
+	}
+
+	result := <-ch
+	if result.err != nil {
+		p.tracef("execute failed %dms err=%v", time.Since(startedAt).Milliseconds(), result.err)
+		return result.value, result.err
+	}
+	p.tracef("execute %dms", time.Since(startedAt).Milliseconds())
+	return result.value, nil
+}
+
+func (p *pageWrapper) GetCookies() ([]enginewebview.Cookie, error) {
+	cookies, err := p.nativeCookies()
+	if err != nil {
+		return nil, err
+	}
+	result := make([]enginewebview.Cookie, 0, len(cookies))
+	for _, cookie := range cookies {
+		item := enginewebview.Cookie{
+			Name:     cookie.Name,
+			Value:    cookie.Value,
+			Domain:   cookie.Domain,
+			Path:     cookie.Path,
+			Secure:   cookie.Secure,
+			HTTPOnly: cookie.HTTPOnly,
+		}
+		if cookie.Expires != "" {
+			if parsed, err := time.Parse(time.RFC3339Nano, cookie.Expires); err == nil {
+				item.Expires = parsed
+			}
+		}
+		result = append(result, item)
+	}
+	return result, nil
+}
+
+func (p *pageWrapper) SetCookie(cookie enginewebview.Cookie) error {
+	type cookieSetter interface {
+		SetCookie(cookie webview.Cookie) error
+	}
+	return p.dispatch(func(w webview.WebView) error {
+		setter, ok := w.(cookieSetter)
+		if !ok {
+			return fmt.Errorf("native cookie access is unavailable")
+		}
+		return setter.SetCookie(webview.Cookie{
+			Name:     cookie.Name,
+			Value:    cookie.Value,
+			Domain:   cookie.Domain,
+			Path:     cookie.Path,
+			Expires:  cookie.Expires,
+			Secure:   cookie.Secure,
+			HTTPOnly: cookie.HTTPOnly,
+		})
+	})
+}
+
+func (p *pageWrapper) DeleteCookie(cookie enginewebview.Cookie) error {
+	type cookieDeleter interface {
+		DeleteCookie(name string, domain string, path string) error
+	}
+	return p.dispatch(func(w webview.WebView) error {
+		deleter, ok := w.(cookieDeleter)
+		if !ok {
+			return fmt.Errorf("native cookie access is unavailable")
+		}
+		return deleter.DeleteCookie(cookie.Name, cookie.Domain, cookie.Path)
+	})
+}
+
+func (p *pageWrapper) ClearCookies() error {
+	type cookieClearer interface {
+		ClearCookies() error
+	}
+	return p.dispatch(func(w webview.WebView) error {
+		clearer, ok := w.(cookieClearer)
+		if !ok {
+			return fmt.Errorf("native cookie access is unavailable")
+		}
+		return clearer.ClearCookies()
+	})
+}
+
+func (p *pageWrapper) Close() error {
+	p.mu.Lock()
+	if p.closed {
+		p.mu.Unlock()
+		return nil
+	}
+	p.closed = true
+	w := p.view
+	wait := p.done
+	p.mu.Unlock()
+
+	if w != nil {
+		// PostQuitMessage (used by the Windows WebView2 terminate_impl)
+		// only takes effect on the thread that owns the message loop.
+		// Dispatch the termination to the webview's UI thread so that
+		// the quit message lands on the correct queue.
+		terminateDone := make(chan struct{})
+		w.Dispatch(func() {
+			w.Terminate()
+			close(terminateDone)
+		})
+		<-terminateDone
+	}
+	<-wait
+	return nil
+}
+
+func (p *pageWrapper) tracef(format string, args ...any) {
+	if !strings.Contains(p.opts.Title, "youtube-sabr") {
+		return
+	}
+	fmt.Printf("goprovider "+format+"\n", args...)
+}
+
+func (p *pageWrapper) waitForNavigation(targetURL string, timeout time.Duration, waitUntil string) error {
+	deadline := time.Now().Add(timeout)
+	ticker := time.NewTicker(100 * time.Millisecond)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-p.loads:
+			if waitUntil == "load" {
+				return nil
+			}
+		case <-ticker.C:
+			state, err := p.navigationState()
+			if err == nil && state.ready(targetURL, waitUntil) {
+				return nil
+			}
+			if time.Now().After(deadline) {
+				return fmt.Errorf("webview navigation timeout")
+			}
+		}
+	}
+}
+
+type navigationState struct {
+	URL        string `json:"url"`
+	ReadyState string `json:"readyState"`
+}
+
+func (s navigationState) ready(targetURL string, waitUntil string) bool {
+	if s.URL == "" || s.URL == "about:blank" {
+		return false
+	}
+	switch waitUntil {
+	case "domcontentloaded":
+		if s.ReadyState == "loading" || s.ReadyState == "" {
+			return false
+		}
+	default:
+		if s.ReadyState != "complete" {
+			return false
+		}
+	}
+	if targetURL == "" {
+		return true
+	}
+	if s.URL == targetURL {
+		return true
+	}
+	target, err := parseURL(targetURL)
+	if err != nil {
+		return true
+	}
+	current, err := parseURL(s.URL)
+	if err != nil {
+		return true
+	}
+	if current.Scheme == target.Scheme && current.Host == target.Host && current.Path == target.Path {
+		return true
+	}
+	return false
+}
+
+func parseURL(raw string) (*url.URL, error) {
+	return url.Parse(raw)
+}
+
+func (p *pageWrapper) navigationState() (navigationState, error) {
+	value, err := p.Execute(`() => ({
+		url: String(location.href || ""),
+		readyState: document.readyState || "",
+	})`)
+	if err != nil {
+		return navigationState{}, err
+	}
+	stateMap, ok := value.(map[string]any)
+	if !ok {
+		return navigationState{}, fmt.Errorf("invalid navigation state")
+	}
+	state := navigationState{}
+	if urlValue, ok := stateMap["url"].(string); ok {
+		state.URL = urlValue
+	}
+	if readyValue, ok := stateMap["readyState"].(string); ok {
+		state.ReadyState = readyValue
+	}
+	return state, nil
+}
+
+func (p *pageWrapper) dispatch(fn func(w webview.WebView) error) error {
+	p.mu.Lock()
+	if p.closed {
+		p.mu.Unlock()
+		return fmt.Errorf("webview page is closed")
+	}
+	w := p.view
+	p.mu.Unlock()
+	if w == nil {
+		return fmt.Errorf("webview is not initialized")
+	}
+
+	done := make(chan error, 1)
+	w.Dispatch(func() {
+		done <- fn(w)
+	})
+	return <-done
+}
+
+func (p *pageWrapper) nativeCookies() ([]nativeCookieJSON, error) {
+	type cookieGetter interface {
+		GetCookies(url string) ([]webview.Cookie, error)
+	}
+
+	var cookies []webview.Cookie
+	err := p.dispatch(func(w webview.WebView) error {
+		getter, ok := w.(cookieGetter)
+		if !ok {
+			return fmt.Errorf("native cookie access is unavailable")
+		}
+		p.mu.Lock()
+		url := p.url
+		p.mu.Unlock()
+		if url == "" {
+			url = "about:blank"
+		}
+		var err error
+		cookies, err = getter.GetCookies(url)
+		return err
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	result := make([]nativeCookieJSON, 0, len(cookies))
+	for _, cookie := range cookies {
+		item := nativeCookieJSON{
+			Name:     cookie.Name,
+			Value:    cookie.Value,
+			Domain:   cookie.Domain,
+			Path:     cookie.Path,
+			Secure:   cookie.Secure,
+			HTTPOnly: cookie.HTTPOnly,
+		}
+		if !cookie.Expires.IsZero() {
+			item.Expires = cookie.Expires.UTC().Format(time.RFC3339Nano)
+		}
+		result = append(result, item)
+	}
+	return result, nil
+}
+
+func (p *pageWrapper) handleCallback(payload string) error {
+	var msg evalMessage
+	if err := json.Unmarshal([]byte(payload), &msg); err != nil {
+		return err
+	}
+	if msg.Ready && msg.ID == p.readyID {
+		select {
+		case p.ready <- nil:
+		default:
+		}
+		return nil
+	}
+	if msg.Load {
+		select {
+		case p.loads <- msg.URL:
+		default:
+		}
+		return nil
+	}
+
+	p.mu.Lock()
+	ch := p.pending[msg.ID]
+	delete(p.pending, msg.ID)
+	p.mu.Unlock()
+	if ch == nil {
+		return nil
+	}
+
+	if !msg.OK {
+		ch <- evalResult{err: errors.New(strings.TrimSpace(msg.Error))}
+		return nil
+	}
+	ch <- evalResult{value: msg.Value}
+	return nil
+}
+
+func (p *pageWrapper) drainLoads() {
+	for {
+		select {
+		case <-p.loads:
+		default:
+			return
+		}
+	}
+}
+
+func buildBootstrapHTML(callbackName string, readyID string) string {
+	return fmt.Sprintf(`<!doctype html>
+<html>
+<head><meta charset="utf-8"></head>
+<body>
+<script>
+window.addEventListener("load", () => {
+  const callback = globalThis[%q];
+  if (typeof callback === "function") {
+    callback(JSON.stringify({ id: %q, ready: true }));
+  }
+}, { once: true });
+</script>
+</body>
+</html>`, callbackName, readyID)
+}
+
+func buildExecuteScript(callbackName string, reqID string, expression string, argsJSON string) string {
+	callbackJSON, _ := json.Marshal(callbackName)
+	reqJSON, _ := json.Marshal(reqID)
+	exprJSON, _ := json.Marshal(expression)
+	argsLiteral := argsJSON
+	if argsLiteral == "" || argsLiteral == "null" {
+		argsLiteral = "[]"
+	}
+	return fmt.Sprintf(`(() => {
+  const __cb = globalThis[%s];
+  const __id = %s;
+  const __expression = %s;
+  const __args = %s;
+  Promise.resolve()
+    .then(async () => {
+      const __target = (0, eval)(__expression);
+      const __value = await (typeof __target === "function" ? __target(...__args) : __target);
+      return { id: __id, ok: true, value: __value ?? null };
+    })
+    .catch((error) => ({
+      id: __id,
+      ok: false,
+      error: [
+        error && error.name ? error.name : "Error",
+        error && error.message ? error.message : String(error),
+        error && error.stack ? error.stack : "",
+      ].filter(Boolean).join(": ").replace(": @", "\n@"),
+    }))
+    .then((message) => __cb(JSON.stringify(message)));
+})();`, string(callbackJSON), string(reqJSON), string(exprJSON), argsLiteral)
+}
+
+func buildLoadNotifyScript(callbackName string) string {
+	callbackJSON, _ := json.Marshal(callbackName)
+	return fmt.Sprintf(`(() => {
+  window.addEventListener("load", () => {
+    const __cb = globalThis[%s];
+    if (typeof __cb !== "function") {
+      return;
+    }
+    __cb(JSON.stringify({
+      load: true,
+      url: String(location.href || ""),
+    }));
+  }, { once: true });
+})();`, string(callbackJSON))
+}
+
+func defaultWindowDimension(value int, fallback int) int {
+	if value > 0 {
+		return value
+	}
+	return fallback
+}
+
+func firstNonEmpty(values ...string) string {
+	for _, value := range values {
+		if strings.TrimSpace(value) != "" {
+			return value
+		}
+	}
+	return ""
+}
@@ -0,0 +1,15 @@
+//go:build cgo && webview && !darwin
+
+package goprovider
+
+import (
+	"testing"
+
+	"github.com/GopeedLab/gopeed/internal/webview/integrationtest"
+)
+
+func TestProviderContract(t *testing.T) {
+	integrationtest.RunProviderContract(t, New(), integrationtest.ContractOptions{
+		CookieDomainMode: integrationtest.CookieDomainModeRequired,
+	})
+}
@@ -0,0 +1,9 @@
+//go:build !cgo
+
+package goprovider
+
+import enginewebview "github.com/GopeedLab/gopeed/pkg/download/engine/webview"
+
+func New() enginewebview.Provider {
+	return enginewebview.NewUnavailableProvider()
+}
@@ -0,0 +1,38 @@
+//go:build cgo && darwin
+
+package goprovider
+
+/*
+#cgo darwin CFLAGS: -x objective-c
+#cgo darwin LDFLAGS: -framework Cocoa
+
+#include <Cocoa/Cocoa.h>
+
+static void gopeedApplyHeadlessWindowOptions(void *windowPtr, int headless) {
+  if (windowPtr == NULL) {
+    return;
+  }
+
+  NSWindow *window = (__bridge NSWindow *)windowPtr;
+  if (headless) {
+    [window orderOut:nil];
+  }
+}
+*/
+import "C"
+
+import (
+	enginewebview "github.com/GopeedLab/gopeed/pkg/download/engine/webview"
+	webview "github.com/GopeedLab/webview_go"
+)
+
+func applyWindowOptions(w webview.WebView, opts enginewebview.OpenOptions) {
+	C.gopeedApplyHeadlessWindowOptions(w.Window(), C.int(boolToInt(opts.Headless)))
+}
+
+func boolToInt(value bool) int {
+	if value {
+		return 1
+	}
+	return 0
+}
@@ -0,0 +1,10 @@
+//go:build cgo && !darwin
+
+package goprovider
+
+import (
+	enginewebview "github.com/GopeedLab/gopeed/pkg/download/engine/webview"
+	webview "github.com/GopeedLab/webview_go"
+)
+
+func applyWindowOptions(_ webview.WebView, _ enginewebview.OpenOptions) {}
@@ -0,0 +1,382 @@
+package integrationtest
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strings"
+	"testing"
+	"time"
+
+	enginewebview "github.com/GopeedLab/gopeed/pkg/download/engine/webview"
+)
+
+const TestUserAgent = "GopeedWebViewIntegration/1.0"
+
+// Providers may need to initialize an external host or a native browser runtime
+// before the first page can be created.
+const defaultAvailabilityTimeout = time.Minute
+
+type ContractOptions struct {
+	AvailabilityTimeout time.Duration
+	CookieDomainMode    CookieDomainMode
+	CookieTestURL       string
+}
+
+type CookieDomainMode int
+
+const (
+	CookieDomainModeRequired CookieDomainMode = iota
+	CookieDomainModeOmit
+)
+
+func RunProviderContract(t *testing.T, provider enginewebview.Provider, opts ContractOptions) {
+	t.Helper()
+
+	timeout := opts.AvailabilityTimeout
+	if timeout <= 0 {
+		timeout = defaultAvailabilityTimeout
+	}
+	waitForProviderAvailable(t, provider, timeout)
+
+	page, server, testURL := openTestPage(t, provider, enginewebview.OpenOptions{
+		Headless:  true,
+		Title:     "Gopeed WebView Integration",
+		Width:     640,
+		Height:    480,
+		UserAgent: TestUserAgent,
+	})
+
+	if err := page.Goto(testURL, map[string]any{"timeoutMs": 10000}); err != nil {
+		t.Fatalf("goto failed: %v", err)
+	}
+
+	ua, err := page.Execute(`() => navigator.userAgent`)
+	if err != nil {
+		t.Fatalf("navigator.userAgent execute failed: %v", err)
+	}
+	if ua != TestUserAgent {
+		t.Fatalf("unexpected user agent: got %v want %q", ua, TestUserAgent)
+	}
+
+	if err := page.Focus("#name"); err != nil {
+		t.Fatalf("focus failed: %v", err)
+	}
+	activeElement, err := page.Execute(`() => document.activeElement && document.activeElement.id`)
+	if err != nil {
+		t.Fatalf("activeElement execute failed: %v", err)
+	}
+	if activeElement != "name" {
+		t.Fatalf("expected active element to be #name, got %v", activeElement)
+	}
+
+	if err := page.Type("#name", "Gopeed", map[string]any{"delay": 5}); err != nil {
+		t.Fatalf("type failed: %v", err)
+	}
+	typeState, err := page.Execute(`() => ({
+		value: document.querySelector('#name').value,
+		mirror: document.querySelector('#name-value').textContent,
+		inputCount: window.__inputEvents.length
+	})`)
+	if err != nil {
+		t.Fatalf("type state execute failed: %v", err)
+	}
+	stateMap, ok := typeState.(map[string]any)
+	if !ok {
+		t.Fatalf("unexpected type state payload: %T", typeState)
+	}
+	if stateMap["value"] != "Gopeed" || stateMap["mirror"] != "Gopeed" {
+		t.Fatalf("unexpected type state: %#v", stateMap)
+	}
+	if stateMap["inputCount"] != float64(len("Gopeed")) {
+		t.Fatalf("unexpected input event count: %#v", stateMap["inputCount"])
+	}
+
+	if err := page.Click("#clicker"); err != nil {
+		t.Fatalf("click failed: %v", err)
+	}
+	clickCount, err := page.Execute(`() => document.querySelector('#click-count').textContent`)
+	if err != nil {
+		t.Fatalf("click count execute failed: %v", err)
+	}
+	if clickCount != "1" {
+		t.Fatalf("expected click count to be 1, got %v", clickCount)
+	}
+
+	found, err := page.WaitForSelector("#delayed", map[string]any{
+		"timeoutMs":      5000,
+		"pollIntervalMs": 25,
+		"visible":        true,
+	})
+	if err != nil {
+		t.Fatalf("waitForSelector failed: %v", err)
+	}
+	if !found {
+		t.Fatal("expected delayed selector to appear")
+	}
+
+	value, err := page.WaitForFunction(`() => window.__readyValue`, map[string]any{
+		"timeoutMs":      5000,
+		"pollIntervalMs": 25,
+	})
+	if err != nil {
+		t.Fatalf("waitForFunction failed: %v", err)
+	}
+	readyValue, ok := value.(map[string]any)
+	if !ok {
+		t.Fatalf("unexpected waitForFunction value: %T", value)
+	}
+	if readyValue["status"] != "ready" {
+		t.Fatalf("unexpected waitForFunction payload: %#v", readyValue)
+	}
+
+	found, err = page.WaitForSelector("#missing", map[string]any{
+		"timeoutMs":      200,
+		"pollIntervalMs": 25,
+	})
+	if err != nil {
+		t.Fatalf("waitForSelector timeout case failed: %v", err)
+	}
+	if found {
+		t.Fatal("expected missing selector wait to time out")
+	}
+
+	cookieTestURL := opts.CookieTestURL
+	if cookieTestURL == "" {
+		cookieTestURL = testURL
+	}
+	runCookieLifecycleAssertions(t, page, server, cookieTestURL, opts.CookieDomainMode)
+}
+
+func waitForProviderAvailable(t *testing.T, provider enginewebview.Provider, timeout time.Duration) {
+	t.Helper()
+	deadline := time.Now().Add(timeout)
+	for time.Now().Before(deadline) {
+		if provider != nil && provider.IsAvailable() {
+			return
+		}
+		time.Sleep(200 * time.Millisecond)
+	}
+	t.Fatalf("provider did not become available within %s", timeout)
+}
+
+func openTestPage(t *testing.T, provider enginewebview.Provider, opts enginewebview.OpenOptions) (*enginewebview.PageHandle, *httptest.Server, string) {
+	t.Helper()
+
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Content-Type", "text/html; charset=utf-8")
+		switch r.URL.Path {
+		case "/next":
+			fmt.Fprint(w, `<!DOCTYPE html>
+<html>
+  <head><title>Next Page</title></head>
+  <body>
+    <h1 id="next-page">Navigation complete</h1>
+  </body>
+</html>`)
+		default:
+			fmt.Fprint(w, `<!DOCTYPE html>
+<html>
+  <head><title>Test Page</title></head>
+  <body>
+    <input id="name" type="text" />
+    <div id="name-value"></div>
+    <button id="clicker" type="button">Click me</button>
+    <div id="click-count">0</div>
+    <button id="nav-btn" type="button">Navigate</button>
+    <script>
+      window.__inputEvents = [];
+      window.__readyValue = null;
+      const nameInput = document.getElementById('name');
+      const nameValue = document.getElementById('name-value');
+      nameInput.addEventListener('input', () => {
+        nameValue.textContent = nameInput.value;
+        window.__inputEvents.push(nameInput.value);
+      });
+      document.getElementById('clicker').addEventListener('click', () => {
+        const counter = document.getElementById('click-count');
+        counter.textContent = String(Number(counter.textContent || '0') + 1);
+      });
+      document.getElementById('nav-btn').addEventListener('click', () => {
+        setTimeout(() => {
+          window.location.href = '/next';
+        }, 50);
+      });
+      setTimeout(() => {
+        const marker = document.createElement('div');
+        marker.id = 'delayed';
+        marker.textContent = 'Loaded later';
+        document.body.appendChild(marker);
+      }, 150);
+      setTimeout(() => {
+        window.__readyValue = { status: 'ready', source: 'timer' };
+      }, 200);
+    </script>
+  </body>
+</html>`)
+		}
+	}))
+	t.Cleanup(server.Close)
+
+	runtime := enginewebview.NewRuntime(provider, true)
+	page, err := runtime.Open(map[string]any{
+		"headless":  opts.Headless,
+		"debug":     opts.Debug,
+		"title":     opts.Title,
+		"width":     opts.Width,
+		"height":    opts.Height,
+		"userAgent": opts.UserAgent,
+	})
+	if err != nil {
+		t.Fatalf("failed to open webview: %v", err)
+	}
+	t.Cleanup(func() {
+		_ = runtime.Close()
+	})
+
+	return page, server, server.URL
+}
+
+func runCookieLifecycleAssertions(t *testing.T, page *enginewebview.PageHandle, _ *httptest.Server, testURL string, domainMode CookieDomainMode) {
+	t.Helper()
+
+	parsedURL, err := url.Parse(testURL)
+	if err != nil {
+		t.Fatalf("parse cookie test url failed: %v", err)
+	}
+	cookieDomain := parsedURL.Hostname()
+
+	if err := page.ClearCookies(); err != nil {
+		t.Fatalf("clearCookies before cookie assertions failed: %v", err)
+	}
+
+	visibleCookie := map[string]any{
+		"name":  "visible",
+		"value": "1",
+		"path":  "/",
+	}
+	secretCookie := map[string]any{
+		"name":     "secret",
+		"value":    "2",
+		"path":     "/",
+		"httpOnly": true,
+		"expires":  time.Now().Add(time.Hour).UTC().Format(time.RFC3339Nano),
+	}
+	deleteCookie := map[string]any{
+		"name": "visible",
+		"path": "/",
+	}
+	if domainMode == CookieDomainModeRequired {
+		visibleCookie["domain"] = cookieDomain
+		secretCookie["domain"] = cookieDomain
+		deleteCookie["domain"] = cookieDomain
+	}
+
+	if err := page.SetCookie(visibleCookie); err != nil {
+		t.Fatalf("set visible cookie failed: %v", err)
+	}
+	if err := page.SetCookie(secretCookie); err != nil {
+		t.Fatalf("set secret cookie failed: %v", err)
+	}
+
+	if err := page.Goto(testURL, map[string]any{"timeoutMs": 10000}); err != nil {
+		t.Fatalf("goto after setCookie failed: %v", err)
+	}
+
+	documentCookie, err := page.Execute(`() => document.cookie`)
+	if err != nil {
+		t.Fatalf("document.cookie execute failed: %v", err)
+	}
+	documentCookieText, ok := documentCookie.(string)
+	if !ok {
+		t.Fatalf("unexpected document.cookie payload: %T", documentCookie)
+	}
+	if !strings.Contains(documentCookieText, "visible=1") {
+		t.Fatalf("expected visible cookie in document.cookie, got %q", documentCookieText)
+	}
+	if strings.Contains(documentCookieText, "secret=2") {
+		t.Fatalf("expected httpOnly cookie to be hidden from document.cookie, got %q", documentCookieText)
+	}
+
+	cookies, err := page.GetCookies()
+	if err != nil {
+		t.Fatalf("getCookies failed: %v", err)
+	}
+	if len(cookies) < 2 {
+		t.Fatalf("expected at least 2 cookies, got %#v", cookies)
+	}
+	if !hasCookie(cookies, "visible", "1") {
+		t.Fatalf("expected visible cookie in native cookie store, got %#v", cookies)
+	}
+	if !hasCookie(cookies, "secret", "2") {
+		t.Fatalf("expected secret cookie in native cookie store, got %#v", cookies)
+	}
+
+	if err := page.DeleteCookie(deleteCookie); err != nil {
+		t.Fatalf("deleteCookie failed: %v", err)
+	}
+	if err := page.Goto(testURL, map[string]any{"timeoutMs": 10000}); err != nil {
+		t.Fatalf("goto after deleteCookie failed: %v", err)
+	}
+
+	documentCookie, err = page.Execute(`() => document.cookie`)
+	if err != nil {
+		t.Fatalf("document.cookie execute after delete failed: %v", err)
+	}
+	documentCookieText, ok = documentCookie.(string)
+	if !ok {
+		t.Fatalf("unexpected document.cookie payload after delete: %T", documentCookie)
+	}
+	if strings.Contains(documentCookieText, "visible=1") {
+		t.Fatalf("expected visible cookie to be deleted, got %q", documentCookieText)
+	}
+	if strings.Contains(documentCookieText, "secret=2") {
+		t.Fatalf("expected httpOnly cookie to remain hidden after delete, got %q", documentCookieText)
+	}
+
+	cookies, err = page.GetCookies()
+	if err != nil {
+		t.Fatalf("getCookies after delete failed: %v", err)
+	}
+	if hasCookie(cookies, "visible", "1") {
+		t.Fatalf("expected visible cookie to be removed from native store, got %#v", cookies)
+	}
+	if !hasCookie(cookies, "secret", "2") {
+		t.Fatalf("expected secret cookie to remain in native store after delete, got %#v", cookies)
+	}
+
+	if err := page.ClearCookies(); err != nil {
+		t.Fatalf("clearCookies failed: %v", err)
+	}
+	if err := page.Goto(testURL, map[string]any{"timeoutMs": 10000}); err != nil {
+		t.Fatalf("goto after clearCookies failed: %v", err)
+	}
+	documentCookie, err = page.Execute(`() => document.cookie`)
+	if err != nil {
+		t.Fatalf("document.cookie execute after clear failed: %v", err)
+	}
+	documentCookieText, ok = documentCookie.(string)
+	if !ok {
+		t.Fatalf("unexpected document.cookie payload after clear: %T", documentCookie)
+	}
+	if documentCookieText != "" {
+		t.Fatalf("expected document.cookie to be empty after clear, got %q", documentCookieText)
+	}
+	cookies, err = page.GetCookies()
+	if err != nil {
+		t.Fatalf("getCookies after clear failed: %v", err)
+	}
+	if len(cookies) != 0 {
+		t.Fatalf("expected cookie store to be empty after clear, got %#v", cookies)
+	}
+}
+
+func hasCookie(cookies []enginewebview.Cookie, name string, value string) bool {
+	for _, cookie := range cookies {
+		if cookie.Name == name && cookie.Value == value {
+			return true
+		}
+	}
+	return false
+}
@@ -0,0 +1,488 @@
+# rpcprovider
+
+`rpcprovider` is the RPC-backed implementation of Gopeed's `webview.Provider` interface.
+
+It is intended for environments where WebView capability is owned by another process, most notably mobile hosts. This package does not implement a WebView itself. Instead, it translates the `pkg/download/engine/webview` page API into single-request `POST + JSON` calls sent to a local host-side RPC service.
+
+## When to use it
+
+Use `rpcprovider` for entrypoints such as `bind/mobile`, where the Go process cannot directly own a native WebView.
+
+Do not use it for desktop or `cmd/web` local WebView integration. Those entrypoints should use `internal/webview/goprovider` instead.
+
+## Configuration
+
+The provider is configured through `pkg/download/engine/webview.RPCConfig`:
+
+```go
+type RPCConfig struct {
+	Network string `json:"network"`
+	Address string `json:"address"`
+	Token   string `json:"token,omitempty"`
+}
+```
+
+Notes:
+
+- `Network` currently supports `tcp` and `unix`.
+- `Address` examples:
+  - `127.0.0.1:38765`
+  - `/path/to/webview.sock`
+- `Token` is optional. When set, the client sends `Authorization: Bearer <token>`.
+
+Example:
+
+```go
+provider := rpcprovider.New(webview.RPCConfig{
+	Network: "tcp",
+	Address: "127.0.0.1:38765",
+	Token:   "secret-token",
+})
+```
+
+## Transport
+
+- Endpoint: `POST /webview`
+- Content type: `application/json`
+- One request, one response
+- No `id` field yet
+- The envelope is intentionally close to JSON-RPC so it can evolve later without renaming the methods or reshaping the payloads
+
+Request example:
+
+```json
+{
+  "method": "page.execute",
+  "params": {
+    "pageId": "page-1",
+    "expression": "document.title",
+    "args": []
+  }
+}
+```
+
+Successful response:
+
+```json
+{
+  "result": {
+    "title": "Example"
+  },
+  "error": null
+}
+```
+
+Failure response:
+
+```json
+{
+  "result": null,
+  "error": {
+    "code": "PAGE_NOT_FOUND",
+    "message": "page not found"
+  }
+}
+```
+
+## Supported methods
+
+- `webview.isAvailable`
+- `page.open`
+- `page.addInitScript`
+- `page.goto`
+- `page.execute`
+- `page.getCookies`
+- `page.setCookie`
+- `page.deleteCookie`
+- `page.clearCookies`
+- `page.close`
+
+The canonical wire models for these methods are defined in:
+
+- [pkg/download/engine/webview/rpc.go](../../../pkg/download/engine/webview/rpc.go)
+- [pkg/download/engine/webview/runtime.go](../../../pkg/download/engine/webview/runtime.go)
+
+The README is only a guide. The Go source above is the authoritative protocol reference.
+
+## Method reference
+
+Each method below uses the common envelope:
+
+```json
+{
+  "method": "<method-name>",
+  "params": { ... }
+}
+```
+
+and returns:
+
+```json
+{
+  "result": ...,
+  "error": null
+}
+```
+
+or:
+
+```json
+{
+  "result": null,
+  "error": {
+    "code": "<ERROR_CODE>",
+    "message": "<message>"
+  }
+}
+```
+
+### `webview.isAvailable`
+
+Request:
+
+```json
+{
+  "method": "webview.isAvailable",
+  "params": {}
+}
+```
+
+Success:
+
+```json
+{
+  "result": {
+    "available": true
+  },
+  "error": null
+}
+```
+
+### `page.open`
+
+Request:
+
+```json
+{
+  "method": "page.open",
+  "params": {
+    "headless": true,
+    "debug": false,
+    "title": "Gopeed WebView",
+    "width": 1280,
+    "height": 720,
+    "userAgent": "Mozilla/5.0 ..."
+  }
+}
+```
+
+Success:
+
+```json
+{
+  "result": {
+    "pageId": "page-1"
+  },
+  "error": null
+}
+```
+
+### `page.addInitScript`
+
+Request:
+
+```json
+{
+  "method": "page.addInitScript",
+  "params": {
+    "pageId": "page-1",
+    "script": "window.__READY__ = true;"
+  }
+}
+```
+
+Success:
+
+```json
+{
+  "result": {},
+  "error": null
+}
+```
+
+### `page.goto`
+
+Request:
+
+```json
+{
+  "method": "page.goto",
+  "params": {
+    "pageId": "page-1",
+    "url": "https://example.com",
+    "timeoutMs": 15000,
+    "waitUntil": "domcontentloaded"
+  }
+}
+```
+
+Success:
+
+```json
+{
+  "result": {},
+  "error": null
+}
+```
+
+`waitUntil` currently supports `load` and `domcontentloaded`. The default is `load`.
+
+### `page.execute`
+
+Request:
+
+```json
+{
+  "method": "page.execute",
+  "params": {
+    "pageId": "page-1",
+    "expression": "document.title",
+    "args": []
+  }
+}
+```
+
+Success:
+
+```json
+{
+  "result": "Example Domain",
+  "error": null
+}
+```
+
+### `page.getCookies`
+
+Request:
+
+```json
+{
+  "method": "page.getCookies",
+  "params": {
+    "pageId": "page-1"
+  }
+}
+```
+
+Success:
+
+```json
+{
+  "result": [
+    {
+      "name": "session",
+      "value": "abc",
+      "domain": ".example.com",
+      "path": "/",
+      "expires": "2026-03-26T12:00:00Z",
+      "secure": true,
+      "httpOnly": true
+    }
+  ],
+  "error": null
+}
+```
+
+### `page.setCookie`
+
+Request:
+
+```json
+{
+  "method": "page.setCookie",
+  "params": {
+    "pageId": "page-1",
+    "cookie": {
+      "name": "session",
+      "value": "abc",
+      "domain": ".example.com",
+      "path": "/",
+      "expires": "2026-03-26T12:00:00Z",
+      "secure": true,
+      "httpOnly": true
+    }
+  }
+}
+```
+
+Success:
+
+```json
+{
+  "result": {},
+  "error": null
+}
+```
+
+### `page.deleteCookie`
+
+Request:
+
+```json
+{
+  "method": "page.deleteCookie",
+  "params": {
+    "pageId": "page-1",
+    "cookie": {
+      "name": "session",
+      "domain": ".example.com",
+      "path": "/"
+    }
+  }
+}
+```
+
+Success:
+
+```json
+{
+  "result": {},
+  "error": null
+}
+```
+
+### `page.clearCookies`
+
+Request:
+
+```json
+{
+  "method": "page.clearCookies",
+  "params": {
+    "pageId": "page-1"
+  }
+}
+```
+
+Success:
+
+```json
+{
+  "result": {},
+  "error": null
+}
+```
+
+### `page.close`
+
+Request:
+
+```json
+{
+  "method": "page.close",
+  "params": {
+    "pageId": "page-1"
+  }
+}
+```
+
+Success:
+
+```json
+{
+  "result": {},
+  "error": null
+}
+```
+
+## Method semantics
+
+- `page.open`
+  - Creates a page session
+  - Returns `pageId`
+- `page.addInitScript`
+  - Registers a page initialization script
+- `page.goto`
+  - Goes to the target URL
+  - The server should return only after navigation completes or fails
+- `page.execute`
+  - Executes an expression or serialized function body
+  - The returned value must be JSON-serializable
+- `page.getCookies`
+  - Returns cookies from the underlying native WebView cookie store
+- `page.setCookie`
+  - Inserts or updates a cookie
+- `page.deleteCookie`
+  - Deletes a cookie using `name/domain/path`
+- `page.clearCookies`
+  - Clears the current cookie store
+- `page.close`
+  - Closes the page and releases related resources
+
+## Cookie model
+
+Cookies use `runtime/webview.Cookie`.
+
+Example payload:
+
+```json
+{
+  "name": "session",
+  "value": "abc",
+  "domain": ".example.com",
+  "path": "/",
+  "expires": "2026-03-26T12:00:00Z",
+  "secure": true,
+  "httpOnly": true
+}
+```
+
+Notes:
+
+- `expires` uses RFC3339 / RFC3339Nano string form.
+- If the host platform supports a full native cookie store, it should return fields such as `httpOnly` and `secure`.
+- `setCookie -> goto` is a valid pattern for preloading authenticated session state.
+
+## Error codes
+
+The current error code set is defined in `pkg/download/engine/webview/rpc.go`:
+
+- `INVALID_REQUEST`
+- `UNKNOWN_METHOD`
+- `UNAVAILABLE`
+- `BROWSER_NOT_FOUND`
+- `PAGE_NOT_FOUND`
+- `NAVIGATION_FAILED`
+- `EVALUATION_FAILED`
+- `TIMEOUT`
+- `INTERNAL_ERROR`
+
+`BROWSER_NOT_FOUND` is a historical leftover from an earlier shape of the protocol. The current protocol no longer has a separate browser model, so this can be cleaned up later if the protocol is tightened further.
+
+## Current protocol boundary
+
+This protocol is intentionally limited:
+
+- Single-direction request/response only
+- Not REST-style resource routing
+- No bidirectional events
+- No streaming event subscriptions
+- No host-initiated push channel
+
+If the protocol needs to evolve toward full JSON-RPC later, the intended migration path is to keep the existing `method/params/result/error` structure and add:
+
+- `id`
+- notifications
+- a bidirectional transport model
+
+## Host implementation guidance
+
+A host implementation should usually:
+
+- Listen on a local `tcp` address or `unix socket`
+- Expose `POST /webview`
+- Validate the bearer token if configured
+- Maintain `pageId -> native webview/session`
+- Own page lifecycle, cleanup, and timeout handling
+
+With that split, Gopeed stays a pure RPC client and does not need to know how the host's native WebView is implemented.
@@ -0,0 +1,195 @@
+package rpcprovider
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"net"
+	"net/http"
+	"strings"
+
+	enginewebview "github.com/GopeedLab/gopeed/pkg/download/engine/webview"
+)
+
+type Provider struct {
+	client *Client
+}
+
+func New(cfg enginewebview.RPCConfig) enginewebview.Provider {
+	return &Provider{
+		client: NewClient(cfg),
+	}
+}
+
+func (p *Provider) IsAvailable() bool {
+	if p == nil || p.client == nil || !p.client.Enabled() {
+		return false
+	}
+	var result enginewebview.IsAvailableResult
+	if err := p.client.Call(enginewebview.MethodIsAvailable, enginewebview.IsAvailableParams{}, &result); err != nil {
+		return false
+	}
+	return result.Available
+}
+
+func (p *Provider) Open(opts enginewebview.OpenOptions) (enginewebview.Page, error) {
+	if p == nil || p.client == nil || !p.IsAvailable() {
+		return nil, enginewebview.ErrUnavailable
+	}
+	var result enginewebview.PageOpenResult
+	if err := p.client.Call(enginewebview.MethodPageOpen, enginewebview.NewPageOpenParams(opts), &result); err != nil {
+		return nil, err
+	}
+	return &page{
+		client: p.client,
+		id:     result.PageID,
+	}, nil
+}
+
+type page struct {
+	client *Client
+	id     string
+}
+
+func (p *page) AddInitScript(script string) error {
+	return p.client.Call(enginewebview.MethodPageAddInitScript, enginewebview.PageAddInitScriptParams{
+		PageID: p.id,
+		Script: script,
+	}, nil)
+}
+
+func (p *page) Goto(url string, opts enginewebview.GotoOptions) error {
+	return p.client.Call(enginewebview.MethodPageGoto, enginewebview.NewPageGotoParams(p.id, url, opts), nil)
+}
+
+func (p *page) Execute(expression string, args ...any) (any, error) {
+	var result any
+	if err := p.client.Call(enginewebview.MethodPageExecute, enginewebview.PageExecuteParams{
+		PageID:     p.id,
+		Expression: expression,
+		Args:       args,
+	}, &result); err != nil {
+		return nil, err
+	}
+	return result, nil
+}
+
+func (p *page) GetCookies() ([]enginewebview.Cookie, error) {
+	var result []enginewebview.Cookie
+	if err := p.client.Call(enginewebview.MethodPageGetCookies, enginewebview.PageGetCookiesParams{
+		PageID: p.id,
+	}, &result); err != nil {
+		return nil, err
+	}
+	if result == nil {
+		return []enginewebview.Cookie{}, nil
+	}
+	return result, nil
+}
+
+func (p *page) SetCookie(cookie enginewebview.Cookie) error {
+	return p.client.Call(enginewebview.MethodPageSetCookie, enginewebview.PageSetCookieParams{
+		PageID: p.id,
+		Cookie: cookie,
+	}, nil)
+}
+
+func (p *page) DeleteCookie(cookie enginewebview.Cookie) error {
+	return p.client.Call(enginewebview.MethodPageDeleteCookie, enginewebview.PageDeleteCookieParams{
+		PageID: p.id,
+		Cookie: cookie,
+	}, nil)
+}
+
+func (p *page) ClearCookies() error {
+	return p.client.Call(enginewebview.MethodPageClearCookies, enginewebview.PageClearCookiesParams{
+		PageID: p.id,
+	}, nil)
+}
+
+func (p *page) Close() error {
+	return p.client.Call(enginewebview.MethodPageClose, enginewebview.PageCloseParams{
+		PageID: p.id,
+	}, nil)
+}
+
+type Client struct {
+	endpoint string
+	token    string
+	http     *http.Client
+}
+
+func NewClient(cfg enginewebview.RPCConfig) *Client {
+	client := &Client{token: cfg.Token}
+	if !cfg.Enabled() {
+		return client
+	}
+	switch strings.ToLower(cfg.Network) {
+	case "unix":
+		client.endpoint = "http://unix" + enginewebview.RPCEndpointPath
+		client.http = &http.Client{
+			Transport: &http.Transport{
+				DialContext: func(ctx context.Context, _, _ string) (net.Conn, error) {
+					var d net.Dialer
+					return d.DialContext(ctx, "unix", cfg.Address)
+				},
+			},
+		}
+	default:
+		client.endpoint = "http://" + cfg.Address + enginewebview.RPCEndpointPath
+		client.http = &http.Client{}
+	}
+	return client
+}
+
+func (c *Client) Enabled() bool {
+	return c != nil && c.endpoint != "" && c.http != nil
+}
+
+func (c *Client) Call(method string, params any, result any) error {
+	if !c.Enabled() {
+		return enginewebview.ErrUnavailable
+	}
+	payload, err := json.Marshal(enginewebview.RPCRequest{
+		Method: method,
+		Params: params,
+	})
+	if err != nil {
+		return err
+	}
+
+	req, err := http.NewRequest(http.MethodPost, c.endpoint, bytes.NewReader(payload))
+	if err != nil {
+		return err
+	}
+	req.Header.Set("Content-Type", "application/json")
+	if c.token != "" {
+		req.Header.Set("Authorization", "Bearer "+c.token)
+	}
+
+	resp, err := c.http.Do(req)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return fmt.Errorf("webview rpc status %d", resp.StatusCode)
+	}
+
+	var body enginewebview.RPCResponse
+	if err := json.NewDecoder(resp.Body).Decode(&body); err != nil {
+		return err
+	}
+	if body.Error != nil {
+		return body.Error
+	}
+	if result == nil {
+		return nil
+	}
+	if len(body.Result) == 0 || string(body.Result) == "null" {
+		return nil
+	}
+	return json.Unmarshal(body.Result, result)
+}
@@ -0,0 +1,39 @@
+//go:build webview && darwin
+
+package rpcprovider
+
+import (
+	"flag"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/GopeedLab/gopeed/internal/webview/integrationtest"
+	enginewebview "github.com/GopeedLab/gopeed/pkg/download/engine/webview"
+)
+
+var (
+	webViewRPCNetwork = flag.String("webview-rpc-network", "unix", "WebView RPC network for integration tests")
+	webViewRPCAddress = flag.String("webview-rpc-address", defaultWebViewRPCAddress(), "WebView RPC address for integration tests")
+	webViewRPCToken   = flag.String("webview-rpc-token", "", "WebView RPC token for integration tests")
+)
+
+func TestProviderContract(t *testing.T) {
+	provider := New(enginewebview.RPCConfig{
+		Network: *webViewRPCNetwork,
+		Address: *webViewRPCAddress,
+		Token:   *webViewRPCToken,
+	})
+	integrationtest.RunProviderContract(t, provider, integrationtest.ContractOptions{
+		CookieDomainMode: integrationtest.CookieDomainModeRequired,
+		CookieTestURL:    "https://example.com/",
+	})
+}
+
+func defaultWebViewRPCAddress() string {
+	homeDir, err := os.UserHomeDir()
+	if err != nil {
+		return ""
+	}
+	return filepath.Join(homeDir, "Library", "Application Support", "com.gopeed.gopeed", "gopeed_webview.sock")
+}
@@ -0,0 +1,50 @@
+package rpcprovider
+
+import (
+	"encoding/json"
+	"net"
+	"net/http"
+	"os"
+	"path/filepath"
+	"testing"
+
+	enginewebview "github.com/GopeedLab/gopeed/pkg/download/engine/webview"
+)
+
+func TestProviderIsAvailableOverUnixSocket(t *testing.T) {
+	socketPath := filepath.Join("/tmp", "gopeed-rpcwebview-"+t.Name()+".sock")
+	listener, err := net.Listen("unix", socketPath)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer listener.Close()
+	defer os.Remove(socketPath)
+
+	server := &http.Server{
+		Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			var req enginewebview.RPCRequest
+			if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+				t.Fatal(err)
+			}
+			if req.Method != enginewebview.MethodIsAvailable {
+				t.Fatalf("unexpected unix method: %s", req.Method)
+			}
+			if err := json.NewEncoder(w).Encode(map[string]any{
+				"result": enginewebview.IsAvailableResult{Available: true},
+				"error":  nil,
+			}); err != nil {
+				t.Fatal(err)
+			}
+		}),
+	}
+	defer server.Close()
+	go server.Serve(listener)
+
+	provider := New(enginewebview.RPCConfig{
+		Network: "unix",
+		Address: socketPath,
+	})
+	if !provider.IsAvailable() {
+		t.Fatal("expected unix provider to be available")
+	}
+}
@@ -0,0 +1,186 @@
+package rpcprovider
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+
+	enginewebview "github.com/GopeedLab/gopeed/pkg/download/engine/webview"
+)
+
+func TestProviderLifecycleOverHTTP(t *testing.T) {
+	var calls []enginewebview.RPCRequest
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.Method != http.MethodPost {
+			t.Fatalf("unexpected method: %s", r.Method)
+		}
+		if r.URL.Path != enginewebview.RPCEndpointPath {
+			t.Fatalf("unexpected path: %s", r.URL.Path)
+		}
+		if got := r.Header.Get("Authorization"); got != "Bearer secret-token" {
+			t.Fatalf("unexpected auth header: %q", got)
+		}
+		var req enginewebview.RPCRequest
+		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+			t.Fatal(err)
+		}
+		calls = append(calls, req)
+
+		var body any
+		switch req.Method {
+		case enginewebview.MethodIsAvailable:
+			body = map[string]any{
+				"result": enginewebview.IsAvailableResult{Available: true},
+				"error":  nil,
+			}
+		case enginewebview.MethodPageOpen:
+			body = map[string]any{
+				"result": enginewebview.PageOpenResult{PageID: "page-open-1"},
+				"error":  nil,
+			}
+		case enginewebview.MethodPageAddInitScript, enginewebview.MethodPageGoto:
+			body = map[string]any{
+				"result": enginewebview.EmptyResult{},
+				"error":  nil,
+			}
+		case enginewebview.MethodPageExecute:
+			body = map[string]any{
+				"result": map[string]any{"title": "Example"},
+				"error":  nil,
+			}
+		case enginewebview.MethodPageClose:
+			body = map[string]any{
+				"result": enginewebview.EmptyResult{},
+				"error":  nil,
+			}
+		default:
+			t.Fatalf("unexpected method: %s", req.Method)
+		}
+		if err := json.NewEncoder(w).Encode(body); err != nil {
+			t.Fatal(err)
+		}
+	}))
+	defer server.Close()
+
+	cfg := enginewebview.RPCConfig{
+		Network: "tcp",
+		Address: server.Listener.Addr().String(),
+		Token:   "secret-token",
+	}
+	provider := New(cfg)
+	if !provider.IsAvailable() {
+		t.Fatal("expected provider to be available")
+	}
+
+	opener, ok := provider.(enginewebview.Opener)
+	if !ok {
+		t.Fatal("expected provider to implement runtime webview opener")
+	}
+	opened, err := opener.Open(enginewebview.OpenOptions{
+		Headless:  true,
+		Width:     1280,
+		Height:    720,
+		Title:     "Gopeed",
+		UserAgent: "UA",
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := opened.AddInitScript("window.__TEST__ = true"); err != nil {
+		t.Fatal(err)
+	}
+	if err := opened.Goto("https://example.com", enginewebview.GotoOptions{
+		TimeoutMS: 3210,
+		WaitUntil: "domcontentloaded",
+	}); err != nil {
+		t.Fatal(err)
+	}
+	value, err := opened.Execute("document.title")
+	if err != nil {
+		t.Fatal(err)
+	}
+	got, ok := value.(map[string]any)
+	if !ok || got["title"] != "Example" {
+		t.Fatalf("unexpected evaluate result: %#v", value)
+	}
+	if err := opened.Close(); err != nil {
+		t.Fatal(err)
+	}
+
+	expectedMethods := []string{
+		enginewebview.MethodIsAvailable,
+		enginewebview.MethodIsAvailable,
+		enginewebview.MethodPageOpen,
+		enginewebview.MethodPageAddInitScript,
+		enginewebview.MethodPageGoto,
+		enginewebview.MethodPageExecute,
+		enginewebview.MethodPageClose,
+	}
+	if len(calls) != len(expectedMethods) {
+		t.Fatalf("unexpected call count: got %d want %d", len(calls), len(expectedMethods))
+	}
+	for i, method := range expectedMethods {
+		if calls[i].Method != method {
+			t.Fatalf("unexpected method at %d: got %s want %s", i, calls[i].Method, method)
+		}
+	}
+	gotoParamsJSON, err := json.Marshal(calls[4].Params)
+	if err != nil {
+		t.Fatal(err)
+	}
+	var gotoParams enginewebview.PageGotoParams
+	if err := json.Unmarshal(gotoParamsJSON, &gotoParams); err != nil {
+		t.Fatal(err)
+	}
+	if gotoParams.WaitUntil != "domcontentloaded" {
+		t.Fatalf("unexpected waitUntil: %q", gotoParams.WaitUntil)
+	}
+}
+
+func TestProviderLaunchUnavailableWithoutEndpoint(t *testing.T) {
+	provider := New(enginewebview.RPCConfig{})
+	if provider.IsAvailable() {
+		t.Fatal("expected empty provider to be unavailable")
+	}
+	opener, ok := provider.(enginewebview.Opener)
+	if !ok {
+		t.Fatal("expected provider to implement runtime webview opener")
+	}
+	if _, err := opener.Open(enginewebview.OpenOptions{}); err == nil || err.Error() != enginewebview.ErrUnavailable.Error() {
+		t.Fatalf("unexpected launch error: %v", err)
+	}
+}
+
+func TestPageSetCookieParamsOmitsZeroExpires(t *testing.T) {
+	params := enginewebview.PageSetCookieParams{
+		PageID: "page-1",
+		Cookie: enginewebview.Cookie{
+			Name:   "visible",
+			Value:  "1",
+			Domain: "example.com",
+			Path:   "/",
+		},
+	}
+	payload, err := json.Marshal(params)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if string(payload) == "" {
+		t.Fatal("expected non-empty json payload")
+	}
+	if got := string(payload); strings.Contains(got, `"expires"`) {
+		t.Fatalf("unexpected zero expires in payload: %s", got)
+	}
+
+	params.Cookie.Expires = time.Now().UTC().Truncate(time.Second)
+	payload, err = json.Marshal(params)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got := string(payload); !strings.Contains(got, `"expires"`) {
+		t.Fatalf("expected expires in payload: %s", got)
+	}
+}
@@ -0,0 +1,82 @@
+package api
+
+import (
+	"encoding/json"
+	"sync"
+
+	"github.com/GopeedLab/gopeed/pkg/download"
+)
+
+type TaskEventMask uint64
+
+const (
+	TaskEventDone TaskEventMask = 1 << iota
+	TaskEventError
+)
+
+type TaskEvent struct {
+	Type   string `json:"type"`
+	TaskID string `json:"taskId"`
+	Name   string `json:"name,omitempty"`
+	Error  string `json:"error,omitempty"`
+}
+
+type TaskEventListener func(payload string)
+
+type taskEventSubscription struct {
+	mu       sync.RWMutex
+	mask     TaskEventMask
+	listener TaskEventListener
+}
+
+func (s *Service) SubscribeTaskEvents(mask TaskEventMask, listener TaskEventListener) {
+	s.taskEvents.mu.Lock()
+	defer s.taskEvents.mu.Unlock()
+	s.taskEvents.mask = mask
+	s.taskEvents.listener = listener
+}
+
+func (s *Service) emitTaskEvent(event *download.Event) {
+	if event == nil || event.Task == nil {
+		return
+	}
+
+	var mask TaskEventMask
+	switch event.Key {
+	case download.EventKeyDone:
+		mask = TaskEventDone
+	case download.EventKeyError:
+		mask = TaskEventError
+	default:
+		return
+	}
+
+	s.taskEvents.mu.RLock()
+	if s.taskEvents.mask&mask == 0 || s.taskEvents.listener == nil {
+		s.taskEvents.mu.RUnlock()
+		return
+	}
+	listener := s.taskEvents.listener
+	s.taskEvents.mu.RUnlock()
+
+	payload := TaskEvent{
+		Type:   "task." + string(event.Key),
+		TaskID: event.Task.ID,
+	}
+	if event.Task.Meta != nil {
+		payload.Name = event.Task.Name()
+	}
+	if event.Err != nil {
+		payload.Error = event.Err.Error()
+	}
+	data, err := json.Marshal(payload)
+	if err != nil {
+		return
+	}
+
+	// A platform callback must never be able to crash a download worker.
+	func() {
+		defer func() { _ = recover() }()
+		listener(string(data))
+	}()
+}
@@ -0,0 +1,37 @@
+package api
+
+import (
+	"encoding/json"
+	"testing"
+
+	"github.com/GopeedLab/gopeed/pkg/download"
+)
+
+func TestTaskEventSubscriptionFiltersMask(t *testing.T) {
+	service := &Service{}
+	var payloads []string
+	service.SubscribeTaskEvents(TaskEventDone, func(payload string) {
+		payloads = append(payloads, payload)
+	})
+
+	task := &download.Task{ID: "task-1"}
+	service.emitTaskEvent(&download.Event{Key: download.EventKeyError, Task: task})
+	service.emitTaskEvent(&download.Event{Key: download.EventKeyDone, Task: task})
+
+	if len(payloads) != 1 {
+		t.Fatalf("got %d callbacks, want 1", len(payloads))
+	}
+	var event TaskEvent
+	if err := json.Unmarshal([]byte(payloads[0]), &event); err != nil {
+		t.Fatal(err)
+	}
+	if event.Type != "task.done" || event.TaskID != task.ID {
+		t.Fatalf("unexpected event: %#v", event)
+	}
+}
+
+func TestTaskEventListenerPanicIsContained(t *testing.T) {
+	service := &Service{}
+	service.SubscribeTaskEvents(TaskEventDone, func(string) { panic("callback failed") })
+	service.emitTaskEvent(&download.Event{Key: download.EventKeyDone, Task: &download.Task{ID: "task-1"}})
+}