From 4a46d60f5d0ec1073cdad9a45b62d5f507c5095f Mon Sep 17 00:00:00 2001
From: aimercat1994 <aimercat1994@users.noreply.github.com>
Date: Sun, 5 Jul 2026 23:25:42 +0800
Subject: [PATCH 1/2] feat: Legado backup import & WebDAV reading progress sync

## Legado Backup Import
- Parse Legado App WebDAV backup .zip files and import into reader-next
- Supports: books, book sources, book groups, bookmarks, replace rules, RSS sources
- Auto-filters content:// local files, decodes data: URI inline books
- Sorts imported books by reading progress (chapter index > position > time)
- Preview modal shows import summary before confirming

## WebDAV Reading Progress Sync
- Legado-compatible progress format: /legado/bookProgress/{name}_{author}.json
- Auto-pull: syncs progress from WebDAV on bookshelf load (chapter index wins)
- Auto-push: writes progress to WebDAV on each chapter save (fire-and-forget)
- Manual sync: pull/push buttons in backup manager UI

## Files Changed
- frontend/src/utils/legadoImport.ts (new)
- frontend/src/utils/webdavSync.ts (new)
- frontend/src/utils/legadoImport.test.ts (new, 15 tests)
- frontend/src/components/WebdavManager.vue (modified)
- frontend/src/stores/bookshelf.ts (modified)
- frontend/src/stores/reader.ts (modified)
- frontend/package.json (added jszip dependency)
---
 frontend/package-lock.json                | 130 ++++--
 frontend/package.json                     |   1 +
 frontend/src/components/WebdavManager.vue | 273 ++++++++++++
 frontend/src/stores/bookshelf.ts          |  11 +
 frontend/src/stores/reader.ts             |  11 +
 frontend/src/utils/legadoImport.test.ts   | 282 +++++++++++++
 frontend/src/utils/legadoImport.ts        | 482 ++++++++++++++++++++++
 frontend/src/utils/webdavSync.ts          | 199 +++++++++
 8 files changed, 1359 insertions(+), 30 deletions(-)
 create mode 100644 frontend/src/utils/legadoImport.test.ts
 create mode 100644 frontend/src/utils/legadoImport.ts
 create mode 100644 frontend/src/utils/webdavSync.ts

diff --git a/frontend/package-lock.json b/frontend/package-lock.json
index 6525d80..fdbffcd 100644
--- a/frontend/package-lock.json
+++ b/frontend/package-lock.json
@@ -9,6 +9,7 @@
       "version": "1.0.13",
       "dependencies": {
         "axios": "^1.8.2",
+        "jszip": "^3.10.1",
         "opencc-js": "^1.0.5",
         "pinia": "^3.0.4",
         "vue": "^3.5.30",
@@ -273,9 +274,6 @@
         "arm64"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "MIT",
       "optional": true,
       "os": [
@@ -293,9 +291,6 @@
         "arm64"
       ],
       "dev": true,
-      "libc": [
-        "musl"
-      ],
       "license": "MIT",
       "optional": true,
       "os": [
@@ -313,9 +308,6 @@
         "ppc64"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "MIT",
       "optional": true,
       "os": [
@@ -333,9 +325,6 @@
         "s390x"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "MIT",
       "optional": true,
       "os": [
@@ -353,9 +342,6 @@
         "x64"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "MIT",
       "optional": true,
       "os": [
@@ -373,9 +359,6 @@
         "x64"
       ],
       "dev": true,
-      "libc": [
-        "musl"
-      ],
       "license": "MIT",
       "optional": true,
       "os": [
@@ -1095,6 +1078,12 @@
         "url": "https://github.com/sponsors/mesqueeb"
       }
     },
+    "node_modules/core-util-is": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.3.tgz",
+      "integrity": "sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==",
+      "license": "MIT"
+    },
     "node_modules/cross-spawn": {
       "version": "7.0.6",
       "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
@@ -1492,6 +1481,18 @@
       "integrity": "sha512-Yc+BQe8SvoXH1643Qez1zqLRmbA5rCL+sSmk6TVos0LWVfNIB7PGncdlId77WzLGSIB5KaWgTaNTs2lNVEI6VQ==",
       "license": "MIT"
     },
+    "node_modules/immediate": {
+      "version": "3.0.6",
+      "resolved": "https://registry.npmjs.org/immediate/-/immediate-3.0.6.tgz",
+      "integrity": "sha512-XXOFtyqDjNDAQxVfYxuF7g9Il/IbWmmlQg2MYKOH8ExIT1qg6xc4zyS3HaEEATgs1btfzxq15ciUiY7gjSXRGQ==",
+      "license": "MIT"
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "license": "ISC"
+    },
     "node_modules/ini": {
       "version": "1.3.8",
       "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz",
@@ -1521,6 +1522,12 @@
         "url": "https://github.com/sponsors/mesqueeb"
       }
     },
+    "node_modules/isarray": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/isarray/-/isarray-1.0.0.tgz",
+      "integrity": "sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==",
+      "license": "MIT"
+    },
     "node_modules/isexe": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
@@ -1573,6 +1580,27 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/jszip": {
+      "version": "3.10.1",
+      "resolved": "https://registry.npmjs.org/jszip/-/jszip-3.10.1.tgz",
+      "integrity": "sha512-xXDvecyTpGLrqFrvkrUSoxxfJI5AH7U8zxxtVclpsUtMCq4JQ290LY8AW5c7Ggnr/Y/oK+bQMbqK2qmtk3pN4g==",
+      "license": "(MIT OR GPL-3.0-or-later)",
+      "dependencies": {
+        "lie": "~3.3.0",
+        "pako": "~1.0.2",
+        "readable-stream": "~2.3.6",
+        "setimmediate": "^1.0.5"
+      }
+    },
+    "node_modules/lie": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/lie/-/lie-3.3.0.tgz",
+      "integrity": "sha512-UaiMJzeWRlEujzAuw5LokY1L5ecNQYZKfmyZ9L7wDHb/p5etKaxXhohBcrw0EYby+G/NA52vRSN4N39dxHAIwQ==",
+      "license": "MIT",
+      "dependencies": {
+        "immediate": "~3.0.5"
+      }
+    },
     "node_modules/lightningcss": {
       "version": "1.32.0",
       "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.32.0.tgz",
@@ -1716,9 +1744,6 @@
         "arm64"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "MPL-2.0",
       "optional": true,
       "os": [
@@ -1740,9 +1765,6 @@
         "arm64"
       ],
       "dev": true,
-      "libc": [
-        "musl"
-      ],
       "license": "MPL-2.0",
       "optional": true,
       "os": [
@@ -1764,9 +1786,6 @@
         "x64"
       ],
       "dev": true,
-      "libc": [
-        "glibc"
-      ],
       "license": "MPL-2.0",
       "optional": true,
       "os": [
@@ -1788,9 +1807,6 @@
         "x64"
       ],
       "dev": true,
-      "libc": [
-        "musl"
-      ],
       "license": "MPL-2.0",
       "optional": true,
       "os": [
@@ -1989,6 +2005,12 @@
       "dev": true,
       "license": "BlueOak-1.0.0"
     },
+    "node_modules/pako": {
+      "version": "1.0.11",
+      "resolved": "https://registry.npmjs.org/pako/-/pako-1.0.11.tgz",
+      "integrity": "sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==",
+      "license": "(MIT AND Zlib)"
+    },
     "node_modules/path-browserify": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-1.0.1.tgz",
@@ -2104,6 +2126,12 @@
         "node": "^10 || ^12 || >=14"
       }
     },
+    "node_modules/process-nextick-args": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
+      "integrity": "sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==",
+      "license": "MIT"
+    },
     "node_modules/proto-list": {
       "version": "1.2.4",
       "resolved": "https://registry.npmjs.org/proto-list/-/proto-list-1.2.4.tgz",
@@ -2117,6 +2145,21 @@
       "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==",
       "license": "MIT"
     },
+    "node_modules/readable-stream": {
+      "version": "2.3.8",
+      "resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-2.3.8.tgz",
+      "integrity": "sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==",
+      "license": "MIT",
+      "dependencies": {
+        "core-util-is": "~1.0.0",
+        "inherits": "~2.0.3",
+        "isarray": "~1.0.0",
+        "process-nextick-args": "~2.0.0",
+        "safe-buffer": "~5.1.1",
+        "string_decoder": "~1.1.1",
+        "util-deprecate": "~1.0.1"
+      }
+    },
     "node_modules/rfdc": {
       "version": "1.4.1",
       "resolved": "https://registry.npmjs.org/rfdc/-/rfdc-1.4.1.tgz",
@@ -2164,6 +2207,12 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/safe-buffer": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
+      "integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
+      "license": "MIT"
+    },
     "node_modules/semver": {
       "version": "7.8.5",
       "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.5.tgz",
@@ -2177,6 +2226,12 @@
         "node": ">=10"
       }
     },
+    "node_modules/setimmediate": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/setimmediate/-/setimmediate-1.0.5.tgz",
+      "integrity": "sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA==",
+      "license": "MIT"
+    },
     "node_modules/shebang-command": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
@@ -2252,6 +2307,15 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/string_decoder": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/string_decoder/-/string_decoder-1.1.1.tgz",
+      "integrity": "sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "~5.1.0"
+      }
+    },
     "node_modules/string-width": {
       "version": "5.1.2",
       "resolved": "https://registry.npmjs.org/string-width/-/string-width-5.1.2.tgz",
@@ -2441,6 +2505,12 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/util-deprecate": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+      "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
+      "license": "MIT"
+    },
     "node_modules/vite": {
       "version": "8.0.3",
       "resolved": "https://registry.npmjs.org/vite/-/vite-8.0.3.tgz",
diff --git a/frontend/package.json b/frontend/package.json
index 91619e9..33cd173 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -11,6 +11,7 @@
   },
   "dependencies": {
     "axios": "^1.8.2",
+    "jszip": "^3.10.1",
     "opencc-js": "^1.0.5",
     "pinia": "^3.0.4",
     "vue": "^3.5.30",
diff --git a/frontend/src/components/WebdavManager.vue b/frontend/src/components/WebdavManager.vue
index 761c71d..98cd23d 100644
--- a/frontend/src/components/WebdavManager.vue
+++ b/frontend/src/components/WebdavManager.vue
@@ -29,12 +29,21 @@
                 <button class="action-btn primary" :disabled="working" @click="createBackup">
                   备份当前数据
                 </button>
+                <button class="action-btn" :disabled="working" @click="triggerLegadoImport">
+                  导入 Legado 备份
+                </button>
                 <button class="action-btn" :disabled="working || loading" @click="loadFiles(currentPath)">
                   刷新列表
                 </button>
                 <button class="action-btn" :disabled="working" @click="triggerUpload">
                   上传文件
                 </button>
+                <button class="action-btn" :disabled="working" @click="pullProgress">
+                  拉取进度
+                </button>
+                <button class="action-btn" :disabled="working" @click="pushProgress">
+                  推送进度
+                </button>
                 <input
                   ref="fileInputRef"
                   type="file"
@@ -42,6 +51,13 @@
                   class="hidden-input"
                   @change="handleUpload"
                 />
+                <input
+                  ref="legadoImportRef"
+                  type="file"
+                  accept=".zip"
+                  class="hidden-input"
+                  @change="handleLegadoFileSelect"
+                />
               </div>
               <button
                 class="action-btn danger"
@@ -96,6 +112,14 @@
                   >
                     恢复
                   </button>
+                  <button
+                    v-if="!entry.isDirectory && isLegadoZipFile(entry.name)"
+                    class="mini-btn"
+                    :disabled="working"
+                    @click="importLegadoFromServer(entry)"
+                  >
+                    导入
+                  </button>
                   <button
                     v-if="!entry.isDirectory"
                     class="mini-btn"
@@ -119,12 +143,94 @@
         </section>
       </div>
     </Transition>
+
+    <!-- Legado import preview modal -->
+    <Transition name="scale">
+      <div v-if="legadoPreview" class="modal-container" @click.self="cancelLegadoImport">
+        <section class="webdav-modal legado-preview-modal">
+          <header class="modal-header">
+            <div>
+              <h2>导入 Legado 备份</h2>
+              <p class="subtitle">以下是从备份文件中解析出的数据，请确认后导入</p>
+            </div>
+            <button class="icon-btn" @click="cancelLegadoImport" aria-label="关闭">
+              <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                <path d="M18 6 6 18M6 6l12 12" />
+              </svg>
+            </button>
+          </header>
+          <div class="legado-summary">
+            <div class="summary-grid">
+              <div class="summary-item">
+                <span class="summary-num">{{ legadoPreview.books.length }}</span>
+                <span class="summary-label">书籍</span>
+                <span v-if="legadoPreview.skippedBooks > 0" class="summary-skip">
+                  (跳过 {{ legadoPreview.skippedBooks }} 本本地书籍)
+                </span>
+                <span v-if="legadoPreview.incompleteBooks > 0" class="summary-skip">
+                  ({{ legadoPreview.incompleteBooks }} 本需手动搜索补全)
+                </span>
+              </div>
+              <div class="summary-item">
+                <span class="summary-num">{{ legadoPreview.bookSources.length }}</span>
+                <span class="summary-label">书源</span>
+              </div>
+              <div class="summary-item">
+                <span class="summary-num">{{ legadoPreview.bookGroups.length }}</span>
+                <span class="summary-label">分组</span>
+              </div>
+              <div class="summary-item">
+                <span class="summary-num">{{ legadoPreview.bookmarks.length }}</span>
+                <span class="summary-label">书签</span>
+              </div>
+              <div class="summary-item">
+                <span class="summary-num">{{ legadoPreview.replaceRules.length }}</span>
+                <span class="summary-label">净化规则</span>
+              </div>
+              <div class="summary-item">
+                <span class="summary-num">{{ legadoPreview.rssSources.length }}</span>
+                <span class="summary-label">RSS 源</span>
+              </div>
+            </div>
+            <div class="notice warning">
+              <strong>注意</strong>
+              <span>导入会追加到当前数据中，不会覆盖已有内容。content:// 本地书籍（手机上的文件）会被跳过，data: 内联书籍会导入但需手动搜索补全书源。</span>
+            </div>
+          </div>
+          <div class="toolbar">
+            <div class="toolbar-left">
+              <button class="action-btn primary" :disabled="working" @click="applyLegadoImport">
+                确认导入
+              </button>
+              <button class="action-btn" :disabled="working" @click="cancelLegadoImport">
+                取消
+              </button>
+            </div>
+          </div>
+        </section>
+      </div>
+    </Transition>
   </Teleport>
 </template>
 
 <script setup lang="ts">
 import { computed, ref, watch } from 'vue'
 import { useAppStore } from '../stores/app'
+import { useBookshelfStore } from '../stores/bookshelf'
+import {
+  tryParseLegadoBackupZip,
+  type LegadoImportResult,
+} from '../utils/legadoImport'
+import {
+  syncProgressFromWebdav,
+  writeAllProgressToWebdav,
+} from '../utils/webdavSync'
+import { saveBooks } from '../api/bookshelf'
+import { saveBookSources } from '../api/source'
+import { saveBookGroup } from '../api/bookshelf'
+import { saveBookmarks } from '../api/bookmark'
+import { saveReplaceRules } from '../api/replaceRule'
+import { saveRssSources } from '../api/rss'
 import {
   deleteWebdavFile,
   deleteWebdavFileList,
@@ -153,6 +259,7 @@ const emit = defineEmits<{
 }>()
 
 const appStore = useAppStore()
+const bookshelfStore = useBookshelfStore()
 const fileInputRef = ref<HTMLInputElement | null>(null)
 const currentPath = ref('/')
 const entries = ref<EntryRow[]>([])
@@ -160,6 +267,8 @@ const selectedPaths = ref<string[]>([])
 const loading = ref(false)
 const working = ref(false)
 const errorMessage = ref('')
+const legadoImportRef = ref<HTMLInputElement | null>(null)
+const legadoPreview = ref<LegadoImportResult | null>(null)
 
 const webdavAvailable = computed(() => {
   if (!appStore.isSecureMode) return true
@@ -199,6 +308,10 @@ function isBackupFile(name: string) {
   return name.toLowerCase().endsWith('.json')
 }
 
+function isLegadoZipFile(name: string) {
+  return name.toLowerCase().endsWith('.zip')
+}
+
 function formatSize(size: number) {
   if (!size) return '0 B'
   const units = ['B', 'KB', 'MB', 'GB']
@@ -271,6 +384,39 @@ function triggerUpload() {
   fileInputRef.value?.click()
 }
 
+function triggerLegadoImport() {
+  legadoImportRef.value?.click()
+}
+
+async function pullProgress() {
+  working.value = true
+  try {
+    const result = await syncProgressFromWebdav(bookshelfStore.books)
+    if (result.updated > 0) {
+      bookshelfStore.books = result.books
+      appStore.showToast(`已从 WebDAV 同步 ${result.updated} 本书的阅读进度`, 'success')
+    } else {
+      appStore.showToast('没有需要更新的阅读进度', 'warning')
+    }
+  } catch (error) {
+    appStore.showToast((error as Error).message || '拉取进度失败', 'error')
+  } finally {
+    working.value = false
+  }
+}
+
+async function pushProgress() {
+  working.value = true
+  try {
+    const written = await writeAllProgressToWebdav(bookshelfStore.books)
+    appStore.showToast(`已推送 ${written} 本书的阅读进度到 WebDAV`, 'success')
+  } catch (error) {
+    appStore.showToast((error as Error).message || '推送进度失败', 'error')
+  } finally {
+    working.value = false
+  }
+}
+
 async function handleUpload(event: Event) {
   const input = event.target as HTMLInputElement
   const files = Array.from(input.files || [])
@@ -362,6 +508,93 @@ async function removeSelected() {
     working.value = false
   }
 }
+async function handleLegadoFileSelect(event: Event) {
+  const input = event.target as HTMLInputElement
+  const file = input.files?.[0]
+  if (!file) return
+  if (!file.name.toLowerCase().endsWith('.zip')) {
+    appStore.showToast('请选择 .zip 格式的备份文件', 'error')
+    input.value = ''
+    return
+  }
+  working.value = true
+  try {
+    const result = await tryParseLegadoBackupZip(file)
+    if (!result) {
+      appStore.showToast('该 ZIP 文件不是 Legado 备份格式', 'error')
+      return
+    }
+    legadoPreview.value = result
+  } catch (error) {
+    appStore.showToast((error as Error).message || '解析备份文件失败', 'error')
+  } finally {
+    working.value = false
+    input.value = ''
+  }
+}
+
+async function applyLegadoImport() {
+  const data = legadoPreview.value
+  if (!data) return
+  working.value = true
+  const errors: string[] = []
+  try {
+    // Import in dependency order: sources → groups → books → bookmarks → rules → rss
+    if (data.bookSources.length) {
+      try { await saveBookSources(data.bookSources) } catch (e) { errors.push(`书源: ${(e as Error).message}`) }
+    }
+    for (const group of data.bookGroups) {
+      try { await saveBookGroup(group) } catch (e) { errors.push(`分组 ${group.groupName}: ${(e as Error).message}`) }
+    }
+    if (data.books.length) {
+      try { await saveBooks(data.books) } catch (e) { errors.push(`书籍: ${(e as Error).message}`) }
+    }
+    if (data.bookmarks.length) {
+      try { await saveBookmarks(data.bookmarks) } catch (e) { errors.push(`书签: ${(e as Error).message}`) }
+    }
+    if (data.replaceRules.length) {
+      try { await saveReplaceRules(data.replaceRules) } catch (e) { errors.push(`净化规则: ${(e as Error).message}`) }
+    }
+    if (data.rssSources.length) {
+      try { await saveRssSources(data.rssSources) } catch (e) { errors.push(`RSS源: ${(e as Error).message}`) }
+    }
+    legadoPreview.value = null
+    if (errors.length > 0) {
+      appStore.showToast(`部分导入失败: ${errors.join('; ')}`, 'error')
+      working.value = false
+    } else {
+      appStore.showToast('Legado 备份导入完成，正在刷新页面', 'success')
+      window.setTimeout(() => {
+        window.location.reload()
+      }, 800)
+    }
+  } catch (error) {
+    appStore.showToast((error as Error).message || '导入失败', 'error')
+    working.value = false
+  }
+}
+
+function cancelLegadoImport() {
+  legadoPreview.value = null
+}
+
+async function importLegadoFromServer(entry: EntryRow) {
+  if (!confirm(`确定从 ${entry.name} 导入 Legado 备份数据吗？`)) return
+  working.value = true
+  try {
+    const blob = await getWebdavFileBlob(entry.path)
+    const result = await tryParseLegadoBackupZip(blob)
+    if (!result) {
+      appStore.showToast('该文件不是 Legado 备份格式', 'error')
+      return
+    }
+    legadoPreview.value = result
+  } catch (error) {
+    appStore.showToast((error as Error).message || '解析失败', 'error')
+  } finally {
+    working.value = false
+  }
+}
 
 async function restoreBackup(entry: EntryRow) {
   if (!confirm(`确定从 ${entry.name} 恢复数据吗？这会覆盖当前书架、书源、RSS、书签和相关本地配置。`)) {
@@ -637,6 +870,46 @@ async function restoreBackup(entry: EntryRow) {
   display: none;
 }
 
+.legado-preview-modal {
+  max-width: 640px;
+}
+
+.legado-summary {
+  padding: var(--space-4) var(--space-6);
+}
+
+.summary-grid {
+  display: grid;
+  grid-template-columns: repeat(3, 1fr);
+  gap: var(--space-3);
+  margin-bottom: var(--space-4);
+}
+
+.summary-item {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  padding: var(--space-3);
+  border-radius: var(--radius-md);
+  background: var(--color-bg-sunken);
+}
+
+.summary-num {
+  font-size: var(--text-2xl);
+  font-weight: 700;
+  color: var(--color-primary);
+}
+
+.summary-label {
+  font-size: var(--text-sm);
+  color: var(--color-text-secondary);
+}
+
+.summary-skip {
+  font-size: var(--text-xs);
+  color: var(--color-text-tertiary);
+}
+
 @media (max-width: 768px) {
   .modal-container {
     padding: var(--space-3);
diff --git a/frontend/src/stores/bookshelf.ts b/frontend/src/stores/bookshelf.ts
index b9bad50..4b46f18 100644
--- a/frontend/src/stores/bookshelf.ts
+++ b/frontend/src/stores/bookshelf.ts
@@ -14,6 +14,7 @@ import type { Book, BookGroup, SearchBook } from '../types'
 import { deleteBrowserBookCache, listBrowserCacheSummary } from '../utils/browserCache'
 import { isLocalTxtBook } from '../utils/localBook'
 import { clearRecentReadBooks, getRecentReadBookKey, loadRecentReadBooks, removeRecentReadBook } from '../utils/recentBooks'
+import { syncProgressFromWebdav } from '../utils/webdavSync'
 
 type SearchScope = 'all' | 'group' | 'source'
 
@@ -114,6 +115,16 @@ export const useBookshelfStore = defineStore('bookshelf', () => {
         browserCachedChapterCount: isLocalTxtBook(book) ? 0 : browserMap.get(book.bookUrl) || 0,
       }))
       await refreshRecentBooks()
+
+      // Sync reading progress from WebDAV (Legado compatible, fire-and-forget)
+      syncProgressFromWebdav(books.value).then((result) => {
+        if (result.updated > 0) {
+          books.value = result.books.map((book) => ({
+            ...book,
+            browserCachedChapterCount: isLocalTxtBook(book) ? 0 : browserMap.get(book.bookUrl) || 0,
+          }))
+        }
+      }).catch(() => undefined)
     } finally {
       loading.value = false
     }
diff --git a/frontend/src/stores/reader.ts b/frontend/src/stores/reader.ts
index 018c327..c5471ba 100644
--- a/frontend/src/stores/reader.ts
+++ b/frontend/src/stores/reader.ts
@@ -2,6 +2,7 @@
 import { ref, computed, reactive, watch } from 'vue'
 import { useAppStore } from './app'
 import { useBookshelfStore } from './bookshelf'
+import { writeProgressToWebdav } from '../utils/webdavSync'
 import { useAiBookStore } from './aiBook'
 import {
   getChapterList,
@@ -1353,6 +1354,16 @@ export const useReaderStore = defineStore('reader', () => {
     await saveBookProgress(payload).then(() => {
       progressDirty.value = false
       lastServerProgressKey.value = `${payload.bookUrl}::${payload.index}::${payload.position}`
+      // Also write progress to WebDAV for Legado sync (fire-and-forget)
+      if (book.value) {
+        writeProgressToWebdav({
+          ...book.value,
+          durChapterIndex: index,
+          durChapterPos: Math.round(progress * 1000),
+          durChapterTime: Date.now(),
+          durChapterTitle: chapters.value[index]?.title,
+        }).catch(() => undefined)
+      }
     }).catch(() => undefined)
   }
 
diff --git a/frontend/src/utils/legadoImport.test.ts b/frontend/src/utils/legadoImport.test.ts
new file mode 100644
index 0000000..4e0eff1
--- /dev/null
+++ b/frontend/src/utils/legadoImport.test.ts
@@ -0,0 +1,282 @@
+import { describe, it, expect } from 'vitest'
+import JSZip from 'jszip'
+import { parseLegadoBackupZip, isLegadoBackupZip, tryParseLegadoBackupZip } from './legadoImport'
+
+// ─── Test fixtures ───
+
+const sampleLegadoBook = {
+  name: '测试书籍',
+  author: '测试作者',
+  bookUrl: 'https://example.com/book/1',
+  origin: 'https://example.com',
+  originName: '测试书源',
+  coverUrl: 'https://example.com/cover.jpg',
+  durChapterIndex: 10,
+  durChapterPos: 500,
+  durChapterTime: 1700000000000,
+  durChapterTitle: '第十章',
+  group: 0,
+  canUpdate: true,
+  totalChapterNum: 100,
+  type: 0,
+  order: 0,
+}
+
+const sampleBookSource = {
+  bookSourceName: '测试书源',
+  bookSourceUrl: 'https://example.com',
+  bookSourceGroup: '测试',
+  bookSourceType: 0,
+  enabled: true,
+  enabledExplore: true,
+  searchUrl: 'https://example.com/search?keyword={{key}}',
+  ruleSearch: { bookList: 'div.book-item', bookName: 'h3' },
+  ruleBookInfo: { name: 'h1', author: '.author' },
+  ruleToc: { chapterList: 'li.chapter', chapterName: 'a' },
+  ruleContent: { content: '#content' },
+}
+
+const sampleBookGroup = {
+  groupId: 1,
+  groupName: '收藏',
+  order: 0,
+  show: true,
+  enableRefresh: true,
+  bookSort: -1,
+  isPrivate: false,
+}
+
+const sampleBookmark = {
+  bookName: '测试书籍',
+  bookAuthor: '测试作者',
+  chapterIndex: 5,
+  chapterPos: 200,
+  chapterName: '第五章',
+  bookText: '这是书签标记的文字',
+  content: '这是书签标记的文字',
+  time: 1700000000000,
+}
+
+const sampleReplaceRule = {
+  id: 1,
+  name: '净化规则',
+  group: '默认',
+  pattern: '广告内容',
+  replacement: '',
+  scopeContent: true,
+  scopeTitle: false,
+  isEnabled: true,
+  isRegex: false,
+  order: 0,
+}
+
+const sampleRssSource = {
+  sourceUrl: 'https://example.com/rss',
+  sourceName: '测试RSS',
+  sourceGroup: '新闻',
+  enabled: true,
+  ruleArticles: 'article',
+  ruleTitle: 'h2',
+  ruleLink: 'a[href]',
+}
+
+// Helper to create a zip blob from JSON files
+async function createTestZip(files: Record<string, unknown>): Promise<Blob> {
+  const zip = new JSZip()
+  for (const [name, data] of Object.entries(files)) {
+    zip.file(name, JSON.stringify(data))
+  }
+  return zip.generateAsync({ type: 'blob' })
+}
+
+// ─── Tests ───
+
+describe('isLegadoBackupZip', () => {
+  it('returns true for valid Legado zip with bookshelf.json', async () => {
+    const blob = await createTestZip({ 'bookshelf.json': [sampleLegadoBook] })
+    expect(await isLegadoBackupZip(blob)).toBe(true)
+  })
+
+  it('returns true for valid Legado zip with bookSource.json only', async () => {
+    const blob = await createTestZip({ 'bookSource.json': [sampleBookSource] })
+    expect(await isLegadoBackupZip(blob)).toBe(true)
+  })
+
+  it('returns false for zip without known files', async () => {
+    const blob = await createTestZip({ 'random.json': {} })
+    expect(await isLegadoBackupZip(blob)).toBe(false)
+  })
+
+  it('returns false for non-zip data', async () => {
+    const blob = new Blob(['not a zip'])
+    expect(await isLegadoBackupZip(blob)).toBe(false)
+  })
+})
+
+describe('parseLegadoBackupZip', () => {
+  it('parses a complete Legado backup', async () => {
+    const blob = await createTestZip({
+      'bookshelf.json': [sampleLegadoBook],
+      'bookSource.json': [sampleBookSource],
+      'bookGroup.json': [sampleBookGroup],
+      'bookmark.json': [sampleBookmark],
+      'replaceRule.json': [sampleReplaceRule],
+      'rssSources.json': [sampleRssSource],
+    })
+
+    const result = await parseLegadoBackupZip(blob)
+
+    expect(result.books).toHaveLength(1)
+    expect(result.books[0].name).toBe('测试书籍')
+    expect(result.books[0].bookUrl).toBe('https://example.com/book/1')
+    expect(result.books[0].durChapterIndex).toBe(10)
+    expect(result.skippedBooks).toBe(0)
+
+    expect(result.bookSources).toHaveLength(1)
+    expect(result.bookSources[0].bookSourceName).toBe('测试书源')
+
+    expect(result.bookGroups).toHaveLength(1)
+    expect(result.bookGroups[0].groupName).toBe('收藏')
+
+    expect(result.bookmarks).toHaveLength(1)
+    expect(result.bookmarks[0].bookName).toBe('测试书籍')
+
+    expect(result.replaceRules).toHaveLength(1)
+    expect(result.replaceRules[0].name).toBe('净化规则')
+    expect(result.replaceRules[0].scope).toBe('content')
+
+    expect(result.rssSources).toHaveLength(1)
+    expect(result.rssSources[0].sourceName).toBe('测试RSS')
+  })
+
+  it('filters out content:// books', async () => {
+    const blob = await createTestZip({
+      'bookshelf.json': [
+        sampleLegadoBook,
+        { ...sampleLegadoBook, name: '本地书', bookUrl: 'content://com.example/book' },
+        { ...sampleLegadoBook, name: '内联书', bookUrl: 'data:;base64,abc123' },
+      ],
+    })
+
+    const result = await parseLegadoBackupZip(blob)
+    expect(result.books).toHaveLength(1)
+    expect(result.books[0].name).toBe('测试书籍')
+    expect(result.skippedBooks).toBe(2)
+  })
+
+  it('handles empty or missing files gracefully', async () => {
+    const blob = await createTestZip({})
+    const result = await parseLegadoBackupZip(blob)
+
+    expect(result.books).toHaveLength(0)
+    expect(result.bookSources).toHaveLength(0)
+    expect(result.bookGroups).toHaveLength(0)
+    expect(result.bookmarks).toHaveLength(0)
+    expect(result.replaceRules).toHaveLength(0)
+    expect(result.rssSources).toHaveLength(0)
+    expect(result.skippedBooks).toBe(0)
+  })
+
+  it('handles malformed JSON gracefully', async () => {
+    const zip = new JSZip()
+    zip.file('bookshelf.json', 'not valid json{{{')
+    zip.file('bookSource.json', JSON.stringify([sampleBookSource]))
+    const blob = await zip.generateAsync({ type: 'blob' })
+
+    const result = await parseLegadoBackupZip(blob)
+    expect(result.books).toHaveLength(0)
+    expect(result.bookSources).toHaveLength(1)
+  })
+
+  it('converts replace rule scope correctly', async () => {
+    const blob = await createTestZip({
+      'replaceRule.json': [
+        { ...sampleReplaceRule, scopeContent: true, scopeTitle: true },
+        { ...sampleReplaceRule, id: 2, name: '标题规则', scopeContent: false, scopeTitle: true },
+        { ...sampleReplaceRule, id: 3, name: '内容规则', scopeContent: true, scopeTitle: false },
+        { ...sampleReplaceRule, id: 4, name: '无scope', scopeContent: false, scopeTitle: false },
+      ],
+    })
+
+    const result = await parseLegadoBackupZip(blob)
+    expect(result.replaceRules[0].scope).toBe('all')
+    expect(result.replaceRules[1].scope).toBe('title')
+    expect(result.replaceRules[2].scope).toBe('content')
+    expect(result.replaceRules[3].scope).toBeUndefined()
+  })
+
+  it('sorts books by reading progress descending', async () => {
+    const blob = await createTestZip({
+      'bookshelf.json': [
+        { ...sampleLegadoBook, name: '旧书', durChapterIndex: 10, durChapterPos: 0, durChapterTime: 1700000000000 },
+        { ...sampleLegadoBook, name: '新书', durChapterIndex: 100, durChapterPos: 500, durChapterTime: 1700100000000 },
+        { ...sampleLegadoBook, name: '中间', durChapterIndex: 50, durChapterPos: 0, durChapterTime: 1700050000000 },
+      ],
+    })
+    const result = await parseLegadoBackupZip(blob)
+    expect(result.books[0].name).toBe('新书')   // chapter 100
+    expect(result.books[1].name).toBe('中间')   // chapter 50
+    expect(result.books[2].name).toBe('旧书')   // chapter 10
+  })
+
+  it('maps Legado book fields to reader-next format', async () => {
+    const legadoBook = {
+      ...sampleLegadoBook,
+      latestChapterTitle: '最新章节',
+      lastCheckTime: 1700000000000,
+      tocUrl: 'https://example.com/toc',
+      charset: 'utf-8',
+    }
+    const blob = await createTestZip({ 'bookshelf.json': [legadoBook] })
+    const result = await parseLegadoBackupZip(blob)
+
+    const book = result.books[0]
+    expect(book.name).toBe('测试书籍')
+    expect(book.author).toBe('测试作者')
+    expect(book.origin).toBe('https://example.com')
+    expect(book.latestChapterTitle).toBe('最新章节')
+    expect(book.lastCheckTime).toBe(1700000000000)
+    expect(book.tocUrl).toBe('https://example.com/toc')
+    expect(book.charset).toBe('utf-8')
+    expect(book.canUpdate).toBe(true)
+  })
+
+  it('handles bookmark with only content field (no bookText)', async () => {
+    const blob = await createTestZip({
+      'bookmark.json': [{
+        bookName: '书名',
+        bookAuthor: '作者',
+        content: '标记内容',
+      }],
+    })
+
+    const result = await parseLegadoBackupZip(blob)
+    expect(result.bookmarks[0].bookText).toBe('标记内容')
+    expect(result.bookmarks[0].content).toBe('标记内容')
+  })
+})
+describe('tryParseLegadoBackupZip', () => {
+  it('returns LegadoImportResult for valid zip', async () => {
+    const blob = await createTestZip({
+      'bookshelf.json': [sampleLegadoBook],
+      'bookSource.json': [sampleBookSource],
+    })
+    const result = await tryParseLegadoBackupZip(blob)
+    expect(result).not.toBeNull()
+    expect(result!.books).toHaveLength(1)
+    expect(result!.bookSources).toHaveLength(1)
+  })
+
+  it('returns null for non-Legado zip', async () => {
+    const blob = await createTestZip({ 'random.json': {} })
+    const result = await tryParseLegadoBackupZip(blob)
+    expect(result).toBeNull()
+  })
+
+  it('returns null for non-zip data', async () => {
+    const blob = new Blob(['not a zip'])
+    const result = await tryParseLegadoBackupZip(blob)
+    expect(result).toBeNull()
+  })
+})
+
diff --git a/frontend/src/utils/legadoImport.ts b/frontend/src/utils/legadoImport.ts
new file mode 100644
index 0000000..e29e48e
--- /dev/null
+++ b/frontend/src/utils/legadoImport.ts
@@ -0,0 +1,482 @@
+/**
+ * Legado (阅读 App) backup ZIP importer.
+ *
+ * Parses a Legado WebDAV backup .zip file and converts its contents
+ * into reader-next's native data format, ready to call existing save APIs.
+ *
+ * Supported Legado files inside the ZIP:
+ *   bookshelf.json   → Book[]        (with field mapping + filtering)
+ *   bookSource.json  → BookSource[]  (near-direct mapping)
+ *   bookGroup.json   → BookGroup[]   (groupId remapping)
+ *   bookmark.json    → Bookmark[]
+ *   replaceRule.json → ReplaceRule[]
+ *   rssSources.json  → RssSource[]
+ */
+import JSZip from 'jszip'
+import type { Book, BookGroup, BookSource, Bookmark, ReplaceRule, RssSource } from '../types'
+
+// ─── Legado raw types (subset of actual fields) ───
+
+interface LegadoBook {
+  name: string
+  author: string
+  bookUrl: string
+  origin: string
+  originName?: string
+  coverUrl?: string
+  tocUrl?: string
+  charset?: string
+  customCoverUrl?: string
+  canUpdate?: boolean
+  durChapterIndex?: number
+  durChapterPos?: number
+  durChapterTime?: number
+  durChapterTitle?: string
+  group?: number
+  lastCheckTime?: number
+  latestChapterTitle?: string
+  totalChapterNum?: number
+  type?: number
+  order?: number
+  [key: string]: unknown
+}
+
+interface LegadoBookSource {
+  bookSourceName: string
+  bookSourceUrl: string
+  bookSourceGroup?: string
+  bookSourceType?: number
+  bookSourceComment?: string
+  enabled?: boolean
+  enabledExplore?: boolean
+  enabledCookieJar?: boolean
+  customOrder?: number
+  weight?: number
+  searchUrl?: string
+  exploreUrl?: string
+  loginUrl?: string
+  loginUi?: string
+  jsLib?: string
+  header?: string
+  bookUrlPattern?: string
+  ruleSearch?: Record<string, unknown>
+  ruleExplore?: Record<string, unknown>
+  ruleBookInfo?: Record<string, unknown>
+  ruleToc?: Record<string, unknown>
+  ruleContent?: Record<string, unknown>
+  [key: string]: unknown
+}
+
+interface LegadoBookGroup {
+  groupId: number
+  groupName: string
+  order?: number
+  show?: boolean
+  enableRefresh?: boolean
+  bookSort?: number
+  isPrivate?: boolean
+}
+
+interface LegadoBookmark {
+  bookUrl?: string
+  bookName: string
+  bookAuthor?: string
+  chapterIndex?: number
+  chapterPos?: number
+  chapterName?: string
+  bookText?: string
+  content?: string
+  time?: number
+}
+
+interface LegadoReplaceRule {
+  id?: number
+  name: string
+  group?: string
+  pattern: string
+  replacement: string
+  scopeContent?: boolean
+  scopeTitle?: boolean
+  isEnabled?: boolean
+  isRegex?: boolean
+  order?: number
+  timeoutMillisecond?: number
+}
+
+interface LegadoRssSource {
+  sourceUrl: string
+  sourceName: string
+  sourceIcon?: string
+  sourceGroup?: string
+  sourceComment?: string
+  enabled?: boolean
+  enabledCookieJar?: boolean
+  concurrentRate?: string
+  header?: string
+  loginUrl?: string
+  loginCheckJs?: string
+  sortUrl?: string
+  singleUrl?: boolean
+  articleStyle?: number
+  ruleArticles?: string
+  ruleNextPage?: string
+  ruleTitle?: string
+  rulePubDate?: string
+  ruleDescription?: string
+  ruleImage?: string
+  ruleLink?: string
+  ruleContent?: string
+  style?: string
+  enableJs?: boolean
+  loadWithBaseUrl?: boolean
+  customOrder?: number
+  lastUpdateTime?: number
+}
+
+// ─── Import result types ───
+
+export interface LegadoImportResult {
+  books: Book[]
+  skippedBooks: number
+  incompleteBooks: number  // data: URI decoded books with no resolvable bookUrl
+  bookSources: BookSource[]
+  bookGroups: BookGroup[]
+  bookmarks: Bookmark[]
+  replaceRules: ReplaceRule[]
+  rssSources: RssSource[]
+}
+
+// ─── Core import logic ───
+
+function isUsableBookUrl(url: string): boolean {
+  if (!url) return false
+  // content:// URIs are Android local files — no file content in backup
+  if (url.startsWith('content://')) return false
+  // data: URIs need source resolution that may not be available
+  if (url.startsWith('data:')) return false
+  return true
+}
+
+/**
+ * Decode a data: URI book (晴天融合VIP4.0 style inline book references).
+ * Returns a usable book entry with name/author only, or null if unresolvable.
+ */
+function decodeDataUriBook(legado: LegadoBook): Book | null {
+  try {
+    const url = legado.bookUrl
+    const b64 = url.split(',', 2)[1]
+    if (!b64) return null
+    const json = JSON.parse(atob(b64))
+    // data: URI books have { book_id, sources, tab, url }
+    // Use the book name + author as a searchable reference
+    return {
+      name: legado.name ?? '',
+      author: legado.author ?? '',
+      bookUrl: '',  // no resolvable URL
+      origin: legado.origin ?? json.sources ?? '',
+      originName: legado.originName ?? json.sources,
+      coverUrl: legado.coverUrl,
+      customCoverUrl: legado.customCoverUrl,
+      canUpdate: false,  // can't auto-update without source
+      durChapterIndex: legado.durChapterIndex ?? 0,
+      durChapterPos: legado.durChapterPos ?? 0,
+      durChapterTime: legado.durChapterTime,
+      durChapterTitle: legado.durChapterTitle,
+      latestChapterTitle: legado.latestChapterTitle,
+      lastCheckTime: legado.lastCheckTime,
+      totalChapterNum: legado.totalChapterNum,
+      type: legado.type,
+      group: legado.group,
+    }
+  } catch {
+    return null
+  }
+}
+
+function convertBook(legado: LegadoBook): Book {
+  return {
+    name: legado.name ?? '',
+    author: legado.author ?? '',
+    bookUrl: legado.bookUrl,
+    origin: legado.origin ?? '',
+    originName: legado.originName,
+    coverUrl: legado.coverUrl,
+    tocUrl: legado.tocUrl,
+    charset: legado.charset,
+    customCoverUrl: legado.customCoverUrl,
+    canUpdate: legado.canUpdate ?? true,
+    durChapterIndex: legado.durChapterIndex ?? 0,
+    durChapterPos: legado.durChapterPos ?? 0,
+    durChapterTime: legado.durChapterTime,
+    durChapterTitle: legado.durChapterTitle,
+    latestChapterTitle: legado.latestChapterTitle,
+    lastCheckTime: legado.lastCheckTime,
+    totalChapterNum: legado.totalChapterNum,
+    type: legado.type,
+    group: legado.group,
+  }
+}
+
+function convertBookSource(legado: LegadoBookSource): BookSource {
+  return {
+    bookSourceName: legado.bookSourceName ?? '',
+    bookSourceUrl: legado.bookSourceUrl ?? '',
+    bookSourceGroup: legado.bookSourceGroup,
+    bookSourceType: legado.bookSourceType,
+    enabled: legado.enabled ?? true,
+    enabledExplore: legado.enabledExplore ?? false,
+    enabledCookieJar: legado.enabledCookieJar,
+    customOrder: legado.customOrder,
+    weight: legado.weight,
+    searchUrl: legado.searchUrl,
+    exploreUrl: legado.exploreUrl,
+    header: legado.header,
+    loginUrl: legado.loginUrl,
+    ruleSearch: legado.ruleSearch as Record<string, string>,
+    ruleExplore: legado.ruleExplore as Record<string, string>,
+    ruleBookInfo: legado.ruleBookInfo as Record<string, string>,
+    ruleToc: legado.ruleToc as Record<string, string>,
+    ruleContent: legado.ruleContent as Record<string, string>,
+  }
+}
+
+function convertBookGroup(legado: LegadoBookGroup): BookGroup {
+  return {
+    groupId: legado.groupId,
+    groupName: legado.groupName ?? '',
+    orderNo: legado.order,
+  }
+}
+
+function convertBookmark(legado: LegadoBookmark): Bookmark {
+  return {
+    bookName: legado.bookName ?? '',
+    bookAuthor: legado.bookAuthor ?? '',
+    chapterIndex: legado.chapterIndex,
+    chapterPos: legado.chapterPos,
+    chapterName: legado.chapterName,
+    bookText: legado.bookText ?? legado.content,
+    content: legado.content ?? legado.bookText,
+    time: legado.time,
+  }
+}
+
+function convertReplaceRule(legado: LegadoReplaceRule): ReplaceRule {
+  let scope: string | undefined
+  if (legado.scopeContent && legado.scopeTitle) {
+    scope = 'all'
+  } else if (legado.scopeContent) {
+    scope = 'content'
+  } else if (legado.scopeTitle) {
+    scope = 'title'
+  }
+  return {
+    id: legado.id ?? 0,
+    name: legado.name ?? '',
+    group: legado.group,
+    pattern: legado.pattern ?? '',
+    replacement: legado.replacement ?? '',
+    scope,
+    isEnabled: legado.isEnabled ?? true,
+    isRegex: legado.isRegex ?? false,
+    order: legado.order ?? 0,
+  }
+}
+
+function convertRssSource(legado: LegadoRssSource): RssSource {
+  return {
+    sourceUrl: legado.sourceUrl ?? '',
+    sourceName: legado.sourceName ?? '',
+    sourceIcon: legado.sourceIcon,
+    sourceGroup: legado.sourceGroup,
+    sourceComment: legado.sourceComment,
+    enabled: legado.enabled ?? true,
+    enabledCookieJar: legado.enabledCookieJar,
+    concurrentRate: legado.concurrentRate,
+    header: legado.header,
+    loginUrl: legado.loginUrl,
+    loginCheckJs: legado.loginCheckJs,
+    sortUrl: legado.sortUrl,
+    singleUrl: legado.singleUrl,
+    articleStyle: legado.articleStyle,
+    ruleArticles: legado.ruleArticles,
+    ruleNextPage: legado.ruleNextPage,
+    ruleTitle: legado.ruleTitle,
+    rulePubDate: legado.rulePubDate,
+    ruleDescription: legado.ruleDescription,
+    ruleImage: legado.ruleImage,
+    ruleLink: legado.ruleLink,
+    ruleContent: legado.ruleContent,
+    style: legado.style,
+    enableJs: legado.enableJs,
+    loadWithBaseUrl: legado.loadWithBaseUrl,
+    customOrder: legado.customOrder,
+    lastUpdateTime: legado.lastUpdateTime,
+  }
+}
+
+// ─── Safe JSON parsing helpers ───
+
+function parseJsonArray<T>(text: string, filename: string): T[] {
+  try {
+    const parsed = JSON.parse(text)
+    if (!Array.isArray(parsed)) {
+      console.warn(`[legadoImport] ${filename} is not an array, skipping`)
+      return []
+    }
+    return parsed as T[]
+  } catch (err) {
+    console.warn(`[legadoImport] Failed to parse ${filename}:`, err)
+    return []
+  }
+}
+
+// ─── Public API ───
+
+/**
+ * Parse a Legado backup ZIP file (as Blob, ArrayBuffer, or File) and
+ * return converted data ready to import into reader-next.
+ */
+export async function parseLegadoBackupZip(
+  source: Blob | ArrayBuffer | File,
+): Promise<LegadoImportResult> {
+  const zip = await JSZip.loadAsync(source)
+  return parseLegadoBackupZipFromZip(zip)
+}
+
+/**
+ * Internal: parse from an already-loaded JSZip instance.
+ */
+async function parseLegadoBackupZipFromZip(
+  zip: JSZip,
+): Promise<LegadoImportResult> {
+  // Helper to read a file from the zip
+  async function readZipFile(name: string): Promise<string | null> {
+    const file = zip.file(name)
+    if (!file) return null
+    return file.async('text')
+  }
+
+  // Parse each known file
+  const [
+    bookshelfText,
+    bookSourcesText,
+    bookGroupsText,
+    bookmarksText,
+    replaceRulesText,
+    rssSourcesText,
+  ] = await Promise.all([
+    readZipFile('bookshelf.json'),
+    readZipFile('bookSource.json'),
+    readZipFile('bookGroup.json'),
+    readZipFile('bookmark.json'),
+    readZipFile('replaceRule.json'),
+    readZipFile('rssSources.json'),
+  ])
+
+  // Convert books (filter out unusable URLs)
+  const rawBooks = bookshelfText
+    ? parseJsonArray<LegadoBook>(bookshelfText, 'bookshelf.json')
+    : []
+  const usableBooks: Book[] = []
+  let skippedBooks = 0
+  let incompleteBooks = 0
+  for (const raw of rawBooks) {
+    if (isUsableBookUrl(raw.bookUrl)) {
+      usableBooks.push(convertBook(raw))
+    } else if (raw.bookUrl && raw.bookUrl.startsWith('data:')) {
+      const decoded = decodeDataUriBook(raw)
+      if (decoded) {
+        usableBooks.push(decoded)
+        incompleteBooks++
+      } else {
+        skippedBooks++
+      }
+    } else {
+      skippedBooks++
+    }
+  }
+  // Sort by reading progress descending — furthest read first, then by last read time
+  usableBooks.sort((a, b) => {
+    const aIdx = a.durChapterIndex ?? 0
+    const bIdx = b.durChapterIndex ?? 0
+    if (bIdx !== aIdx) return bIdx - aIdx
+    const aPos = a.durChapterPos ?? 0
+    const bPos = b.durChapterPos ?? 0
+    if (bPos !== aPos) return bPos - aPos
+    return (b.durChapterTime ?? 0) - (a.durChapterTime ?? 0)
+  })
+
+  // Convert book sources
+  const rawSources = bookSourcesText
+    ? parseJsonArray<LegadoBookSource>(bookSourcesText, 'bookSource.json')
+    : []
+  const bookSources = rawSources.map(convertBookSource)
+
+  // Convert book groups
+  const rawGroups = bookGroupsText
+    ? parseJsonArray<LegadoBookGroup>(bookGroupsText, 'bookGroup.json')
+    : []
+  const bookGroups = rawGroups.map(convertBookGroup)
+
+  // Convert bookmarks
+  const rawBookmarks = bookmarksText
+    ? parseJsonArray<LegadoBookmark>(bookmarksText, 'bookmark.json')
+    : []
+  const bookmarks = rawBookmarks.map(convertBookmark)
+
+  // Convert replace rules
+  const rawRules = replaceRulesText
+    ? parseJsonArray<LegadoReplaceRule>(replaceRulesText, 'replaceRule.json')
+    : []
+  const replaceRules = rawRules.map(convertReplaceRule)
+
+  // Convert RSS sources
+  const rawRss = rssSourcesText
+    ? parseJsonArray<LegadoRssSource>(rssSourcesText, 'rssSources.json')
+    : []
+  const rssSources = rawRss.map(convertRssSource)
+
+  return {
+    books: usableBooks,
+    skippedBooks,
+    incompleteBooks,
+    bookSources,
+    bookGroups,
+    bookmarks,
+    replaceRules,
+    rssSources,
+  }
+}
+
+/**
+ * Quick validation: check if a ZIP file looks like a Legado backup
+ * by looking for known filenames.
+ */
+export async function isLegadoBackupZip(source: Blob | ArrayBuffer | File): Promise<boolean> {
+  try {
+    const zip = await JSZip.loadAsync(source)
+    // A Legado backup must contain at least bookshelf.json or bookSource.json
+    return !!zip.file('bookshelf.json') || !!zip.file('bookSource.json')
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Parse a Legado backup ZIP and return null if it's not a valid Legado backup.
+ * Combines validation + parsing in a single zip load to avoid double-reads.
+ */
+export async function tryParseLegadoBackupZip(
+  source: Blob | ArrayBuffer | File,
+): Promise<LegadoImportResult | null> {
+  try {
+    const zip = await JSZip.loadAsync(source)
+    if (!zip.file('bookshelf.json') && !zip.file('bookSource.json')) {
+      return null
+    }
+    return await parseLegadoBackupZipFromZip(zip)
+  } catch {
+    return null
+  }
+}
diff --git a/frontend/src/utils/webdavSync.ts b/frontend/src/utils/webdavSync.ts
new file mode 100644
index 0000000..3909717
--- /dev/null
+++ b/frontend/src/utils/webdavSync.ts
@@ -0,0 +1,199 @@
+/**
+ * Legado-compatible reading progress sync via WebDAV.
+ *
+ * Legado stores per-book progress as JSON files under:
+ *   /legado/bookProgress/{bookName}_{author}.json
+ *
+ * This module reads those files, merges with the local bookshelf
+ * (chapter index > position wins), and writes progress back after reading.
+ */
+import {
+  getWebdavFileList,
+  getWebdavFileText,
+  uploadTextToWebdav,
+} from '../api/webdav'
+import { saveBooks } from '../api/bookshelf'
+import type { Book } from '../types'
+
+const PROGRESS_DIR = '/legado/bookProgress'
+
+interface LegadoProgress {
+  name: string
+  author: string
+  durChapterIndex: number
+  durChapterPos: number
+  durChapterTime: number
+  durChapterTitle?: string
+}
+
+/**
+ * Build a Legado-compatible filename from book name and author.
+ * Matches the pattern: {name}_{author}.json
+ */
+function buildProgressFilename(name: string, author: string): string {
+  const safe = (s: string) => s.replace(/[/\\:*?"<>|]/g, '_').trim()
+  const n = safe(name || '未知')
+  const a = safe(author || '未知')
+  return `${n}_${a}.json`
+}
+
+/**
+ * Parse a Legado progress JSON file content.
+ */
+function parseProgressJson(raw: string): LegadoProgress | null {
+  try {
+    const data = JSON.parse(raw)
+    if (typeof data.name === 'string' && typeof data.durChapterIndex === 'number') {
+      return data as LegadoProgress
+    }
+    return null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Pull reading progress from WebDAV bookProgress/ and merge into bookshelf.
+ * For each remote progress entry, if the remote chapter index (then position)
+ * is ahead of the local book's, update the local book's progress.
+ *
+ * Returns the number of books updated.
+ */
+export async function syncProgressFromWebdav(books: Book[]): Promise<{
+  updated: number
+  books: Book[]
+}> {
+  // List files in the progress directory
+  let entries
+  try {
+    entries = await getWebdavFileList(PROGRESS_DIR)
+  } catch {
+    // Directory doesn't exist yet — no remote progress to sync
+    return { updated: 0, books }
+  }
+
+  const jsonEntries = entries.filter(
+    (e) => !e.isDirectory && e.name.endsWith('.json'),
+  )
+  if (jsonEntries.length === 0) {
+    return { updated: 0, books }
+  }
+
+  // Read all progress files
+  const remoteProgressList: LegadoProgress[] = []
+  await Promise.all(
+    jsonEntries.map(async (entry) => {
+      try {
+        const raw = await getWebdavFileText(entry.path)
+        const progress = parseProgressJson(raw)
+        if (progress) {
+          remoteProgressList.push(progress)
+        }
+      } catch {
+        // Skip unreadable files
+      }
+    }),
+  )
+
+  if (remoteProgressList.length === 0) {
+    return { updated: 0, books }
+  }
+
+  // Build lookup: "name|author" → remote progress
+  const remoteMap = new Map<string, LegadoProgress>()
+  for (const p of remoteProgressList) {
+    const key = `${p.name}|${p.author}`
+    const existing = remoteMap.get(key)
+    // Keep the newer one if duplicates
+    const pIdx = p.durChapterIndex ?? 0
+    const eIdx = existing?.durChapterIndex ?? 0
+    const pPos = p.durChapterPos ?? 0
+    const ePos = existing?.durChapterPos ?? 0
+    if (!existing || pIdx > eIdx || (pIdx === eIdx && pPos > ePos)) {
+      remoteMap.set(key, p)
+    }
+  }
+
+  // Merge: update local books where remote is newer
+  let updated = 0
+  const updatedBooks = books.map((book) => {
+    const key = `${book.name}|${book.author}`
+    const remote = remoteMap.get(key)
+    if (!remote) return book
+
+    // Remote has more progress — update local book
+    // Compare by chapter index first, then position within chapter
+    const localIndex = book.durChapterIndex ?? 0
+    const remoteIndex = remote.durChapterIndex ?? 0
+    const localPos = book.durChapterPos ?? 0
+    const remotePos = remote.durChapterPos ?? 0
+
+    const remoteIsNewer = remoteIndex > localIndex
+      || (remoteIndex === localIndex && remotePos > localPos)
+
+    if (remoteIsNewer) {
+      updated++
+      return {
+        ...book,
+        durChapterIndex: remote.durChapterIndex,
+        durChapterPos: remote.durChapterPos,
+        durChapterTime: remote.durChapterTime,
+        durChapterTitle: remote.durChapterTitle ?? book.durChapterTitle,
+      }
+    }
+    return book
+  })
+
+  // Persist updated books to server
+  if (updated > 0) {
+    // Only save books that actually changed
+    const changed = updatedBooks.filter((book, i) => book !== books[i])
+    if (changed.length > 0) {
+      await saveBooks(changed)
+    }
+  }
+
+  return { updated, books: updatedBooks }
+}
+
+/**
+ * Write a single book's reading progress to WebDAV in Legado format.
+ * Call this after the user finishes a reading session.
+ */
+export async function writeProgressToWebdav(book: Book): Promise<void> {
+  if (!book.name) return
+
+  const progress: LegadoProgress = {
+    name: book.name,
+    author: book.author || '',
+    durChapterIndex: book.durChapterIndex ?? 0,
+    durChapterPos: book.durChapterPos ?? 0,
+    durChapterTime: book.durChapterTime ?? Date.now(),
+    durChapterTitle: book.durChapterTitle,
+  }
+
+  const filename = buildProgressFilename(book.name, book.author || '')
+  const content = JSON.stringify(progress, null, 2)
+
+  try {
+    await uploadTextToWebdav(content, filename, PROGRESS_DIR)
+  } catch (err) {
+    console.warn('[webdavSync] Failed to write progress:', err)
+  }
+}
+
+/**
+ * Push all books' current progress to WebDAV.
+ * Useful for initial sync or after bulk import.
+ */
+export async function writeAllProgressToWebdav(books: Book[]): Promise<number> {
+  let written = 0
+  // Write sequentially to avoid overwhelming the server
+  for (const book of books) {
+    if (book.durChapterIndex && book.durChapterIndex > 0) {
+      await writeProgressToWebdav(book)
+      written++
+    }
+  }
+  return written
+}

From 6781e1cf3f311982caafb397450e6a2957f23774 Mon Sep 17 00:00:00 2001
From: aimercat1994 <aimercat1994@users.noreply.github.com>
Date: Tue, 7 Jul 2026 10:52:09 +0800
Subject: [PATCH 2/2] fix: filter empty bookUrl on import, sort by last read
 time

- Filter out data: URI decoded books with empty bookUrl to prevent
  'bookUrl required' error from saveBooks API
- Revert import sort to use durChapterTime (last read time) instead
  of chapter index, which is more meaningful for shelf display order
- Update tests to match new sort behavior
---
 frontend/src/components/WebdavManager.vue |  6 ++++--
 frontend/src/utils/legadoImport.test.ts   | 14 +++++++-------
 frontend/src/utils/legadoImport.ts        | 12 ++----------
 3 files changed, 13 insertions(+), 19 deletions(-)

diff --git a/frontend/src/components/WebdavManager.vue b/frontend/src/components/WebdavManager.vue
index 98cd23d..7c01f73 100644
--- a/frontend/src/components/WebdavManager.vue
+++ b/frontend/src/components/WebdavManager.vue
@@ -546,8 +546,10 @@ async function applyLegadoImport() {
     for (const group of data.bookGroups) {
       try { await saveBookGroup(group) } catch (e) { errors.push(`分组 ${group.groupName}: ${(e as Error).message}`) }
     }
-    if (data.books.length) {
-      try { await saveBooks(data.books) } catch (e) { errors.push(`书籍: ${(e as Error).message}`) }
+    // Filter out books with empty bookUrl (data: URI decoded books)
+    const validBooks = data.books.filter((b) => !!b.bookUrl)
+    if (validBooks.length) {
+      try { await saveBooks(validBooks) } catch (e) { errors.push(`书籍: ${(e as Error).message}`) }
     }
     if (data.bookmarks.length) {
       try { await saveBookmarks(data.bookmarks) } catch (e) { errors.push(`书签: ${(e as Error).message}`) }
diff --git a/frontend/src/utils/legadoImport.test.ts b/frontend/src/utils/legadoImport.test.ts
index 4e0eff1..f0e2a0d 100644
--- a/frontend/src/utils/legadoImport.test.ts
+++ b/frontend/src/utils/legadoImport.test.ts
@@ -205,18 +205,18 @@ describe('parseLegadoBackupZip', () => {
     expect(result.replaceRules[3].scope).toBeUndefined()
   })
 
-  it('sorts books by reading progress descending', async () => {
+  it('sorts books by last read time descending', async () => {
     const blob = await createTestZip({
       'bookshelf.json': [
-        { ...sampleLegadoBook, name: '旧书', durChapterIndex: 10, durChapterPos: 0, durChapterTime: 1700000000000 },
-        { ...sampleLegadoBook, name: '新书', durChapterIndex: 100, durChapterPos: 500, durChapterTime: 1700100000000 },
-        { ...sampleLegadoBook, name: '中间', durChapterIndex: 50, durChapterPos: 0, durChapterTime: 1700050000000 },
+        { ...sampleLegadoBook, name: '旧书', durChapterIndex: 100, durChapterTime: 1700000000000 },
+        { ...sampleLegadoBook, name: '新书', durChapterIndex: 10, durChapterTime: 1700100000000 },
+        { ...sampleLegadoBook, name: '中间', durChapterIndex: 50, durChapterTime: 1700050000000 },
       ],
     })
     const result = await parseLegadoBackupZip(blob)
-    expect(result.books[0].name).toBe('新书')   // chapter 100
-    expect(result.books[1].name).toBe('中间')   // chapter 50
-    expect(result.books[2].name).toBe('旧书')   // chapter 10
+    expect(result.books[0].name).toBe('新书')   // most recent time
+    expect(result.books[1].name).toBe('中间')
+    expect(result.books[2].name).toBe('旧书')   // oldest time
   })
 
   it('maps Legado book fields to reader-next format', async () => {
diff --git a/frontend/src/utils/legadoImport.ts b/frontend/src/utils/legadoImport.ts
index e29e48e..fe2925b 100644
--- a/frontend/src/utils/legadoImport.ts
+++ b/frontend/src/utils/legadoImport.ts
@@ -396,16 +396,8 @@ async function parseLegadoBackupZipFromZip(
       skippedBooks++
     }
   }
-  // Sort by reading progress descending — furthest read first, then by last read time
-  usableBooks.sort((a, b) => {
-    const aIdx = a.durChapterIndex ?? 0
-    const bIdx = b.durChapterIndex ?? 0
-    if (bIdx !== aIdx) return bIdx - aIdx
-    const aPos = a.durChapterPos ?? 0
-    const bPos = b.durChapterPos ?? 0
-    if (bPos !== aPos) return bPos - aPos
-    return (b.durChapterTime ?? 0) - (a.durChapterTime ?? 0)
-  })
+  // Sort by last read time descending — most recently read first
+  usableBooks.sort((a, b) => (b.durChapterTime ?? 0) - (a.durChapterTime ?? 0))
 
   // Convert book sources
   const rawSources = bookSourcesText