Skip to content
CAI
Software that uses CAICheck a score

gotson/komga

50.7

Adequate · 22 October 2026

101.1k

lines of production code

TypeScript

with Kotlin

9

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

This system is a self-hosted media server designed for organizing and reading digital comics and ebooks. It provides a backend that ingests, analyzes, and manages libraries of books and series, supporting various formats and metadata sources. The system exposes this content through multiple interfaces, including a modern web UI, a desktop tray application, and standard protocols like OPDS and Kobo Sync for integration with external readers.

How it got here

2019–2021 — Architecture overhaul and web UI rewrite

72 changes.

The project underwent a significant architectural transformation, migrating the database engine from H2 to SQLite and replacing the Hibernate persistence layer with jOOQ to enable advanced search and performance tuning. Concurrently, the legacy web interface was completely replaced by a new Vue.js-based frontend featuring a modern reader, PWA support, and real-time updates via Server-Sent Events. This period also established a robust domain-driven backend with comprehensive metadata import capabilities, API key authentication, and extensive test coverage.

2022–2026 — Next UI migration and sync expansion

117 changes.

This period focused on the development and beta release of the new Vue-based Next UI, replacing the legacy frontend with a modern architecture. Concurrently, the backend expanded its ecosystem support by implementing Kobo and KOReader synchronization protocols, while also introducing OPDS v2 standards and robust content restriction enforcement.

Features

API key authentication without session creation

Added an API key authentication mechanism that allows requests to be authenticated via an API key (passed in a header or extracted from the URI) without creating an HTTP session. This is implemented through a new \ApiKeyAuthenticationFilter\ and supporting components (\ApiKeyAuthenticationProvider\, \ApiKeyAuthenticationToken\, \ApiKeyGenerator\, and converters) in the security infrastructure, ensuring that API key requests bypass session management to avoid unnecessary session registry entries.

komga/src/main/kotlin/org/gotson/komga/infrastructure/security/apikey · high confidence

Add ComicRack metadata DTOs for importing ComicInfo.xml and reading lists

New data-transfer objects (AgeRating, Book, ComicInfo, Manga, ReadingList, YesNo) have been added to the ComicRack metadata infrastructure to support parsing ComicInfo.xml files and ComicRack reading lists. These DTOs enable the import of additional metadata fields such as translator, tags, story arc number, GTIN (as ISBN), and age ratings, as well as the creation of read lists from ComicRack list structures.

komga/src/main/kotlin/org/gotson/komga/infrastructure/metadata/comicrack/dto · high confidence

Add EPUB metadata import for books and series

Komga now supports importing metadata from EPUB files. The new EpubMetadataProvider extracts book-level details such as title, description, release date, ISBN, and authors (including roles like translator, colorist, and penciller via MARC relators). It also retrieves series-level information including the series title, publisher, language, genres, and reading direction. Library settings control whether EPUB book and series metadata are imported independently.

komga/src/main/kotlin/org/gotson/komga/infrastructure/metadata/epub · high confidence

Add KOReader Sync API support

This change introduces a new REST API controller at \/koreader\ that enables synchronization of reading progress between Komga and the KOReader application. The implementation handles user authentication, retrieves current reading progress for books (supporting PDF, CBZ, and EPUB formats with specific location parsing for EPUBs), and updates progress back to Komga. It includes DTOs for document progress and user authentication, allowing KOReader clients to sync their state with the library.

komga/src/main/kotlin/org/gotson/komga/interfaces/api/kosync · high confidence

Add Kobo Sync support with on-the-fly KEPUB conversion

This change introduces a new Kobo Sync infrastructure that allows Komga to act as a proxy for the Kobo store API, enabling Kobo devices and apps to sync reading progress and library data with Komga. It includes a KepubConverter component that uses the external 'kepubify' tool to convert EPUB books to KEPUB format on the fly, ensuring compatibility with Kobo devices. The KoboProxy component handles request forwarding, header management (including sync tokens), and error handling, while the KomgaSyncTokenGenerator manages the translation between Komga's internal sync tokens and the raw Kobo store tokens required for synchronization.

komga/src/main/kotlin/org/gotson/komga/infrastructure/kobo · high confidence

Add Mylar series.json DTOs for metadata import

Added Kotlin data classes (AgeRating, MylarMetadata, Series, Status) to parse Mylar's series.json metadata, including field aliases for compatibility with both 'cid' and 'comicId' identifiers and support for Mylar version 1.0.1 format changes.

komga/src/main/kotlin/org/gotson/komga/infrastructure/metadata/mylar/dto · high confidence

Add OPDS v2 API support with authentication and new data models

This change introduces the OPDS v2 interface, adding a new controller and associated DTOs for catalog browsing, search, and authentication flows (Basic, OAuth2 Implicit, OAuth2 Password). Users can now access their library via the OPDS v2 standard, with support for navigation, facets, and restricted content access enforced through the new authentication document structure.

komga/src/main/kotlin/org/gotson/komga/interfaces/api/opds/v2 · high confidence

Add PWA support and mobile web app capabilities

The web UI now supports Progressive Web App (PWA) features, allowing users to add the application to their home screen on mobile devices. This includes a new manifest.json file defining app metadata and icons, along with updated HTML meta tags for iOS and Android compatibility, proper favicon handling, and configuration for standalone display mode.

komga-webui/public · high confidence

Add Web Publication Manifest and OPDS 2.0 DTOs

The API now supports the Readium Web Publication Manifest and OPDS 2.0 standards by introducing new data transfer objects. This includes \WPPublicationDto\ and related classes to structure publication metadata, links, and resources according to the Web Publication specification, as well as constants for OPDS media types (JSON, Publication, Authentication) and link relations (search, cover, acquisition, auth). These changes enable clients like Aldiko and Cantook to consume standardized metadata and progression data.

komga/src/main/kotlin/org/gotson/komga/interfaces/api/dto · high confidence

Add book comparison UI components for import workflows

The \next-ui/src/components/book/compare\ directory now includes a suite of Vue components that enable side-by-side comparison of two books during the import process. The main \Compare\ component orchestrates three tabs: General (displaying metadata like filename, file size, and page count with 'more/less' indicators for upgrades), Pages (a table listing page-by-page details with clickable rows), and Visual (a side-by-side image viewer with synchronized page steppers). Supporting components include \Info\ for metadata rows, \Pages\ for the comparison table, \Visual\ for the image viewer, and \page/Stepper\ for page navigation controls. Storybook stories are provided for all components to facilitate development and testing.

next-ui/src/components/book/compare · high confidence

Add contextual navigation breadcrumbs

A new NavigationBreadcrumbs component has been added to the next-ui library, rendering a breadcrumb trail based on the current browsing context. It dynamically displays context-specific subtitles (Series, Read list, Collection, Library) and fetches metadata for items like series titles, collection names, and library views to ensure accurate, up-to-date labels in the navigation path.

next-ui/src/components/navigation · high confidence

Add duplicate page hash management tables

Introduces three new tables for managing duplicate pages: KnownTable for known duplicates with action toggles (Delete Auto, Delete Manual, Ignore), UnknownTable for unclassified duplicates with bulk selection and marking, and MatchTable for viewing specific matches of a duplicate hash. Includes Storybook stories and documentation for all three components.

next-ui/src/components/pageHash · high confidence

Add role button with custom role support

A new 'Add role' button component has been introduced in the metadata edition interface. It provides a dropdown menu listing available contributor roles, allowing users to select an existing role or open a dialog to define a custom role name. This enables users to assign new contributor roles to books, including those not predefined in the system.

next-ui/src/components/btn · high confidence

Add v-ktooltip directive for enhanced tooltip interactions

A new \v-ktooltip\ directive has been introduced in the \next-ui\ library, providing a Vue directive wrapper around the \KTooltip\ component. This allows developers to attach tooltips to elements using the \v-ktooltip\ syntax, supporting various binding modes such as simple text strings, object configurations for advanced options (like \scrim\ or \openOnClick\), and boolean toggles. The directive handles mounting, updating, and unmounting of the tooltip overlay, ensuring proper cleanup and integration with the application's app context.

next-ui/src/directives · high confidence

Added benchmark configuration resources

The benchmark module now includes specific configuration files to define its execution environment. The new \application-benchmark.yml\ sets up the application version, benchmark measurement parameters (iterations, warmup, mode), and points the database and Lucene data directories to a dedicated workspace folder. Additionally, \junit-platform.properties\ configures JUnit to use a per-class test instance lifecycle, which is typically used to optimize performance in benchmarking scenarios by reducing setup overhead.

komga/src/benchmark/resources · high confidence

Added caching layer for transient books

A new TransientBookCache service has been introduced in the infrastructure layer to cache transient book data. This implementation uses Caffeine with a one-hour access-based expiration to store and retrieve transient book entities, optimizing performance for lookups and saves of temporary book metadata.

komga/src/main/kotlin/org/gotson/komga/infrastructure/cache · high confidence

Added internationalization for the desktop tray menu and startup error dialogs

The Komga tray application now supports multiple languages for its system tray menu and startup error dialogs. New resource files (messages\\.properties) provide translations for menu actions such as opening the main interface, opening the NextUI interface, showing the configuration directory, viewing logs, and quitting the application. Additionally, error messages displayed when the application fails to start (e.g., port in use or unexpected errors) are now localized, improving the user experience for non-English speakers.

komga-tray/src/main/resources/org · high confidence

Added reactive fetch components for book and series details

New Details.vue components have been added for both books and series in the fetch directory. These components utilize @pinia/colada to fetch detail data and expose the results via a slot using reactive data, ensuring that changes to the underlying query data are automatically reflected in the UI.

next-ui/src/components/book/fetch, next-ui/src/components/series/fetch, next-ui/src/components/collection/fetch, next-ui/src/components/readlist/fetch · high confidence

Admin read list management actions

Admins can now edit and delete read lists directly from the action menu. The edit action opens a dialog that allows updating the read list's name, order, and summary, as well as managing posters (uploading new ones, selecting a primary poster, or deleting existing ones). The delete action triggers a confirmation dialog before removing the read list, with success or error notifications displayed via snackbar messages.

next-ui/src/composables/readlist · high confidence

Background tasks now support configurable concurrency and priority

The background task system has been refactored to allow users to configure the number of threads used for processing tasks, enabling faster parallel execution for operations like library scans, book analysis, and metadata refreshes. Tasks are now assigned explicit priority levels (e.g., HIGH, DEFAULT, LOW), ensuring that critical operations like imports or scans are processed before lower-priority background maintenance tasks. This change improves overall system responsiveness and allows users to tune performance based on their hardware capabilities.

komga/src/main/kotlin/org/gotson/komga/application/tasks · high confidence

Database-backed HTTP session storage for SQLite

Komga now supports storing HTTP sessions in the database instead of relying on in-memory storage. This change introduces a Flyway migration (V20261007135622) for SQLite that creates the \SPRING\_SESSION\ and \SPRING\_SESSION\_ATTRIBUTES\ tables, enabling persistent session management across application restarts or in clustered environments.

komga/src/flyway/resources/sessions · high confidence

Desktop tray menu and startup error dialog

The desktop application now includes a system tray icon with a menu that allows users to open the main Komga interface, open the NextUI interface, locate the log file, locate the configuration directory, and quit the application. Additionally, if the application fails to start, a detailed error dialog is displayed to the user, providing the error message and an optional stack trace that can be copied to the clipboard.

komga-tray/src/main/kotlin/org/gotson/komga/application · high confidence

First beta version of the new UI

This release introduces the first beta version of the new user interface, replacing the previous layout with a Vue 3 and Vuetify 3-based application. The new UI features a redesigned navigation drawer with links to libraries, import, history, and a link to the classic UI, alongside global composables for theme, authentication, and server-sent events. Key new capabilities include a detailed book view with tabs for general info, pages, and visual reading, a book comparison tool, and enhanced import workflows for books and read lists. The interface also supports editing books, series, collections, and read lists, managing library actions, and filtering content by various metadata fields.

next-ui/src, next-ui/src/components · high confidence

Generated OpenAPI client for Komga API integration

The application now includes an auto-generated HTTP client (via @hey-api/openapi-ts) in next-ui/src/generated, providing type-safe access to the Komga backend. This adds support for all API endpoints, including the new 'add to collection' and 'add to read list' actions, and enables features like Server-Sent Events (SSE) for streaming updates.

next-ui/src/generated · high confidence

ISBN barcode detection for books

Komga can now automatically detect and extract ISBNs from book pages by scanning barcodes. This new capability is provided by the IsbnBarcodeProvider, which analyzes specific pages of a book to find valid ISBN-13 barcodes and applies the found ISBN to the book's metadata. This feature is controlled by the library-level 'importBarcodeIsbn' setting, allowing users to enable or disable automatic ISBN extraction per library.

komga/src/main/kotlin/org/gotson/komga/infrastructure/metadata/barcode · high confidence

Import metadata and read lists from ComicRack (ComicInfo.xml and .cbl)

Komga now parses ComicInfo.xml files embedded in comic archives to populate book and series metadata, including authors, tags, ISBNs (from GTIN), web links, and reading direction. It also supports importing ComicRack .cbl read lists, matching series with or without volume numbers in brackets, and can append the ComicInfo volume to the series title if the library option is enabled.

komga/src/main/kotlin/org/gotson/komga/infrastructure/metadata/comicrack · high confidence

Import series metadata from Mylar series.json files

Komga now supports importing metadata for comic series from Mylar's series.json files. When enabled in library settings, the system reads series title, status, description, publisher, age rating, and total book count from these files, allowing users to leverage their existing Mylar metadata within Komga.

komga/src/main/kotlin/org/gotson/komga/infrastructure/metadata/mylar · high confidence

Initial Kobo Sync support

Komga now implements the Kobo Store API, allowing Kobo e-readers to sync with your library. This new \KoboController\ and its associated DTOs handle device authentication, library synchronization (including metadata, reading progress, and tags), and book downloads. The implementation supports on-the-fly conversion of books to KEPUB format for better rendering on Kobo devices and ensures that reading states and content restrictions are properly synchronized.

komga/src/main/kotlin/org/gotson/komga/interfaces/api/kobo · high confidence

Initial Storybook configuration for component development

The Storybook environment for next-ui has been established with a new configuration that supports internationalization (including RTL locales), theme switching between light and dark modes, and responsive viewport testing. The setup integrates Vuetify, Vue Router (using memory history to bypass auth guards), Pinia with Colada for data fetching, and MSW for mocking API responses, providing a complete isolated environment for developing and testing UI components.

next-ui/.storybook · high confidence

Initial WebUI plugin architecture and service wiring

The web interface now initializes via a structured plugin system in \komga-webui/src/plugins\. This includes an HTTP client plugin that automatically converts ISO date strings to JavaScript Date objects, a Vuetify theme plugin defining light and dark palettes, and a persisted state module that saves user preferences (such as reader settings, library filters, and theme) to local storage. Additionally, dedicated plugins wire up frontend services for core features including libraries, books, series, collections, read lists, users, OAuth2, and server metrics, making them available throughout the application.

komga-webui/src/plugins · high confidence

Initial beta release of the Next UI with new components, layouts, and pages

This change introduces the first beta version of the Next UI, adding a new set of Vue components, layouts, and pages. Key additions include the \ItemCardWide\ component for displaying entity cards with selection, progress, and action icons, along with \DeletionWarning\ components for both general entities and series-specific deletion confirmations. The UI now features \default\ and \single\ layouts to structure the application shell, and introduces several new pages under \/media\ for administration, including views for known/unknown duplicate pages and placeholders for analysis, duplicate files, and missing posters. Additionally, the update includes a new logging service (\logtape\) for console output and CSS layer definitions to manage styling precedence.

(repo-wide) · high confidence

Initial release of the Vue.js-based WebUI with translation support and Epub reader

The komga-webui module is introduced as a new Vue.js frontend, replacing previous implementations. This change adds support for user-facing translations (i18n) via Vue I18n configuration and includes a new Epub reader component. The frontend is configured to run on a development server at port 8081, connecting to the API at localhost:8080, and includes specific build rules to handle CSS resources for the Epub reader libraries (Readium and r2d2bc).

komga-webui · high confidence

Initial release of the Vue.js-based web UI

The web interface has been rewritten from scratch using Vue.js, Vuetify, and Vuex, replacing the previous implementation. This new frontend introduces a modern, responsive design with a sidebar navigation structure, replacing the old tab-based layout. Key user-facing capabilities include dynamic theme switching (supporting dark mode and system preference), multi-language support with specific pluralization rules (e.g., for Polish), and OAuth2 login integration. The UI now features a comprehensive settings dashboard for server administration, user management, and media analysis, along with improved library browsing, read list management, and a new web reader. Session handling has been updated to automatically log out users when sessions expire, and the application now supports running behind a base URL path.

komga-webui/src · high confidence

Initial setup of the new Vue-based Next UI

This change introduces the first beta version of the new Next UI, a Vue 3 frontend built with Vuetify, TypeScript, and Vite. It establishes the complete development environment, including ESLint and Prettier configurations, Storybook for component testing, and Vitest for unit and browser tests. The UI integrates with the backend via an auto-generated OpenAPI client (using @hey-api/openapi-ts) and Pinia Colada for state management, while handling internationalization through FormatJS and dynamic asset paths for server deployment.

next-ui · high confidence

Introduce Pinia-based state management for the new UI

The next-ui stores directory now uses Pinia to manage reactive application state, replacing the previous approach. This introduces dedicated stores for app settings (persisted via pinia-plugin-persistedstate), dialog handling, image cache busting, message notifications, selection management with route-aware clearing, and task queue tracking, providing a centralized and reactive foundation for the new UI components.

next-ui/src/stores · high confidence

Introduce ReadlistCard component with role-based actions

Added a new ReadlistCard component for displaying readlists, featuring role-based UI controls: the edit quick-action icon is visible only to admins, the menu icon (triggering a bottom sheet) appears for admins or users with the FILE\_DOWNLOAD role, and the play FAB opens the first book. The card also includes Storybook stories covering default, selected, hover, and non-admin states.

next-ui/src/components/readlist/card · high confidence

Introduce native EPUB parsing and extraction infrastructure

Added a new set of Kotlin classes in the EPUB infrastructure package to handle the parsing and extraction of EPUB files. This includes logic to read the OPF manifest, process navigation documents (both EPUB 2 NCX and EPUB 3 NAV), extract table of contents entries, and identify book covers and page resources. The implementation uses Jsoup for XML parsing and handles URL decoding and path normalization to ensure robust access to content within the EPUB zip archive.

komga/src/main/kotlin/org/gotson/komga/infrastructure/mediacontainer/epub · high confidence

Introduces Tika-based media content detection

The media container infrastructure now uses Apache Tika to detect media types from file paths and input streams, replacing previous detection logic. This change adds a new ContentDetector service and TikaConfiguration bean to handle MIME type identification, enabling more robust support for various image formats (including JPEG XL) and archive files within the library.

komga/src/main/kotlin/org/gotson/komga/infrastructure/mediacontainer · high confidence

Introduction of XXH128-based file hashing infrastructure

A new Hasher component has been added to the infrastructure layer to compute file hashes using the XXH3\_128 algorithm with a fixed seed. This utility reads files via InputStreams and returns hexadecimal hash strings, providing the underlying mechanism for detecting duplicate pages and generating file hashes for books as indicated by the associated feature commits.

komga/src/main/kotlin/org/gotson/komga/infrastructure/hash · high confidence

Introduction of domain model classes for user management, content restrictions, and search

This change introduces a comprehensive set of new domain model classes in the \komga/src/main/kotlin/org/gotson/komga/domain/model\ package. Key additions include \KomgaUser\ for user accounts with role-based access and library sharing, \ContentRestrictions\ and \AgeRestriction\ for filtering content by age and labels, and a new \SearchCondition\ DSL for advanced series and book filtering. The diff also adds models for API key authentication (\ApiKey\), authentication activity logging (\AuthenticationActivity\), and various media-related structures like \Media\, \BookPage\, and \R2Locator\ for Readium progression support.

komga/src/main/kotlin/org/gotson/komga/domain/model · high confidence

Keyboard shortcuts for book, continuous, and EPUB readers

The web UI now defines keyboard shortcuts for navigating and configuring the book, continuous, and EPUB readers. Users can switch reading directions (left-to-right, right-to-left, vertical, webtoon), cycle page layouts, adjust side padding and page margins, toggle toolbars/settings/thumbnails, and use fullscreen mode. EPUB-specific shortcuts include page navigation, layout toggling, theme cycling, and font size adjustment, with arrow keys adapting to the current reading direction.

komga-webui/src/functions/shortcuts · high confidence

Library-level periodic scan scheduling

The system now supports configuring periodic library scans at the individual library level. A new LibraryScanScheduler service manages these schedules, allowing users to set scan intervals (such as hourly, daily, or weekly) per library. The scheduler automatically handles the timing and execution of library scans based on these configured intervals, replacing any previous global or manual scanning mechanisms for these specific libraries.

komga/src/main/kotlin/org/gotson/komga/application/scheduler · high confidence

New Book Card component with contextual metadata and action controls

The BookCard component has been introduced to display book details, dynamically showing a footer subtitle based on the active sort key (such as read date, release date, or file size) and handling various media statuses like errors or unsupported formats. It provides contextual actions, including a quick-edit icon for admins and a bottom-sheet menu for selection, while supporting visual states for reading progress, hover interactions, and series grouping.

next-ui/src/components/book/card · high confidence

New CLI commands for listing users and resetting passwords

Users can now manage accounts directly via the command line. A new --list-users flag displays all registered user emails, while --reset and --newpassword flags allow administrators to reset passwords for specific users. These features are implemented as ApplicationRunners that execute at startup when the corresponding arguments are provided.

komga/src/main/kotlin/org/gotson/komga/interfaces/apprunner · high confidence

New CORS configuration and API key authentication support

The security infrastructure now includes a configurable CORS policy that allows administrators to define allowed origins via the \komga.cors.allowed-origins\ property, enabling controlled cross-origin access for web clients. Additionally, a new API key authentication mechanism has been introduced, allowing users to authenticate REST API requests using a unique key sent via the \X-API-Key\ header or embedded in the request URI, with the system automatically hashing and storing these keys securely. This change also refactors the security configuration to use Spring Security 6 standards, replacing deprecated adapters and introducing specific filters for API key validation alongside existing OAuth2 and session-based authentication.

komga/src/main/kotlin/org/gotson/komga/infrastructure/security · high confidence

New Collection Card component with role-based actions

A new CollectionCard component has been introduced to display collection items, featuring a poster image, title, and series count. The component integrates with the current user's role to conditionally render editing capabilities: the quick-action (edit) icon and the bottom-sheet menu are only visible to administrators, while non-admin users see a read-only view. It also supports selection states and includes Storybook stories to demonstrate default, selected, and hover interactions for both admin and non-admin contexts.

next-ui/src/components/collection/card · high confidence

New History table with expandable event details

A new History table component has been added to display historical events, featuring a server-side data table that supports multi-sorting, pagination, and row expansion. When a row is expanded, specific details for each event type are shown: Book File Deleted displays the file name and reason, Book Imported shows the file, source, and upgrade status, Book Converted presents the before and after file names, Duplicate Page Deleted provides page metadata and a thumbnail, and Series Directory Deleted lists the directory and reason. The Series and Book columns now render clickable links to the respective series or book pages when the data is available.

next-ui/src/components/history · high confidence

New ItemCard component with flexible layout and interaction states

The ItemCard component has been introduced to provide a flexible card layout for entity items, supporting configurable titles and multiple subtitle lines with optional link navigation. It features a poster image area with stretch options, a progress bar, and a top-right indicator (icon or count). The card includes an interactive overlay that reveals selection controls, a center floating action button (FAB), and quick action/menu icons on hover, with specific handling to prevent selection hover icons from appearing during touch interactions. Storybook stories have been added to demonstrate various states including long text wrapping, empty lines, landscape orientation, and loading/error scenarios.

next-ui/src/components/item/card · high confidence

New RAR and ZIP archive extraction infrastructure

The application now supports extracting content from RAR (including RAR4 and RAR5) and ZIP archives through new dedicated extractor services. This change introduces a unified extraction interface and specific implementations that handle archive entry enumeration, media type detection, and image dimension analysis, enabling users to browse and read comics stored within these compressed formats.

komga/src/main/kotlin/org/gotson/komga/infrastructure/mediacontainer/divina · high confidence

New REST API endpoints for client settings, historical events, and announcements

This change introduces several new API endpoints to the REST interface. The Client Settings API allows administrators and users to manage global and per-user configuration settings via dedicated endpoints. A new History endpoint provides administrators with a paginated list of historical system events. Additionally, an Announcements endpoint enables the retrieval and marking of read status for website announcements, while the Claim endpoint exposes server claim status and creation. These additions expand the programmatic control over application settings, audit trails, and initial server setup.

komga/src/main/kotlin/org/gotson/komga/interfaces/api/rest · high confidence

New Server Settings UI component

A new Server Settings form component has been added to the UI, allowing users to configure poster generation options (size and regeneration), scan behavior (deleting empty collections/read lists), task pool size, and 'remember me' duration. The component includes Storybook stories and documentation for the new interface.

next-ui/src/components/server · high confidence

New UI components for library navigation, filtering, and item browsing

The web interface introduces a suite of new components to enhance content discovery and management. LibraryNavigation provides a dedicated toolbar for browsing series, books, collections, and readlists within a library, including a new 'Recommended' tab. AlphabeticalNavigation adds a quick-jump bar for libraries. Filtering is handled by FilterDrawer, FilterPanels, and FilterList, allowing users to sort and filter content with support for 'any/all' logic. Item browsing is powered by ItemBrowser and ItemCard, which display content in a grid with support for selection, dragging, and context-specific action menus. Additional components like HorizontalScroller, CollectionsExpansionPanels, and EmptyState support the new layout and interaction patterns.

komga-webui/src/components · high confidence

New action menus for library items and read lists

The web UI now provides dedicated context menus for Books, Series, Oneshots, Collections, Read Lists, and Libraries. These menus expose item-specific actions such as analyzing, refreshing metadata, marking as read/unread, adding to collections or read lists, and deleting. Library-level menus additionally support scanning (including deep scan), emptying the trash, and reordering libraries, with confirmation dialogs added for destructive operations like analysis and metadata refresh.

komga-webui/src/components/menus · high confidence

New and updated dialogs for API keys, bulk editing, and collections

The web UI now includes an ApiKeyAddDialog for generating and copying API keys, a BulkEditBooksDialog for mass-editing book metadata with lock controls, and new CollectionAddToDialog and CollectionEditDialog components for managing collections. These changes also introduce a reusable ConfirmationDialog for user prompts and a BookPickerDialog for selecting books, replacing or supplementing previous dialog implementations.

komga-webui/src/components/dialogs · high confidence

New app layout bar with mobile navigation and connection alerts

The application now uses a new layout bar component that adapts to mobile devices by displaying a menu icon for the navigation drawer and providing context-aware tooltips. It also includes a warning banner that alerts users when the real-time server connection is unavailable, and conditionally renders selection-specific UI elements based on the current selection state and input device type.

next-ui/src/components/layout/app · high confidence

New book and read list import interfaces for administrators

Administrators can now import content via two new pages: a book import page that scans a specified directory to display and fine-tune a table of detected books, and a read list (CBL) import page that accepts a single .cbl file upload to match and display potential matches. Both interfaces are restricted to the ADMIN role and include Storybook documentation and test stories covering default, loading, and various error states (such as unsupported file types or empty results).

next-ui/src/pages/import · high confidence

New book import interface with directory selection and series matching

The book import workflow now uses a new UI flow starting with a directory selection component that allows users to browse or input a path to scan for books. The resulting transient books are displayed in a table that automatically analyzes unknown books, fetches series details, and attempts to auto-match existing series books for upgrades. Users can manually select series for unmatched books, view comparison details for matched upgrades, and see status indicators for analysis progress and errors.

next-ui/src/components/import/books · high confidence

New book management and interaction capabilities in the UI

The book view now supports several new user actions and information displays. Users can add books to read lists and collections, with corresponding confirmation dialogs and notifications. The book details dialog provides a dedicated view for book information, while the import table allows comparing books. Additionally, the UI now displays the specific file format (e.g., PDF, EPUB, CBR, CBZ) in the book view, and the edit metadata dialog has been enhanced to handle oneshot books by allowing edits to series fields.

next-ui/src/composables/book · high confidence

New book navigation and deletion warning components

The book view now includes a navigation bar that lets users move to the previous or next book within a series or read list, along with a menu to browse sibling books. A new warning dialog component alerts users that deleting a book will permanently remove its media, sidecar files, metadata, and read progress. These components are part of the initial beta UI for the book section.

next-ui/src/components/book · high confidence

New book view UI with action menu and status alerts

The book view page now uses a redesigned layout that displays the book poster, read progress, and series information, along with a new action menu component that groups primary actions (like marking as read/unread) and exposes additional options via a bottom sheet. The view also includes specific alerts for deleted books, media errors, and unsupported file formats to improve user awareness of file status.

next-ui/src/components/book/view · high confidence

New bottom-sheet menu components for Library and Libraries contexts

Added Sheet.vue and SheetLibraries.vue components that render a bottom-sheet menu with a title and subtitle, displaying context-specific actions (such as Scan, Edit, Delete for a single library, and Reorder, Scan All for the libraries list) sorted by a defined priority. These components integrate with existing action composables to provide a consistent, filtered, and ordered set of primary and management actions for library-related operations.

next-ui/src/components/library/menu · high confidence

New collection and readlist view components

Added new Vue components for the Collection and Readlist entity views. These include \CollectionView\ and \ReadlistView\ which display the entity name, ordering status (manual vs automatic), and poster image, along with \Actions\ components that provide action buttons (such as Edit, Open Reader) and a more-menu bottom sheet. The views use Vuetify's display utilities to handle responsive layout and teleport action controls to specific DOM nodes based on screen size.

next-ui/src/components/collection/view, next-ui/src/components/readlist/view · high confidence

New collection edit dialog with tabbed interface and poster management

The collection editing experience has been restructured into a new tabbed dialog (Edit.vue) featuring a 'General' tab for managing collection name and series ordering (General.vue) and a 'Poster' tab for uploading and managing collection posters. The interface now displays error counts on tabs to guide users to validation issues, and automatically resets to the General tab after a failed submission attempt.

next-ui/src/components/collection/form · high confidence

New collection editing and deletion actions

Added composable logic to enable editing and deleting collections. The new \useCollectionActions\ composable exposes Edit and Delete actions (admin-only) that trigger dedicated dialogs. The \useEditCollectionDialog\ composable handles the edit workflow, allowing users to update collection metadata (name, ordering) and manage posters (upload, select, delete), with success/error feedback via snackbar notifications. The delete action presents a confirmation dialog with a warning component before permanently removing the collection.

next-ui/src/composables/collection · high confidence

New collection management UI components

The collection area now includes new Vue components for managing series within collections. Users can add series to existing collections or create new ones via the AddTo component, which supports searching, filtering, and duplicate detection. A DeletionWarning component provides clear feedback before removing a collection, noting that series and books remain intact. Additionally, a Navigation component allows users to move between series within a collection using previous/next buttons and a series list menu, respecting both ordered and title-sorted collection configurations.

next-ui/src/components/collection · high confidence

New composable architecture for the next UI

The \next-ui/src/composables\ directory has been populated with a comprehensive set of new composables that establish the core logic for the new interface. This includes \useBrowsingContext\ for managing URL-based navigation state, \useFilters\ and \useFilterContributors\ for handling complex filtering with route synchronization, and \useSort\ for managing sort orders. The update introduces \useEntitiesActions\ to centralize bulk operations like marking items as read, adding to collections, and deletion, alongside \useSelectionContextualActions\ for the selection bar. Infrastructure improvements include \usePagination\ for synchronized page tracking, \useOverviewSection\ to drive dynamic content sections, and a robust \useSSE\ composable for real-time cache invalidation via Server-Sent Events. Additional utilities cover authentication watching, device detection, image prefetching, and error code formatting.

next-ui/src/composables · high confidence

New continuous and paged reader components for the web UI

The web UI now includes dedicated Vue components for reading books: ContinuousReader.vue handles vertical scrolling (webtoon style) with configurable page margins, side padding, and scale types (width-fit or original), while PagedReader.vue manages discrete page navigation using a carousel, supporting various layouts (single/double page) and reading directions (left-to-right, right-to-left, vertical). These components replace or supplement previous reader implementations, providing a more structured and feature-rich reading experience with keyboard navigation, touch/swipe support, and pre-rendering capabilities.

komga-webui/src/components/readers · high confidence

New data-fetching layer for the next UI

The \next-ui/src/colada\ directory now provides a comprehensive set of composable functions for fetching and mutating data, replacing previous patterns with a standardized approach using \@pinia/colada\. This layer introduces typed queries and mutations for all core entities—including books, series, collections, read lists, libraries, users, and settings—along with specialized utilities for cache invalidation and error handling. Users benefit from consistent data synchronization, automatic cache management, and robust handling of server-side states across the new interface.

next-ui/src/colada · high confidence

New dialog components for book, series, and file selection

The dialog component library now includes dedicated pickers for books, series, and file names, alongside reusable confirmation and simple dialog wrappers. The BookPicker dialog allows users to search and select a book from a provided list with filtering and sorting capabilities. The SeriesPicker dialog enables searching for series by name, displaying results with cover art and library context, and supports debounced search input. The FileNamePicker dialog helps users rename series books by displaying existing filenames and allowing selection or manual entry. Additionally, the Confirm dialog provides configurable confirmation modes (click, checkbox, or text validation), while ConfirmEdit and DialogSimple offer structured wrappers for edit forms and simple informational messages, all integrated with a centralized dialog store for instance management.

next-ui/src/components/dialog · high confidence

New domain service layer for book lifecycle and analysis

The application introduces a dedicated domain service layer in \komga/src/main/kotlin/org/gotson/komga/domain/service\ to manage the core book lifecycle. This includes \BookAnalyzer\ for detecting media types and extracting page metadata, \BookConverter\ for converting archives to CBZ, \BookImporter\ for handling file imports and sidecars, \BookLifecycle\ for managing read progress and thumbnails, \BookPageEditor\ for removing duplicate pages, and \LibraryContentLifecycle\ for scanning and organizing library content. These services centralize the logic previously scattered across the codebase, providing a structured foundation for book management operations.

komga/src/main/kotlin/org/gotson/komga/domain/service · high confidence

New dynamic overview section page for library browsing

A new Vue component has been added to render specific sections within a library's overview, allowing users to browse content (books or series) in a grid layout with infinite scroll. The page dynamically adjusts its card width based on the display size and supports item selection, while enforcing role-based access control (USER) and validating the requested section against known types.

next-ui/src/pages/libraries/\[viewId\]/overview · high confidence

New file-based routing and initial page components for the next UI

The \next-ui/src/pages\ directory now uses Vue's file-based routing to define application views. This change introduces the core authentication and onboarding flow with \login.vue\ (including a 'Remember Me' option and error handling), \claim.vue\ (for initial server setup with password confirmation), and \startup.vue\ (which checks for an authenticated user and redirects accordingly). It also adds essential navigation and error states: \index.vue\ redirects to the pinned libraries view, \error.vue\ handles server unreachability with a retry option, and \\[...path\].vue\ manages 404s with a 5-second countdown redirect. Additionally, \history.vue\ is added as an admin-only view, and Storybook stories are provided for the login and claim flows to document their behavior.

next-ui/src/pages · high confidence

New filter and sort UI components

This change introduces a new set of UI components for filtering and sorting data. In the filter area, it adds components for selecting 'Any/All' logic, managing tri-state selections (include/exclude), displaying filter counts, and handling range selections. It also includes a searchable list component with virtual scrolling and a mode selector. In the sort area, it adds components for managing single and multi-sort options, including tri-state toggles for sort order (asc/desc/none) and a restore-to-default button. Storybook stories are provided for all new components to aid in development and testing.

next-ui/src/components/filter · high confidence

New filter components for series and book attributes

The \next-ui/src/components/filter/by\ directory now includes a comprehensive set of new Vue components for filtering content by specific attributes. These include AgeRating, ReleaseYear, and Poster filters, as well as search-enabled list filters for Contributors, Genres, Languages, Libraries, NotableEntities, Publishers, SharingLabels, and Tags. Additionally, simple selection filters are provided for Complete, MediaProfile, MediaStatus, OneShot, ReadStatus, SeriesStatus, SharingLabel, and Unavailable states, each accompanied by Storybook stories to demonstrate their usage.

next-ui/src/components/filter/by · high confidence

New import read list table with automatic series and book matching

Users can now import reading lists via a new data table interface that automatically matches series and books based on server-provided identifiers. The table displays import entries and uses an internal watcher to fetch series books and auto-select the correct book number when a series is picked. It supports filtering, manual selection of series and books via dialogs, and displays status icons for duplicates or errors. A bottom form allows users to name and summarize the new read list before creation, with validation and loading states handled via Vuetify components.

next-ui/src/components/import/readlist · high confidence

New infinite-scroll combobox components for filtering

Added new combobox components (Contributor, Genre, NotableEntity, SharingLabel, Tag) that support infinite scrolling and debounced search, allowing users to efficiently filter by these entity types without loading the entire dataset at once.

next-ui/src/components/combobox · high confidence

New internationalization (i18n) infrastructure and message definitions

The application now includes a dedicated i18n utility layer in \next-ui/src/utils/i18n\. This introduces a locale helper that manages language selection by persisting user preferences to localStorage, matching browser preferences, and supporting Right-to-Left (RTL) layouts. It also adds comprehensive message definitions for common UI strings, filter panel sections (such as Notable entities and Sharing labels), series editing forms, background task names, historical events, and a wide range of system error codes (ERR\_1000–ERR\_1039). Tests have been added to verify locale loading, fallback behavior, and persistence.

next-ui/src/utils/i18n · high confidence

New item display components for grid, poster, and scrollable lists

Added three new Vue components to the item display layer: Browser.vue provides a paginated or infinite-scroll grid/list view using Vuetify's data iterator; Poster.vue renders media cards with optional top-right badges, progress bars, and lazy loading; and Scroller.vue implements a horizontal slide-group carousel with navigation arrows and touch-device chevron indicators. These components introduce the foundational UI structure for item presentation in the new UI beta, supporting selection states, RTL layouts, and responsive pagination.

next-ui/src/components/item · high confidence

New item menu components with RTL and bottom-sheet support

This change introduces three new Vue components in the item menu location: ItemMenu.vue, ItemMenuBottomSheet.vue, and Sheet.vue. ItemMenu.vue provides a desktop-style dropdown menu that supports RTL locales by dynamically adjusting the submenu arrow icon and ensures menus close properly after an action is selected. ItemMenuBottomSheet.vue offers a mobile-friendly bottom sheet variant that can display a title and subtitle (such as an entity type). The Sheet.vue component acts as a wrapper that automatically selects between the dropdown and bottom sheet views based on the device's touch capability, ensuring a consistent user experience across platforms.

next-ui/src/components/item/menu · high confidence

New library management pages for browsing and creation

The libraries section now includes dedicated pages for browsing library views and creating new libraries. The new \[viewId\] page handles library view navigation, providing context for filters and automatically redirecting users to the create page if no libraries exist, or to the overview if the library list is incomplete. The new create page displays an empty state with a call-to-action for administrators to create their first library, while non-administrators see a message indicating no libraries are available on the server.

next-ui/src/pages/libraries · high confidence

New library navigation and warning components

The library section now includes a new \DeletionWarning\ component that displays a confirmation notice before deleting a library, clarifying that series, books, and metadata will be removed while media files remain on disk. Additionally, \LibraryNavigation\ and \TabNavigation\ components have been added to provide a structured navigation interface, featuring tabs for Overview, Series, Books, and conditionally for Collections and Read Lists, with support for switching between pinned, all, and unpinned library views.

next-ui/src/components/library · high confidence

New library subview pages for books, collections, readlists, series, and overview

The library view now includes dedicated pages for browsing books, collections, readlists, and series, as well as a configurable overview section. These pages provide a consistent browsing experience with poster size adjustment, paging controls, and item selection. The books and series views include advanced filtering (by read status, tags, authors, genres, etc.) and sorting options, while the overview page allows users to reorder and configure displayed sections.

next-ui/src/pages/libraries/\[viewId\] · high confidence

New multi-select toolbar with bulk action capabilities

The web interface now includes a dedicated multi-select bar component that appears when items are selected, enabling bulk operations directly from the UI. This toolbar supports actions such as marking items as read or unread, adding them to collections or read lists, bulk editing metadata, and deleting items. It also features select-all and deselect-all controls, with specific buttons appearing based on the item type (books, series, collections, or read lists) and user permissions.

komga-webui/src/components/bars · high confidence

New multi-step library creation and editing form

The library creation and editing interface has been restructured into a four-step wizard (General, Scanner, Options, Metadata) using Vuetify tabs, replacing the previous single-page layout. This change introduces dedicated form steps for configuring library basics, scanning schedules and exclusions, file processing options, and metadata import sources, along with corresponding Storybook stories and documentation for each component.

next-ui/src/components/library/form · high confidence

New read list management components for adding items and warning on deletion

The read list section now includes an 'Add to' dialog (AddTo.vue) that lets users search existing read lists, create new ones, and add books or series to them, complete with duplicate name validation and infinite scroll. A 'Deletion Warning' component (DeletionWarning.vue) is also introduced to inform users that deleting a read list is irreversible and will not affect the underlying series or books. Storybook stories are provided for both components to demonstrate their behavior.

next-ui/src/components/readlist · high confidence

A new Card component has been added to the release section to display Komga release details. The card shows the release version as a clickable link to the GitHub release page, accompanied by an external link icon. It also renders badges for 'Installed' and 'Latest' statuses based on the release state, displays the release date, and renders the changelog description as formatted HTML. Storybook stories are included to demonstrate the component's various states.

next-ui/src/components/announcement, next-ui/src/components/release · high confidence

The selection interface now includes new components (Bar, BarActions, Footer) that display contextual actions and item counts. The Bar component uses tooltips for action buttons, addressing mobile usability, while the Footer component features a primary-colored design with a slide-group for action buttons. A Storybook story has been added for the Bar component to facilitate testing and visualization.

next-ui/src/components/selection · high confidence

New series card components with contextual navigation and metadata editing

This change introduces new \SeriesCard\ and \SeriesCardWide\ components that display series metadata, including dynamic subtitles based on sort context (e.g., release date, creation date) or status (e.g., 'Unavailable', 'One-shot'). The cards now support contextual navigation by passing a browsing context parameter to the series detail route, and provide admin-only quick actions for editing series metadata via a dialog. A bottom-sheet menu is triggered by long-press or menu icon, allowing users to select the series. Storybook stories are added to demonstrate various states such as read/unread, selected, hover, and non-admin views.

next-ui/src/components/series/card · high confidence

New series detail page with advanced filtering and navigation

A new series detail page (\[id\].vue) has been introduced, featuring a top app bar with navigation breadcrumbs and collection navigation controls. The page includes a comprehensive filter drawer allowing users to filter by read status, one-shot status, media profile, media status, tags, and contributors, along with sorting options. A sticky control bar provides access to poster size adjustment, presentation mode toggling (grid/list), paging controls, and filter management. The page handles loading states with skeleton loaders and displays empty states for network errors or no results.

next-ui/src/pages/series · high confidence

New series management actions and dialogs

This change introduces new composables in the series module that enable users to add series to collections, edit series metadata, and manage series actions. The \useAddToCollectionDialog\ composable provides a dialog for adding series to collections with notifications upon creation or addition. The \useEditSeriesMetadataDialog\ composable enables editing series metadata including poster management (upload, select, delete) and metadata updates. The \useSeriesActions\ composable consolidates various series actions including mark read/unread, download, edit metadata, refresh metadata, analyze, delete, and read/resume reading, with appropriate role-based access controls. The \useSeries\ composable provides computed properties for series status including read state, unread count, in-progress status, availability, and reading permissions.

next-ui/src/composables/library, next-ui/src/composables/series · high confidence

New series view page with action menu and metadata chips

The series view page now features a dedicated action menu (Actions.vue) that displays primary actions like reading and editing, along with a secondary menu for additional options. The main view (SeriesView.vue) presents series metadata including title, book count, release date, status, language, age rating, and reading direction as clickable chips. It also shows read status indicators and 'on deck' book information. The component includes Storybook stories for testing various states including normal, with books data, and deleted series.

next-ui/src/components/series/view · high confidence

New server and account management pages

This change introduces a suite of new pages for the server and account sections of the UI. Server-side features include an Announcements page (with bulk read marking), a Settings page (with thumbnail regeneration), an Updates page (displaying release status), and a Users page (supporting create, edit, delete, and password change operations). Account-side pages include Activity, API Keys (with force-sync and deletion), and Details (with password change). Several pages (Server Metrics, Server UI, Account UI) are currently placeholders showing a construction state.

next-ui/src/pages/server · high confidence

New sidecar consumer interfaces for book and series metadata

The sidecar infrastructure now exposes two new interfaces, SidecarBookConsumer and SidecarSeriesConsumer, which define how the system identifies and matches sidecar files for individual books and entire series respectively. These interfaces allow the scanning process to detect changes in sidecar files by specifying the sidecar type, pre-filtering patterns for books, and matching logic for both book and series sidecar filenames.

komga/src/main/kotlin/org/gotson/komga/infrastructure/sidecar · high confidence

New type definitions and validation schemas for the Next UI

The \next-ui/src/types\ directory has been populated with a comprehensive set of new TypeScript type definitions, validation schemas, and supporting utilities that underpin the new UI layer. This includes domain models for books and series (e.g., \BookDetails\, \BookImport\, \ReadListImportEntry\), enums with localized messages for media profiles, statuses, and reading directions, and robust validation schemas using Valibot for complex filter criteria and user settings. Additionally, it introduces structural types for pagination (\PageRequest\), routing (\RouteLocationObject\, \RouterMeta\), and UI components (\ItemCard\, \Dialog\), along with tests to ensure the correctness of these foundational types.

next-ui/src/types · high confidence

New user management interface with authentication activity tracking

The user management section now features a comprehensive set of new components built on Vuetify. Administrators can view a paginated, sortable table of users with actions to change passwords, edit, or delete accounts (excluding the current user). A dedicated authentication activity table allows tracking of login attempts, IP addresses, and user agents, with an option to filter for the current user's own activity. User creation and editing are handled via a unified form supporting role assignment, library sharing configuration, and age restrictions. Additionally, a warning dialog is displayed before account deletion to confirm the permanent loss of read progress and authentication history.

next-ui/src/components/user · high confidence

New utility functions for UI logic and navigation

The \next-ui/src/functions\ directory now contains a collection of new utility modules that centralize core UI logic. These include \browsing-context.ts\ for managing navigation stacks and route generation, \filter.ts\ for converting UI filter states into API query conditions, \entity.ts\ for type-guarding different content types (books, series, collections, readlists), and \selection.ts\ for determining available actions based on selected entities. Additional helpers cover array operations, clipboard image pasting, file size formatting, library defaults, and user settings parsing.

next-ui/src/functions · high confidence

New utility functions for web UI logic and API routing

The web UI now includes a dedicated set of helper functions in \komga-webui/src/functions\ to manage core display and interaction logic. This introduces specific capabilities for handling book formats (CBR, CBZ, PDF, EPUB, KEPUB, RAR5) and determining the correct reader route, calculating read progress and pages remaining, and building page spreads for single and double-page layouts. It also adds support for detecting browser capabilities for modern image formats like JPEG XL and WebP, managing URL generation for API resources, and handling UI-specific tasks such as image resizing for posters, sorting/filtering parameters, and accent-insensitive search.

komga-webui/src/functions · high confidence

New web UI service layer for API integration

The web UI now includes a comprehensive set of TypeScript service classes in the \komga-webui/src/services\ directory to handle all communication with the backend API. These services provide structured wrappers for interacting with endpoints covering books, series, collections, read lists, libraries, users, and settings, as well as specialized services for server actuator controls, announcements, OAuth2 login, page hashing, and real-time updates via Server-Sent Events (SSE). This change establishes the foundational client-side architecture required for the new dynamic UI features.

komga-webui/src/services · high confidence

New web UI views for account, announcements, API keys, and media browsing

The web interface now includes dedicated views for managing user accounts (AccountView), viewing server announcements (AnnouncementsView), and managing API keys (ApiKeys). Additionally, comprehensive browsing and management screens have been added for all media types: BrowseBooks, BrowseLibraries, BrowseSeries, BrowseCollections, BrowseReadLists, and BrowseOneshot. These views provide users with the ability to filter, sort, and paginate through their libraries, series, books, collections, and read lists, supporting multi-select actions and detailed item navigation.

komga-webui/src/views · high confidence

OAuth2 and OIDC login support with automatic user creation

Users can now log in to Komga using external OAuth2 providers (starting with GitHub) and OIDC identity providers. The system automatically creates a new Komga account upon first successful login if the 'oauth2AccountCreation' configuration option is enabled; otherwise, the login fails if the user does not already exist. For GitHub logins, the service fetches the user's verified email address if it is not provided in the initial token response. For OIDC logins, the system enforces email verification requirements based on the 'oidcEmailVerification' setting, rejecting logins from unverified or missing email claims.

komga/src/main/kotlin/org/gotson/komga/infrastructure/security/oauth2 · high confidence

Poster upload component with clipboard paste support

The poster management area now includes a new upload interface (PosterUpload) that allows users to add local image files via drag-and-drop or by pasting images from the clipboard (Cmd+V). This component integrates with the existing PosterCard to display a unified list of remote and local posters, enabling selection, deletion, and undo actions for both types of assets.

next-ui/src/components/poster · high confidence

Real-time updates via Server-Sent Events

The web UI now receives live notifications for library changes (additions, updates, deletions), series and book status changes, read progress updates, thumbnail modifications, and task queue status. It also notifies users when their session expires or is deleted, allowing the interface to react immediately to backend events without manual refresh.

komga/src/main/kotlin/org/gotson/komga/interfaces/sse · high confidence

Repository initialization with build, CI, and documentation scaffolding

The repository is initialized with essential configuration and documentation files. A .editorconfig is added to standardize code formatting across Kotlin, TypeScript, JavaScript, and YAML files. Conveyor configuration files (conveyor.conf, conveyor.ci.conf, etc.) are introduced to define the desktop application build process, including JVM modules, platform-specific inputs (kepubify, native libraries), and CI integration for Apple notarization and Microsoft Store publishing. Documentation files such as README.md, CONTRIBUTING.md, DEVELOPING.md, SECURITY.md, PRIVACY.md, and ERRORCODES.md are added to guide users and contributors. The .gitignore is updated to exclude build artifacts, logs, and temporary files. The gradlew and gradlew.bat scripts are updated to a newer version with improved POSIX compliance and error handling.

(repo-wide) · high confidence

Support for database-backed HTTP sessions

Komga now supports storing HTTP sessions in a database via a new \komga.jdbc-session-enabled\ configuration property. When enabled, sessions are persisted using Spring Session JDBC with SQLite-compatible queries, allowing for session sharing across multiple instances or persistence across restarts; when disabled (the default), sessions remain in-memory using Caffeine. The session cookie name is now explicitly set to \KOMGA-SESSION\, and a custom \SmartHttpSessionIdResolver\ allows session IDs to be passed via the \X-Auth-Token\ header as an alternative to cookies, which is useful for API clients.

komga/src/main/kotlin/org/gotson/komga/infrastructure/session · high confidence

Support for local artwork files and oneshot series metadata

Users can now provide custom cover images for series and books by placing local image files (PNG, JPEG, JPG, TBN, WebP, GIF) in the library directories, with the system automatically detecting and using them as thumbnails. Additionally, metadata for oneshot series is now automatically populated from the single book's metadata, ensuring consistent information display for single-issue content.

komga/src/main/kotlin/org/gotson/komga/infrastructure/metadata/localartwork · high confidence

Removals

Removal of Swagger 2 configuration

The Swagger 2 configuration file has been removed from the codebase. This eliminates the manual setup for Swagger 2 documentation, which previously ignored specific authentication principal parameters. This change aligns with the project's migration to OpenAPI 3, as the legacy Swagger 2 infrastructure is no longer required.

komga/src/main/kotlin/org/gotson/komga/infrastructure/swagger · high confidence

Removal of legacy Series and Book API endpoints

The legacy REST controller for managing series and books (SerieController.kt) has been removed. This eliminates the previous API endpoints for listing series, retrieving individual series, fetching books within a series, and accessing book content files. Users relying on these specific endpoints for series and book data retrieval will need to migrate to the updated API structure provided by the current version.

komga/src/main/kotlin/org/gotson/komga/interfaces/web · high confidence

API

Comprehensive REST API DTO overhaul and new capability support

The REST API data structures have been completely redefined to support new features and stricter validation. Users can now manage API keys, view authentication activity logs, and configure granular library settings (such as scan intervals, directory exclusions, and hashing options) via the API. The API exposes new endpoints and DTOs for managing alternate series titles, book links, and sharing labels. Duplicate page detection is now exposed via page hash DTOs, and read progress synchronization has been enhanced with new Tachiyomi V2 DTOs. Additionally, the API now supports client-side settings, server configuration (port, context path), and fetching Komga release announcements via a JSON feed.

komga/src/main/kotlin/org/gotson/komga/interfaces/api/rest/dto · high confidence

Architecture

Database access layer migrated to split read/write DAOs with JOOQ

The database access layer for the main data source has been restructured into a set of dedicated, split read/write DAOs (e.g., \AuthenticationActivityDao\, \BookDao\, \BookDtoDao\, \KomgaUserDao\) using JOOQ. This change introduces a clear separation between read operations (using a read-only \dslContextRO\) and write operations (using a write \dslRW\), which improves performance and concurrency. The new implementation includes optimized queries for features like 'On Deck' books using materialized CTEs, support for Kobo sync metadata, and enhanced search capabilities with temporary tables for large result sets.

komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/main · high confidence

Introduce comprehensive TypeScript type definitions for the web UI

The web UI now uses a dedicated set of TypeScript interfaces and enums in the \komga-webui/src/types\ directory to strongly type all data models and configuration options. This covers domain entities such as books, series, libraries, collections, and read lists, as well as reader settings (scale types, layouts), user roles, and server settings. It also defines types for event-driven updates via Server-Sent Events (SSE), search conditions, and pagination, providing a consistent and type-safe foundation for the frontend components.

komga-webui/src/types · high confidence

Behavioural changes

API v3 now returns RFC 9457 Problem Detail for errors

The v3 REST API has been updated to use RFC 9457 Problem Detail for error responses. This change introduces a new error handling controller advice that standardizes validation errors (from method arguments and constraint violations) into a consistent JSON format including a 'violations' array. Additionally, the v3 API now exposes new endpoints for managing referential data, specifically allowing users to list notable entities, their kinds, and their names with filtering and pagination support.

komga/src/main/kotlin/org/gotson/komga/interfaces/api/rest/v3 · high confidence

Database migrations for thumbnails, metadata, and progress fixes

This update applies several database migrations to improve data integrity and structure. Thumbnails are moved from the MEDIA table to a dedicated THUMBNAIL\_BOOK table with generated IDs. Series metadata (age rating, publisher, reading direction) is aggregated from books to the series level, and missing series metadata is auto-generated for existing series. Incorrect BCP47 language codes in series metadata are normalized. Additionally, read progress locators are corrected to fix compatibility issues, and missing series metadata entries are created for series that lacked them.

komga/src/flyway/kotlin · high confidence

Database schema evolution for SQLite storage

The application's database schema has evolved significantly to support new features and performance improvements while migrating to SQLite. Key changes include the introduction of read lists, series sharing labels, and oneshot directory support, alongside enhanced metadata capabilities like full-text search (later removed), alternate titles, and ISBN tracking. The schema now stores authentication activity, historical events, and user content restrictions, while also optimizing performance through various database indices and aggregating book metadata at the series level. Library configuration has expanded to include options for scanning intervals, file type exclusions, automatic trash emptying, and local artwork import.

komga/src/flyway/resources/db · high confidence

Database schema updates for task management

The database schema for the task management system has been updated with new tables and indices to support background task handling. A new \TASK\ table is introduced to store task details including priority, group ID, class, payload, and owner, along with an index on the owner and group ID columns. Additionally, new indices are created on the task table to optimize queue polling (based on owner, priority, and last modified date) and to support lookups by simple type.

komga/src/flyway/resources/tasks · high confidence

Domain events are now published asynchronously in production

The application now uses Spring's built-in event multicaster with a dedicated task executor for publishing domain events, replacing the previous Artemis-based messaging system. This configuration is active in all non-test profiles, ensuring that event listeners are executed asynchronously to improve responsiveness, while tests continue to use synchronous event processing for reliability.

komga/src/main/kotlin/org/gotson/komga/application/events · high confidence

Enable HTTP request/response exchange logging

The application now includes an in-memory repository for tracking HTTP exchanges, allowing users to inspect request and response details via Spring Boot Actuator endpoints. This replaces the previous HttpTrace mechanism with the newer HttpExchange infrastructure provided by Spring Boot.

komga/src/main/kotlin/org/gotson/komga/infrastructure/httpexchange · high confidence

Enforced content restrictions across API endpoints

The API now consistently enforces user-specific content restrictions (such as age ratings and label-based filters) for all book and series access points. A new ContentRestrictionChecker component centralizes this logic, ensuring that restrictions are applied not only to standard book pages and metadata but also to thumbnails, OPDS feeds, and WebPub manifests (EPUB, PDF, and Divina profiles). Users with restricted access will now receive forbidden errors when attempting to view content they are not permitted to see, closing previous gaps where restrictions were bypassed in specific endpoints.

komga/src/main/kotlin/org/gotson/komga/interfaces/api · high confidence

Enhanced web server configuration and request handling infrastructure

This update introduces several improvements to the web layer: the server port and context path can now be explicitly configured via settings; ETag caching is enabled for API, OPDS, and Kobo endpoints (excluding file downloads) to improve performance; query parameters using square brackets (e.g., \author\[\]\) are now correctly parsed and merged; the Kobo Sync feature now handles missing port information in forwarded headers more robustly; and static web resources (including favicons and CSS layers) are properly served with appropriate cache controls.

komga/src/main/kotlin/org/gotson/komga/infrastructure/web · high confidence

Improved OpenAPI documentation and schema generation

The OpenAPI specification now includes the /actuator/info endpoint for retrieving server information. Additionally, the generated schema for sealed classes (such as SearchOperator and SearchCondition) is flattened to remove unnecessary inheritance wrappers, resulting in cleaner and more accurate API documentation for clients.

komga/src/main/kotlin/org/gotson/komga/infrastructure/openapi · high confidence

Improved startup reliability and faster ZIP extraction

Komga now validates that the system's temporary directory exists and is writable at startup, preventing runtime failures caused by missing or inaccessible temp paths. Additionally, ZIP file handling has been optimized for speed by reading only the central directory record first, falling back to a full scan only when necessary, which improves performance when extracting entries from archives.

komga/src/main/kotlin/org/gotson/komga/infrastructure/util · high confidence

The application now includes a dedicated styles directory with global and settings files. Users will see that links on touch devices no longer display underlines by default, while desktop users still see underlines on hover. Additionally, a new utility class is available to enforce line-clamping on text elements, and the SASS settings file is prepared for Vuetify configuration.

next-ui/src/styles · high confidence

Introduce OPDS v1 DTOs with static XML namespace prefixes

The OPDS v1 API now uses a dedicated set of data-transfer objects (OpdsAuthor, OpdsEntry, OpdsFeed, OpdsLink, OpenSearchDescription) to serialize its Atom XML responses. A key behavioral change is the use of static XML namespace prefixes (e.g., 'pse' for OPDS Page Streaming Extension) defined in XmlNamespaces.kt, ensuring consistent and predictable XML output for clients consuming the catalog, navigation, and acquisition feeds.

komga/src/main/kotlin/org/gotson/komga/interfaces/api/opds/v1/dto · high confidence

Introduce desktop application entry point with startup error handling and file explorer utilities

The komga-tray module now includes a new DesktopApplication entry point that validates the temporary directory is accessible on startup and provides a user-friendly error dialog if the application fails to launch (e.g., due to port conflicts). It also adds internationalized resource loading (RB.kt) and utility functions for opening URLs and file explorers, including a specific Windows workaround for opening file directories.

komga-tray/src/main/kotlin/org/gotson/komga · high confidence

Introduce new API client layer with centralized base URL and error handling

The next-ui application now uses a dedicated API client setup in next-ui/src/api that centralizes the base URL configuration (supporting both environment variables and window globals) and configures the OpenAPI-generated client with session cookie support and XMLHttpRequest headers to prevent browser auth popups. This change also adds interceptors that parse Spring-style API errors (extracting detail or message fields from the response body) and attach them to thrown errors, while providing helper functions to construct URLs for series, book, and collection posters, file downloads, and the book reader interface.

next-ui/src/api · high confidence

Introduction of centralized transaction template configuration

A new \TransactionConfiguration\ class has been added to the infrastructure layer to provide a Spring-managed \TransactionTemplate\ bean. This change establishes a centralized configuration for transaction management, allowing other components to utilize a consistent template for executing database operations.

komga/src/main/kotlin/org/gotson/komga/infrastructure/transaction · high confidence

Media management pages redirected to library filters

The dedicated media management pages (analysis, missing posters, duplicate files, and duplicate pages) have been replaced with redirect or placeholder views. The analysis and missing posters pages now redirect users to the main library view with specific filters applied (e.g., filtering for books with errors or missing posters), while the duplicate files page shows a construction placeholder and the duplicate pages pages display their respective tables. These changes require ADMIN role access.

next-ui/src/pages/media · high confidence

Migrate database access layer from Hibernate to jOOQ

The application's data access implementation has been replaced with jOOQ, introducing new configuration classes for read/write and read-only DSL contexts, helper classes for generating search conditions, and utilities for handling SQLite-specific features like temporary tables and accent-insensitive collations. This change underpins improved search capabilities, including better full-text search, accent-insensitive queries, and support for new search criteria such as isNull/isNotNull operators and poster-based book searches.

komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq · high confidence

New Dockerfile template with updated base image and bundled kepubify

The Docker build process now uses a multi-stage template (Dockerfile.tpl) that upgrades the base image to Ubuntu 26.04 for amd64 and arm64 architectures and bundles the kepubify tool for enhanced ebook support. The image also installs native libraries for JPEG-XL, HEIF, and WebP, adds curl and wget, and configures proper locale support. The container now exposes port 25600 by default and uses the Spring Boot jar tools to extract layers.

komga/docker · high confidence

New UI styling for dialogs, popovers, and e-book rendering

The web interface now includes dedicated styles for enhanced user interactions and content display. Tabbed dialogs on extra-small screens are adjusted to use full viewport height with scrolling, while list items now feature distinct hover states for warning and danger actions. Popovers and popups have been restyled with smooth fade-in animations and scroll indicators. Additionally, the e-book reader (Readium) styling is introduced, supporting pagination, scrolling, and various reading modes with customizable fonts and colors.

komga-webui/src/styles · high confidence

New book detail page with oneshot series context and navigation

The book detail view has been replaced with a new implementation that displays series metadata for oneshot books and adjusts navigation breadcrumbs based on the browsing context. Specifically, if a user navigates to a non-oneshot book from a library view, the context automatically shifts to the book's parent series to ensure relevant navigation options are available. For oneshot books, the view explicitly fetches and displays series attributes and includes a dedicated collection navigation component.

next-ui/src/pages/book · high confidence

New bottom sheet menu components for book, collection, read list, and series

The application now uses dedicated bottom sheet menu components for Books, Collections, Read Lists, and Series. These new UI elements display a contextual title and a localized subtitle (e.g., 'Book', 'Collection') and present a sorted list of available actions. The menus are divided into 'default' actions (such as Open Reader, Download, Mark Read/Unread, Add to Collection/Read List) and 'management' actions (such as Edit, Refresh Metadata, Analyze, Delete). A 'Select' action is conditionally included in the menu only when the selection store is empty and the device is using a touch primary input, controlled by the \addSelectAction\ prop.

(repo-wide) · high confidence

New configuration infrastructure and database filesystem validation

The application now includes a new \ConfigurationChecker\ component that validates database storage paths at startup, blocking operation if the files reside on remote filesystems like CIFS or NFS to prevent data corruption. Additionally, the \KomgaProperties\ class has been significantly expanded to support SQLite-specific settings (such as WAL mode and connection pooling), Lucene search analyzer tuning, Kobo sync options, and CORS configuration, while ensuring necessary database directories are created automatically.

komga/src/main/kotlin/org/gotson/komga/infrastructure/configuration · high confidence

New database-backed task repository implementation

The system now uses a new \TasksDao\ component to manage background tasks via the database instead of the previous in-memory or alternative mechanism. This implementation introduces a dedicated \TASK\ table schema and utilizes separate read/write DSL contexts to optimize performance. It supports batched saves, priority-based task retrieval, and owner-based locking to ensure tasks are processed exactly once, replacing the prior task handling logic.

komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/tasks · high confidence

New image infrastructure for analysis, conversion, and mosaic generation

The image processing layer has been restructured with new components: ImageAnalyzer extracts dimensions from image streams, ImageConverter handles format conversion (including WebP support via NightMonkeys) and resizing with upscaling prevention, and MosaicGenerator creates composite thumbnails using configured quality settings. These changes enable more robust image handling, including proper alpha channel management and support for additional image formats.

komga/src/main/kotlin/org/gotson/komga/infrastructure/image · high confidence

New navigation drawer with library reordering and classic UI access

The application now features a new navigation drawer component that includes a dedicated mode for reordering libraries via drag-and-drop, a footer with documentation links and build version info, and a menu structure that provides access to the classic UI. The drawer also introduces a new 'My Account' section in the menu, replacing the previous 'Server \> User Interface' page, and includes a 'Classic UI' link to switch interfaces.

next-ui/src/components/layout/app/drawer · high confidence

New plugin architecture with Vuetify 4, RTL support, and unhead integration

The application now uses a centralized plugin registration system in \next-ui/src/plugins\ that initializes several key services. Vuetify has been upgraded to version 4.2.0 and configured with the MD3 blueprint, including specific light and dark theme colors and custom validation rules for ISBNs, URLs, and language codes. The UI now supports Right-to-Left (RTL) locales by dynamically loading the correct Vuetify locale and setting the RTL flag based on the current language. Additionally, the app integrates \@unhead/vue\ for head management and \vue-intl\ for internationalization, ensuring that locale-specific messages are loaded efficiently. Navigation guards for login, roles, and scroll behavior are also registered through this new plugin structure.

next-ui/src/plugins · high confidence

New read list editing dialog with tabbed interface and error indicators

The read list editing experience now uses a dedicated dialog component featuring two tabs: 'General' for editing the name, summary, and ordering settings, and 'Poster' for managing cover images. A key usability improvement is the display of validation error counts directly on the tab headers, allowing users to quickly identify which section contains issues. The form also automatically resets to the General tab upon a failed submission attempt.

next-ui/src/components/readlist/form · high confidence

New router implementation with Pinia Colada query caching and dedicated navigation guards

The router module has been rewritten to use Pinia Colada's query cache for all navigation guards, replacing previous reactive query patterns. This introduces dedicated guards for authentication (login-guard), role-based access (role-guard), server claim status (claim-guard), oneshot series redirection (oneshot-guard), and library view redirection (library-view-redirect-guard). The router now also implements custom scroll behavior that saves and restores scroll positions only on popstate navigation (back/forward buttons) to prevent jumping during filter/tab interactions, and includes a workaround for Vite dynamic import errors.

next-ui/src/router · high confidence

New tabbed book editing form with oneshot-specific fields

The book editing interface has been replaced with a new tabbed form (Edit.vue) that organizes editing into General, Contributors, Tags, Links, and Poster tabs, with an additional Sharing tab for series. The General tab now conditionally displays fields based on whether the book is a 'oneshot': oneshots show a 'Title Sort' field and hide the 'Number' and 'Sort number' fields, while regular books show the number fields. The Contributors tab (Contributors.vue) allows dynamic management of author roles, including adding custom roles, and the Tags tab (Tags.vue) exposes genre selection for oneshots.

next-ui/src/components/book/form · high confidence

New tabbed series edit form with dedicated metadata sections

The series editing interface has been replaced with a new tabbed form (Edit.vue) that organizes metadata updates into six distinct sections: General, Alternate titles, Tags, Links, Poster, and Sharing. This new layout introduces specific components for managing series details, including a General tab for core fields like title, summary, publisher, status, and reading direction; a Titles tab for adding and removing alternate titles; a Tags tab for genres and series tags; and a Sharing tab for managing sharing labels. The form also integrates poster upload functionality and displays error counts per tab to guide users to validation issues.

next-ui/src/components/series/form · high confidence

New validation annotations for metadata fields

Added new custom validation annotations (BCP47, Blank, NullOrBlankOrBCP47, NullOrBlankOrISBN, NullOrNotBlank, NullOrNotEmpty) to the validation infrastructure. These annotations provide stricter and more specific validation rules for metadata fields, such as ensuring language tags are valid BCP 47 formats and ISBNs are valid ISBN-13, while also allowing null or blank values where appropriate. This enhances data integrity for metadata updates.

komga/src/main/kotlin/org/gotson/komga/infrastructure/validation · high confidence

OPDS v1 XML output now uses static namespace prefixes

The XML serialization infrastructure for OPDS v1 has been updated to enforce static namespace prefixes in the generated XML output. This change is implemented via a new \NamespaceXmlFactory\ and a corresponding Spring configuration bean that maps specific prefixes to their namespaces, ensuring consistent and predictable XML structure for OPDS clients.

komga/src/main/kotlin/org/gotson/komga/infrastructure/xml · high confidence

OPDS v1.2 catalog restructured with new navigation entries and alternate OPDS v2 link

The OPDS v1.2 catalog endpoint now presents a reorganized navigation structure, introducing dedicated entries for 'Keep Reading' and 'On Deck' alongside existing 'All series' and 'Latest series' views. Additionally, the root catalog feed now includes an alternate link pointing to the OPDS v2 catalog, facilitating easier discovery and migration for clients supporting the newer protocol version.

komga/src/main/kotlin/org/gotson/komga/interfaces/api/opds/v1 · high confidence

PDF page extraction refactored to use Apache PDFBox 3

The PDF extraction logic in the \PdfExtractor\ service has been rewritten to use Apache PDFBox 3.0.1, replacing the previous implementation. This change updates how PDF pages are loaded, rendered as images, and extracted as individual PDF files, ensuring compatibility with the newer library version and potentially improving performance or stability for PDF media handling.

komga/src/main/kotlin/org/gotson/komga/infrastructure/mediacontainer/pdf · high confidence

Persistence layer refactored to custom repository interfaces

The persistence layer for books, series, and related entities has been refactored from standard Spring Data JPA repositories to custom repository interfaces. This change replaces the previous \JpaRepository\ implementations with explicit method definitions for data access, introducing support for advanced search conditions, context-aware filtering, and specific operations like page hashing and thumbnail management. Users benefit from improved data retrieval capabilities and better integration with the application's search and synchronization features.

komga/src/main/kotlin/org/gotson/komga/domain/persistence · high confidence

Refactored metadata provider interfaces for books and series

The metadata infrastructure has been refactored to introduce distinct interfaces for book and series metadata providers. Book metadata is now handled via \BookMetadataProvider\, which exposes capabilities as a set and retrieves patches from \BookWithMedia\ objects. Series metadata is split into \SeriesMetadataProvider\ for general series data and \SeriesMetadataFromBookProvider\, which adds support for appending volume information to series titles. All providers now implement a common \MetadataProvider\ base interface that allows checking if a library handles specific metadata patch targets.

komga/src/main/kotlin/org/gotson/komga/infrastructure/metadata · high confidence

Refactored pagination logic to support unpaged queries with lazy counting

The application's query layer has been refactored to introduce a new \PageResponse\ data class and helper utilities (\buildPage\, \PageResult\) that explicitly handle both paged and unpaged API requests. This change enables unpaged queries to return all results in a single response without requiring a pre-calculated total count, addressing performance concerns by allowing lazy counting for large datasets. The new \UnpagedSorted\ class and \isEmpty\ extension provide the necessary infrastructure to distinguish between paged and unpaged requests, ensuring that API responses correctly reflect the requested page size and total elements.

komga/src/main/kotlin/org/gotson/komga/application/query · high confidence

Refactored scheduler components and introduced new startup/monitoring tasks

The scheduler package has been refactored to use @Component instead of @Controller, and the legacy RootScannerController has been removed. New scheduled tasks have been added: AuthenticationActivityCleanupController now automatically deletes authentication activity records older than one month; InitialUserController creates default admin/user accounts on first startup in development mode; MetricsPublisherController publishes library, series, book, and task metrics to Micrometer; PeriodicScannerController handles library scans on startup and schedules periodic scans; and SearchIndexController manages Lucene index creation and upgrades on startup.

komga/src/main/kotlin/org/gotson/komga/interfaces/scheduler · high confidence

SQLite database engine with configurable connection pooling and Unicode search enhancements

The application has migrated its underlying database from H2 to SQLite, introducing configurable connection pooling via HikariCP and allowing users to tune pool sizes and SQLite pragmas (such as journal mode and busy timeout) through configuration. This change also enables the separation of read and write connections when Write-Ahead Logging (WAL) is active to improve performance. Additionally, the new SQLite integration includes custom user-defined functions and collations to support accent-insensitive searching and improved Unicode sorting for library items.

komga/src/main/kotlin/org/gotson/komga/infrastructure/datasource · high confidence

Search index rebuilds for readlists and supports partial text matching

The search infrastructure now includes ReadList entities in the Lucene index, ensuring that changes to readlists trigger an index rebuild so they become searchable. Additionally, the indexing process has been updated to use n-gram analysis, which allows users to find series and books by typing partial words or fragments rather than requiring exact full-word matches.

komga/src/main/kotlin/org/gotson/komga/infrastructure/search · high confidence

Series titles now sort correctly with Unicode collation

The system no longer strips accents from input data, which fixes an issue where series titles containing accented characters were not sorting correctly. By preserving the original Unicode characters, titles are now ordered according to proper Unicode collation rules, ensuring that items with diacritics appear in the expected position within lists.

komga/src/main/kotlin/org/gotson/komga/language · high confidence

Startup validation and jOOQ log cleanup

The application now verifies that the temporary directory exists and is writable before starting, preventing runtime errors caused by missing or inaccessible temp paths. Additionally, jOOQ's startup logo and tips are suppressed in the logs to reduce visual noise.

komga/src/main/kotlin/org/gotson/komga · high confidence

Support for KOReader single-resource sync format

The KOReader synchronization infrastructure now supports the single-resource sync format used by KOReader. This is achieved by introducing a new utility to parse resource indices from various progress string patterns (bracketed, unbracketed, and anchor-based) and updating the progress converter to correctly map these indices to EPUB content hrefs, ensuring reading progress is accurately tracked for books with multiple resources.

komga/src/main/kotlin/org/gotson/komga/infrastructure/koreader · high confidence

Support for serving multiple UIs with correct base URL handling

The web interface now supports serving both the main and next UI versions. An IndexController has been added to handle root and next-page routes, explicitly passing the servlet context path as the base URL to ensure assets and links resolve correctly when the application is deployed under a custom base path. Additionally, a ResourceNotFoundController was introduced to intercept 404 errors, forwarding non-API requests to the index page to enable client-side routing while preserving standard 404 responses for API endpoints.

komga/src/main/kotlin/org/gotson/komga/interfaces/mvc · high confidence

Test coverage

3 commits adding/updating tests in komga/src/test/resources/archives; Added EPUB test fixtures for metadata parsing edge cases; Added JMH benchmark infrastructure for performance testing; Added REST API benchmarks for series and book browsing; Added architecture and coding rules tests; Added test utility for temporal assertions; Added tests for ComicInfo and ReadingList XML deserialization; Added tests for ComicRack metadata and read list providers; Added tests for EPUB metadata extraction; Added tests for ISBN barcode provider; Added tests for KOReader Sync API endpoints; Added tests for KoReader progress string parsing; Added tests for Kobo Sync API endpoints; Added tests for Kobo sync token generation and KEPUB conversion; Added tests for Mylar series.json DTO deserialization; Added tests for ResourceNotFoundController; Added tests for Unicode collation behavior; Added tests for background task processing and priority handling; Added tests for bracket parameter handling in request wrapper; Added tests for datasource configuration in WAL and memory modes; Added tests for local artwork provider thumbnail selection; Added tests for multi-datasource autowiring; Added tests for multilingual search analyzers and index lifecycle; Added tests for session and authentication cookie handling; Added tests for the JOOQ data access layer; Added unit tests for Mylar series metadata provider; Added unit tests for book spreads, TOC flattening, and page loading; Added unit tests for domain model classes; Added unit tests for domain service layer; Added unit tests for media container extractors and EPUB navigation parsing; Added unit tests for the JOOQ Tasks DAO; Comprehensive MSW API mock suite for Next.js UI development; Expanded REST API test coverage.

Dependencies

Gradle wrapper upgraded to version 9.6.1 with new network settings

The Gradle wrapper has been updated from version 5.5 to 9.6.1, requiring a download of the new distribution. Additionally, new configuration properties have been added to the wrapper settings: networkTimeout is set to 10000ms, retries are disabled (0), retryBackOffMs is set to 500ms, and URL validation is enabled via validateDistributionUrl=true.

gradle · high confidence

Migrate build system to Gradle version catalog and modernize dependencies

The project has restructured its build configuration by introducing a Gradle version catalog (gradle/libs.versions.toml) to centralize dependency management, replacing the previous inline version declarations. This change upgrades the core build tooling to Gradle 9.6.1 and Kotlin 2.4.10, while updating the Spring Boot framework to version 3.5.16. Additionally, the desktop application module (komga-tray) is now configured using the new catalog and JetBrains Compose 1.11.1, and the web UI packages (komga-webui and next-ui) have been initialized with their respective dependency manifests.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 56 → 51 (-4.8)
  • Rubric changed (rubric-2026.10.1 → rubric-2026.10.5) — scores are not directly comparable.

Lenses

  • Code Health 68 → 69 (+1.2)
  • Architecture 69 → 69 (+0.2)
  • Maturity 63 → 61 (-2.5)
  • Readiness 53 → 47 (-6.2)
  • Security 65 → 52 (-13.4)
  • Domain Modelling 70 → 70 (+0.7)
  • Accessibility 50 → 47 (-3.1)
  • Performance 78 → 78 (+0.0)

Resolved (290)

  • Change coupling: Book.kt ↔ Series.kt (komga/src/main/kotlin/org/gotson/komga/domain/model/Book.kt)
  • Change coupling: Utils.kt ↔ BookDtoDao.kt (komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/Utils.kt)
  • Change coupling: Utils.kt ↔ SeriesDtoDao.kt (komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/Utils.kt)
  • Critical CVE: [GHSA redacted] (komga-webui/package-lock.json)
  • Documentation: no contributor guidance (README.md)
  • Documentation: no project overview (README.md)
  • Documentation: no usage examples (README.md)
  • Duplicated block (13–14 lines × 10) (komga/src/main/kotlin/org/gotson/komga/interfaces/api/rest/ReferentialV2Controller.kt)
  • Duplicated block (14–15 lines × 6) (komga/src/main/kotlin/org/gotson/komga/interfaces/api/rest/ReferentialV2Controller.kt)
  • Duplicated block (16–17 lines × 4) (komga/src/main/kotlin/org/gotson/komga/interfaces/api/rest/ReferentialV2Controller.kt)
  • High CVE: [GHSA redacted] (komga-webui/package-lock.json)
  • High CVE: [GHSA redacted] (komga-webui/package-lock.json)
  • High CVE: [GHSA redacted] (komga-webui/package-lock.json)
  • Medium CVE: [GHSA redacted] (komga-webui/package-lock.json)
  • Medium CVE: [GHSA redacted] (komga-webui/package-lock.json)
  • Members sharing a duplicated core (10 members, 50+ identical tokens) (komga/src/main/kotlin/org/gotson/komga/interfaces/api/rest/ReferentialV2Controller.kt)
  • Members sharing a duplicated core (4 members, 50+ identical tokens) (komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/main/SeriesDao.kt)
  • Members sharing a duplicated core (7 members, 50+ identical tokens) (komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/main/AuthenticationActivityDao.kt)
  • Outdated (compile): ch.qos.logback:logback-classic
  • Outdated (compile): ch.qos.logback:logback-core
  • …and 270 more

New (37)

  • BookDao.findAll (cyclomatic 20) (komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/main/BookDao.kt)
  • Change-coupling hub: Utils.kt → BookDtoDao.kt, SeriesDtoDao.kt, BookController.kt (komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/Utils.kt)
  • Critical CVE: [GHSA redacted] (next-ui/package-lock.json)
  • Critical CVE: [GHSA redacted] (next-ui/package-lock.json)
  • Critical CVE: [GHSA redacted] (komga-webui/package-lock.json)
  • Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
  • Duplicated block (10 lines × 2) (komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/main/PageHashDao.kt)
  • Duplicated block (15 lines × 2) (komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/BookSearchHelper.kt)
  • Duplicated block (16–17 lines × 2) (komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/main/BookDtoDao.kt)
  • Duplicated block (8 lines × 2) (komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/main/ReadListDao.kt)
  • Duplicated block (8–11 lines × 3) (komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/main/PageHashDao.kt)
  • High CVE: [GHSA redacted] (komga-webui/package-lock.json)
  • High CVE: [GHSA redacted] (next-ui/package-lock.json)
  • High CVE: [GHSA redacted] (komga-webui/package-lock.json)
  • Hotspot: komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/main/ReferentialDao.kt (komga/src/main/kotlin/org/gotson/komga/infrastructure/jooq/main/ReferentialDao.kt)
  • Hotspot: next-ui/src/composables/sse.ts (next-ui/src/composables/sse.ts)
  • Medium CVE: [GHSA redacted] (komga-webui/package-lock.json)
  • Medium CVE: [GHSA redacted] (komga-webui/package-lock.json)
  • Medium CVE: [GHSA redacted] (next-ui/package-lock.json)
  • Medium CVE: [GHSA redacted] (next-ui/package-lock.json)
  • …and 17 more

Changes since last survey

  • 38 commits — 31 feature/other, 7 fixes

By area

  • komga/src — 8 commits
  • next-ui/src — 6 commits
  • (root) — 5 commits
  • komga/build.gradle.kts — 5 commits
  • komga-webui/package-lock.json — 3 commits
  • next-ui/i18n — 3 commits
  • gradle/libs.versions.toml — 2 commits
  • komga-tray/src — 1 commit
  • komga-webui/public — 1 commit
  • komga-webui/src — 1 commit
  • komga/docker — 1 commit
  • next-ui/package-lock.json — 1 commit
  • next-ui/public — 1 commit

Notable commits

  • fix: fix(komga): incorrect koreader hash in some cases
  • fix: fix(komga): nextui reader links would not open properly if nextui is set as default
  • fix: fix(nextui): apply overflow in match table to avoid scrolling
  • fix: fix(nextui): harmonize dialog closing controls
  • fix: fix(nextui): harmonize table behaviour on mobile
  • fix: fix(nextui): ordering values were inverted in the collection/readlist edit dialogs
  • fix: fix(nextui): remove Server > User Interface page
  • change: build(docker): enable storing http sessions in database
  • change: build(docker): use java 25 for amd64/arm64 images
  • change: build(komga): refactor jooq gradle configuration
  • change: build: update Gradle to 9.8.1
  • change: chore(release): 1.29.0 [skip ci]
  • change: chore(release): 1.29.1 [skip ci]
  • change: deps(komga): bump archunit to 1.5.1
  • change: deps(komga): bump commons-lang3 to 3.21.0
  • change: deps(komga): bump jimfs to 1.3.2
  • change: deps(komga): bump junrar to 8.1.2
  • change: deps(komga): bump sqlite-jdbc to 3.53.4.0
  • change: deps(komga): bump twelve monkeys to 3.15.3
  • change: deps(nextui): bump deps
  • …and 18 more

Architecture

  • Unchanged — 0 containers · 1 contexts · 0 edges

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

gotson/komga was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 22 October 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 023ec905c10a35bbb8e29095420d266cd3adad60 — the exact code this score is about.
  • Scored under rubric-2026.10.5 — the same rubric and the same method as every other entry in this index.
  • Measured by watchdog.canine.dev using codehealth-analyzer measure-2026.10.3+preprod-fddbc92cb8df.