forked from akai/readest
febb0d9a6921a0c2ee5c3d291f42cdf65b7ef9d8
7 Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
 Huang Xin
|
febb0d9a69 |
fix(backup): normalize Windows backslash paths in backup zip entries (#4706)
A backup .zip exported on Windows failed to restore on every platform
(Web, Android, Windows): books restored with metadata but no files or
covers.
`appService.readDirectory` returns paths using the host separator, so on
Windows `file.path` is `hash\cover.png` (backslash). `addBackupEntriesToZip`
used that verbatim as the zip entry name, so entries were named with `\`.
Restore matches a book's files with `filename.startsWith(`${hash}/`)`
(forward slash), which never matched the backslash names, so every book
file was silently skipped.
Normalize the zip entry name to forward slashes when adding files. Entry
names are now cross-platform and restorable everywhere. Already-exported
broken backups need re-exporting from the fixed app.
Fixes #4703
Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
|
||
|
loveheaven
|
ff605e000d |
feat(library): in-place import from registered external folders (#4315)
* feat(library): in-place import with cloud sync and symmetric local delete
Adds an `inPlace` option to importBook so a source file inside a
registered external library folder is referenced directly via
`book.filePath` instead of being copied into Books/<hash>/. Sidecars
(cover, config, nav) still live under Books/<hash>/.
ingestService routes through shouldImportInPlace, which marks an
import in-place when the absolute source path lives under any of
`settings.externalLibraryFolders` and is NOT inside a per-root
`Books/` subtree. The Readest data dir (`customRootDir`) is
intentionally excluded — that directory is Readest's home and
should freely hold hash copies; in-place is for user-registered
roots (Duokan, Calibre, Moon+ Reader, an iCloud mirror, …).
Cloud sync treats in-place books as first-class:
- uploadBook reads bytes from (book.filePath, 'None') when set.
The cloud key is unchanged, so a peer downloading the book
lands it under Books/<hash>/ as a normal hash copy.
- useBooksSync strips `book.filePath` before pushing — it is a
device-local path that is meaningless on any other device.
- ingestService no longer skips upload for in-place books;
autoUpload / forceUpload behave like any other book. Only
transient imports opt out.
- deleteBook 'local'/'both' now physically removes the source
file at book.filePath (base 'None'). Local-delete semantics
are symmetric with hash-copy books: the local copy is gone,
the cloud backup remains, a future pull restores under
Books/<hash>/. removeFile errors are swallowed.
New `SystemSettings.externalLibraryFolders?: string[]` (no UI yet;
registration entrypoint lands in a follow-up). Added to
BACKUP_SETTINGS_BLACKLIST alongside `localBooksDir` /
`customRootDir` so device-local paths don't ride cloud backups.
Tests: cloud-service, ingest-service, and backup-settings suites
cover in-place delete, multi-root matching, per-root `Books/`
guard, and the backup-strip.
* feat(library): one-tap "read in place" toggle in folder import
Surface the in-place / copy choice as a single "Read books in place (don't copy)" checkbox in the Import-from-Folder dialog. When the user opts in, the chosen directory is registered in `settings.externalLibraryFolders` and ingestService's `shouldImportInPlace` will route the books straight to importBook with `inPlace: true` — no copy into Books/<hash>/, sync still works, local delete still removes the source file (the symmetry was set up in the previous in-place commit).
User experience:
- First-time users hit the toggle once per library folder. The choice is also persisted to localStorage so subsequent dialog opens default to whatever they picked last.
- Repeat imports from a folder that's already registered as an external library folder force the toggle ON and disable it, with a help line explaining that imports from this folder are always in-place. The check is exact-string (after path normalization) so registering /Users/me/Duokan only locks the toggle for that exact path — picking /Users/me/Downloads after Duokan still shows the toggle in its normal state.
- URL-ingress / drag-drop replays go through `runFolderImport` without the dialog and default `readInPlace: false`. They still benefit from in-place automatically when the dropped path lives under an already-registered root, because that decision is made by `shouldImportInPlace` based on settings, not by the dialog flag.
Mechanics:
- ImportFromFolderResult gains `readInPlace: boolean`. ImportFromFolderDialog gains an `initialReadInPlace` prop (seeded from the new `readest:lastImportFolderReadInPlace` localStorage key) and an `isRegisteredExternalRoot` predicate it uses to render the locked / unlocked toggle.
- runFolderImport calls a new `registerExternalLibraryFolder` helper that appends the chosen directory to `settings.externalLibraryFolders` and persists settings, but only when `result.readInPlace` is true. `isRegisteredExternalRoot` does the inverse lookup the dialog needs. Both helpers normalize paths the same way `shouldImportInPlace` does so the predicate matches the ingest layer.
- The new feature has no effect for users who never flip the toggle: `externalLibraryFolders` stays empty, the path-prefix check in `shouldImportInPlace` returns false for every import, and books continue to be copied into Books/<hash>/ exactly as before.
Self-healing for externally-removed in-place books:
Once the dialog lets users opt their library into in-place mode, the source file becomes a piece of state Readest doesn't control — another app may rewrite it (e.g. Duokan persisting reading progress into the epub), the user may move it in Finder, or an external drive may unmount between sessions. Previously, clicking such a book would navigate into the reader, fail inside loadBookContent's `fs.openFile(book.filePath, 'None')` with a low-level IO error, flash an "Unable to open book" toast, and auto-bounce back to the library — leaving the stale library record in place so the next tap reproduces the same dance.
BookshelfItem.handleBookClick now probes availability before navigating, but only for purely-local in-place books (`book.filePath && !book.uploadedAt && !book.deletedAt`). If `appService.isBookAvailable` returns false — which for in-place books means the recorded `book.filePath` no longer exists at the OS level — we dispatch `delete-books` for that hash and show an info toast explaining the removal, instead of opening the reader.
Scope is intentionally narrow:
- Cloud-synced books still flow through `makeBookAvailable`'s on-demand download path; missing local copies trigger a re-download, not a deletion.
- Hash-copy books (no `filePath` set) are not probed: a missing Books/<hash>/ file under normal use signals a bug or filesystem corruption, not user intent, and silently dropping the record would hide the real problem.
- The dispatched delete-books event reuses the existing Bookshelf deletion path, so sidecar metadata and selection state are cleaned up the same way as a user-initiated delete. For in-place books that path doesn't touch any file outside Books/<hash>/, so the now-missing source location (or whatever the user did with it externally) is left alone — symmetric with 165f15a6.
* fix(library): centralize book content resolution
---------
Co-authored-by: Huang Xin <chrox.huang@gmail.com>
|
||
|
loveheaven
|
98049282eb |
feat(ai): add OpenRouter provider and unify provider HTTP transport (#4289)
* OpenRouter: new OpenAI-compatible provider with chat + embedding model routing, health check via /models, and a fetchOpenRouterModels() helper for the settings UI. API key, base URL and model fields are persisted in AISettings, surfaced in AIPanel, indexed by commandRegistry, and added to backupService's credential allow-list so the key round-trips through encrypted backups. * utils/httpFetch: introduce getAIFetch() as the single decision point for outbound AI traffic. In Tauri it returns @tauri-apps/plugin-http's fetch (Rust/reqwest transport, no renderer CORS preflight, no Android cleartext block); on the web build it falls back to window.fetch. OllamaProvider is migrated end-to-end — both ai-sdk-ollama streaming and the /api/tags health probe — and the new OpenRouterProvider uses the same path, so any future provider only has to call getAIFetch(). * Tests: unit tests for OpenRouter provider behavior (model selection, availability, health check) and a backup-settings round-trip test ensuring openrouterApiKey is treated as a credential field. |
||
|
Huang Xin
|
52f9634810 |
feat(backup): include global settings in backup zip (#4211)
* feat(backup): include global settings in backup zip Backup zips previously held only book files and library.json. Issue #4098 asks for app configuration to be backed up too. A `settings.json` snapshot is now written at the zip root. Restore deep-merges it onto the current device's settings, so fields the snapshot omits keep their current values. `sanitizeSettingsForBackup` strips, via a blacklist, fields that are device-specific or sync/migration bookkeeping (filesystem paths, replica/kosync device ids, sync cursors, lastOpenBooks, screen brightness, schema versions). Account credentials (kosync/Readwise/ Hardcover tokens, AI gateway key, OPDS catalog logins) are stripped unless the user opts in via a new "Include account credentials" checkbox in the Backup & Restore dialog — the zip is unencrypted. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix(backup): keep revived books visible after a cloud-synced restore When the library is deleted (soft delete) and the deletion has synced to the cloud, restoring an older backup un-deletes the books locally — but the next sync's last-writer-wins merge re-applied the cloud's deletion tombstone, so the restored books vanished again. The deletion never bumps `updatedAt`, so a restored book and its cloud tombstone share the same timestamp; `processOldBook` breaks the tie toward the cloud. `reviveRestoredBooks` now fixes up books that were soft-deleted locally but present in the backup: - Bumps `updatedAt` so the restore out-ranks the cloud tombstone. A single uniform offset is applied to every revived book, so their relative order — and the library's "Updated" sort — is preserved exactly; the newest maps to now, none land in the future. - Clears `syncedAt` so the next push re-uploads them and corrects the cloud rows. - Restores `downloadedAt` / `coverDownloadedAt` from the backup record (the local deletion had cleared them) so revived books are not shown as not-downloaded even though their files were re-extracted. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com> |
||
|
Huang Xin
|
0fba5b7054 | feat(config): version book config schema (#4208) | ||
|
Lex Moulton
|
030a7c0823 |
perf: optimize library operations for large collections (#3827)
* perf(store): decouple page turn from full library rewrite for large collections Previously every page turn triggered setLibrary() which copied the entire library array, ran refreshGroups() with MD5 hashing over all books, and caused cascading re-renders. With ~2800 books this made reading unusable. - Add hash-indexed Map to libraryStore for O(1) book lookups - Add lightweight updateBookProgress() that skips array copy and refreshGroups - Use hash index in setProgress, saveConfig, and initViewState - Batch cover URL generation with concurrency limit on library load Addresses #3714 * perf(import): replace filter()[0] with find() to short-circuit on first match * fix(store): replace Object.assign state mutation with immutable spread in setConfig * perf(persistence): remove JSON pretty-printing to reduce serialization overhead * fix(reader): stabilize debounce reference in useIframeEvents to prevent timer reset on re-render * perf(context): memoize provider values to prevent unnecessary consumer re-renders * perf(store): cache visible library to avoid refiltering on every access * perf(library): remove redundant refreshGroups call already triggered by setLibrary * perf(import): replace O(n) splice(0,0) with O(1) push for new book insertion * perf(import): defer library persistence to end of import batch instead of every 4 books * perf(library): skip full library reload on reader close since store is already in sync * fix: address PR review feedback for library perf optimizations Correctness fixes for issues found in code review: - fix(library): restore library reload on close-reader-window. Reader windows are independent Tauri webviews with their own libraryStore instance, so progress / readingStatus / move-to-front updates from the reader do not propagate to the main window. Reload from disk so the library reflects the changes the reader just persisted. - perf(import): wire BookLookupIndex into importBooks. The lookupIndex parameter on bookService.importBook had no caller, leaving the Map-based dedup path dead. Build the index once per import batch in app/library/page.tsx and thread it through appService.importBook so the O(1) dedup path is actually exercised. - perf(import): defer library save to end of batch. Add a skipSave option to libraryStore.updateBooks and call appService.saveLibraryBooks once after the entire import loop, instead of once per concurrency-4 sub-batch. - fix(store): make updateBookProgress immutable. The previous in-place mutation reused the same library array reference, bypassing Zustand change detection AND leaving the visibleLibrary cache holding stale Book references. Now slice the array, update the entry, and refresh visibleLibrary. Also make readingStatus a required parameter so future callers cannot accidentally clear it by omitting the argument. - fix(store): make saveConfig immutable. It previously mutated the Book object's progress / timestamps in place and used splice/unshift on the shared library array. Now spread to a new book object and rebuild via setLibrary. Also corrects the interface signature to return Promise<void> (the implementation was already async). - fix(store): make updateBook immutable for the same reason — it was mutating the previous-state library array before spreading. - fix(context): wrap AuthContext login/logout/refresh in useCallback. Without this, the useMemo deps array changed every render and the memo was a no-op, defeating the optimization the PR was trying to add. - fix(reader): use a ref for handlePageFlip in useMouseEvent's debounce. The empty-deps useMemo froze the first-render handler; with the ref the debounced wrapper always invokes the latest closure. Test coverage added: - library-store: immutable updateBookProgress, visibleLibrary cache refresh, deleted-book filtering, updateBooks skipSave option - book-data-store: immutable saveConfig, move-to-front correctness, visibleLibrary order, persistence behavior - import-metahash: BookLookupIndex update on new import, lookup-index consultation before scanning books array - auth-context (new file): context value identity stability across re-renders, callback identity stability - useIframeEvents (new file): debounced wheel handler dispatches to the latest handlePageFlip after re-render Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * refactor(types): move BookLookupIndex to types/book.ts Avoids the inline `import('@/services/bookService').BookLookupIndex` type annotation in types/system.ts. Both the AppService interface and the bookService implementation now import BookLookupIndex from the canonical location alongside Book. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> * refactor(import): convert importBook params to options object Replace the long positional-argument list on appService.importBook (saveBook, saveCover, overwrite, transient, lookupIndex) with a single options object so callers no longer need to pad with `undefined, undefined, undefined, undefined` to reach the parameter they actually want to set. Before: await appService.importBook(file, library, undefined, undefined, undefined, undefined, lookupIndex); After: await appService.importBook(file, library, { lookupIndex }); The underlying bookService.importBook is also refactored to take an options object: required AppService callbacks (saveBookConfig, generateCoverImageUrl) are bundled with the optional flags via an ImportBookInternalOptions interface that extends the public ImportBookOptions defined in types/book.ts. All existing call sites updated to the new shape. Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Huang Xin <chrox.huang@gmail.com> Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com> |
||
|
Huang Xin
|
91bc4ddec7 | feat(library): backup to and restore from a zip file (#3571) |