thunderbird/thunderbird-android
58.5
Adequate · 24 October 2026
203.9k
lines of production code
Kotlin
with Java
5
measurements over time
What this system is
This system is the Thunderbird mobile email client, implemented as a Kotlin Multiplatform application with a modular architecture. It provides core email functionality including account management, message composition, and folder synchronization across IMAP, POP3, and JMAP protocols. The application features a modern Jetpack Compose UI, comprehensive onboarding with auto-discovery, and shared components for cross-platform testing.
How it got here
2008–2024 — Kotlin migration and modular architecture
132 changes.
The project underwent a comprehensive architectural overhaul, migrating core mail protocols and backend logic from Java to Kotlin while introducing a modular structure with dedicated backend and feature modules. This period established a unified UI foundation using Jetpack Compose and the Bolt design system, alongside a new MVI-based account setup flow with auto-discovery and OAuth support. The work also included the implementation of new mail protocols like JMAP and POP3, extensive testing infrastructure, and the separation of K-9 Mail and Thunderbird app variants.
2025 — modular architecture and settings overhaul
107 changes.
This period focused on restructuring the application into a modular architecture, introducing dedicated modules for account settings, navigation drawers, and message lists. It established foundational infrastructure including a new feature flag system, centralized configuration storage, and type-safe APIs for accounts and folders. The work also delivered significant UI enhancements such as a new home screen widget, in-app notification banners, and a redesigned message reader with improved styling.
2026 — Feature expansion and architectural modernization
76 changes.
This period focused on implementing new features such as the Thundermail onboarding flow, Google Play funding, and a changelog viewer, while simultaneously modernizing the codebase with MVI architecture, type-safe navigation, and PII-safe compilation. Significant work was also dedicated to strengthening the build infrastructure, testing frameworks, and UI component catalog to support these new capabilities.
Features
Add CLI tool to migrate string resources to Compose
A new command-line interface (\resource-mover\) is introduced to automate the migration of string resources from traditional Android XML files to Compose resources. The tool accepts source and target module paths along with specific resource keys, automatically detecting the target format (Compose vs. standard XML). When migrating to Compose resources, it cleans up the string declarations by stripping XLIFF tags (e.g., \\<xliff:g\>\) to ensure compatibility with the Compose resource format. The CLI handles file creation, key replacement, and cleanup of empty source files.
cli/resource-mover-cli · high confidence
Add DemoFolder data model for demo backend
The demo backend now includes a \DemoFolder\ data class to represent folder structures within the demo environment. This serializable model defines folder attributes including name, type, message server IDs, and nested sub-folders, enabling the demo module to structure and transmit folder data consistently.
backend/demo · high confidence_
Add EML message export capability
Users can now export email messages in the EML format. This change introduces the EmlMessageExporter implementation, which handles the file copy operation from the source to the destination URI and maps underlying file system errors (such as unavailable files, read/write failures, or unknown errors) to specific message export error types for better error handling.
feature/mail/message/export/impl-eml/src/commonMain/kotlin/net/thunderbird/feature/mail · high confidence
Add JVM-specific notification module stub
A new Koin module file for the JVM target has been added to the notification feature implementation. This file defines an empty platform-specific module, serving as a structural placeholder for dependency injection configuration on JVM platforms.
feature/notification/impl/src/jvmMain/kotlin/net/thunderbird/feature/notification · high confidence
Add K-9 Mail app module with ProGuard rules and F-Droid documentation
This change introduces the new app-k9mail module, which includes a README detailing F-Droid metadata availability and a proguard-rules.pro file. The ProGuard configuration preserves critical classes and members required for runtime functionality, specifically keeping the XOAuth2Response class for OAuth2 authentication, maintaining enum constants in net.thunderbird.core.common.mail.Flag for Moshi JSON deserialization, and preserving collection interfaces in MessagingControllerCommands to prevent R8 from stripping reflection-dependent code.
app-k9mail · high confidence
Add MessageQueryRepository for querying messages by criteria
A new DefaultMessageQueryRepository has been introduced to handle message lookups based on specific criteria. This component allows the application to retrieve a local message ID by matching an account ID, folder ID, and server message ID against the underlying database, facilitating more flexible message retrieval logic.
app-common/src/main/kotlin/net/thunderbird/app/common/feature/mail/message/data · high confidence
Add ModuleInfo data class for Weblate component metadata
The weblate-cli now includes a new ModuleInfo data class to represent component metadata, storing the path, resource type, name, and slug for each module. This structure supports the CLI's ability to manage and cache information about Weblate components.
weblate-cli · high confidence
Add OpenPGP encryption detection and extraction logic
The legacy/crypto-openpgp module now includes an EncryptionDetector and OpenPgpEncryptionExtractor to identify and report OpenPGP-encrypted messages. The detector recognizes multipart/encrypted and application/pkcs7-mime (S/MIME) content types, as well as inline PGP messages that appear as the first text part without surrounding preamble or epilogue text. The extractor exposes this capability via the standard EncryptionExtractor interface, returning an "openpgp" encryption type when encrypted content is detected.
legacy/crypto-openpgp · high confidence
Add Thunderbird for Android app with ProGuard configuration
Introduced the app-thunderbird module, including a README and a ProGuard rules file. The configuration preserves specific classes and members required for Moshi serialization (such as enum constants and collection interfaces) and maintains compatibility with libraries like Glide, OkHttp, and OpenPGP, ensuring the app builds and runs correctly with code shrinking enabled.
app-thunderbird · high confidence
Add Thunderbird migration screen to onboarding
Users can now import data from Thunderbird during the onboarding process. This change introduces a new migration screen that provides options to scan a QR code for import, click to sign in via Thundermail, add a new account, or perform a direct import. The screen also includes guidance for users already using Thunderbird on desktop, encouraging them to upgrade to the latest version for QR code compatibility.
feature/onboarding/migration/thunderbird/src/main/kotlin/app/k9mail/feature/onboarding · high confidence
Add contact data model and document creation contract
The app introduces a new Contact data class to represent user contacts with fields for ID, name, email address, URI, and photo URI. Additionally, a CreateDocumentResultContract is added to standardize the user flow for creating documents via the system's ACTION\_CREATE\_DOCUMENT intent, allowing users to specify a title and MIME type when saving files.
core/android/common · high confidence_
Add demo backend and debug feature flag overrides for development builds
Debug builds of K9 Mail and Thunderbird now include a demo backend and auto-discovery configuration, allowing developers to test with simulated data without needing real account credentials. Additionally, a runtime debug override feature flag provider is registered, enabling dynamic feature flag adjustments during development.
app-k9mail/src/debug/kotlin/app/k9mail/dev · high confidence
Add internal RecyclerView layout manager utilities
The ui-utils/linear-layout-manager module now includes a copy of Android's internal LinearLayoutManager implementation and supporting classes (LayoutManager, ViewBoundsCheck, ScrollbarHelper). This brings in internal RecyclerView layout logic to support advanced list management features within the app.
ui-utils/linear-layout-manager · high confidence
Add launcher shortcut creation activity for mail accounts
Users can now create home screen shortcuts that directly open specific mail accounts or search contexts. This new LauncherShortcutActivity handles the system shortcut creation intent, allowing users to select an account from the list and pin a shortcut to their device home screen. The shortcut will display the account name (or email if no name is set) and the app logo, and launching it will open the corresponding account view or search result.
feature/widget/shortcut/src/main/kotlin/app/k9mail/feature/widget · high confidence
Add localized strings for account setup and edit screens
Added English source strings and translations for account setup and edit screens, including navigation buttons (Next/Back), server error messages, and save settings status messages (loading, error, success).
feature/account · high confidence
Add message list glance widget
A new Android home-screen widget (Glance) has been added to display a list of recent messages from the unified folders. The widget shows message subjects, senders, dates, and thread counts, and allows users to tap an item to open the message or tap a compose icon to start a new email. It respects the user's threaded view setting and sorts messages by date.
feature/widget/message-list-glance/src/main/kotlin/net/thunderbird/feature/widget · high confidence
Add onboarding permissions screen for contacts and notifications
Users now encounter a dedicated permissions screen during onboarding that checks and requests access to contacts and notifications. The screen displays the current status of each permission, allows users to grant access via a single 'Allow' action, and enables the 'Next' button only once the required permissions are granted (or hidden if not applicable, such as on older Android versions). The implementation uses the new Bolt UI theme and Material 3 components, with navigation handled via Koin dependency injection and MVI architecture.
feature/onboarding/permissions/src/main/kotlin/app/k9mail/feature/onboarding · high confidence
Add secret debug settings screen with feature flag and notification sections
A new secret debug settings screen is now available, accessible via the SecretDebugSettingsRoute which supports tabs for Notifications and Feature Flags. This screen allows users to toggle feature flags (with options to restore defaults, apply changes, and restart the main activity) and manage notification settings, including selecting accounts, choosing notification types (system and in-app), triggering notifications, and editing notification data fields like sender, subject, summary, and preview.
debug-settings · high confidence
Add secret debug settings screen with feature flag support
A new secret debug settings screen has been added to the application, accessible via a dedicated navigation route and gated by a feature flag. This location provides the UI previews, dependency injection module, and navigation wiring for the screen, which includes sections for managing debug feature flags and testing in-app notifications across multiple accounts.
feature/debug-settings/src/debug/kotlin/net/thunderbird/feature/debug · high confidence
Add sync debug logging and logcat export capabilities
The logging module now supports capturing synchronization-specific debug logs to a dedicated file (thunderbird-sync-debug.txt) and exporting them, as well as exporting Android logcat output. Users can enable or disable the sync debug log capture via the new DebugLogConfigurator, and the system provides mechanisms to export both the sync debug file and the device's logcat buffer to external destinations.
core/logging/internal · high confidence
Add temporary Draggable modifier fork for Compose Foundation 1.11.0
The Bolt UI component library now includes a temporary, internal fork of the Compose Foundation \draggable\ modifier. This addition is a workaround to support touch dragging behavior before the upstream \compose-foundation\ 1.11.0 release, with the file marked for deletion once that version is available.
bolt · high confidence
Add translation CLI data models for API responses
The translation CLI now includes Kotlin data classes (Language, TranslationResponse, Translation, TranslationLanguage) to model the structure of API responses, enabling the CLI to parse and handle translation results from the backend service.
translation-cli · high confidence
Added F-Droid listing metadata and translations for Thunderbird Android
The app's metadata for the F-Droid store has been populated with localized titles, short descriptions, and full descriptions for numerous languages (including Arabic, Belarusian, Bulgarian, Bengali, Breton, Catalan, Corsican, Czech, Welsh, Danish, German, Greek, English, Esperanto, Spanish, Estonian, Basque, Persian, Finnish, French, and Frisian). A .gitkeep file was also added to preserve the changelogs directory structure.
app-metadata/net.thunderbird.android · high confidence
Added F-Droid listing metadata for Thunderbird Beta
Added app store listing metadata for the F-Droid distribution of Thunderbird Beta, including localized titles, short descriptions, and full descriptions for multiple languages (such as Arabic, Belarusian, Bulgarian, Catalan, Czech, Welsh, Danish, German, Greek, English, Esperanto, Spanish, Estonian, and Basque). This ensures the beta version is properly presented with accurate privacy-focused messaging and feature highlights on F-Droid.
app-metadata/net.thunderbird.android.beta · high confidence
Added F-Droid metadata and changelogs for K-9 Mail
The \app-metadata/com.fsck.k9\ directory now contains the store listing assets for K-9 Mail on F-Droid. This includes full and short descriptions, titles, and version-specific changelogs for multiple languages (including English, German, Spanish, Czech, and others). The changelogs document recent updates such as the migration to Material 3, improved account setup, and various bug fixes.
app-metadata/com.fsck.k9 · high confidence
Added OAuth configuration factory for beta build
The beta build now includes a dedicated OAuth configuration factory that registers supported email providers (AOL, Fastmail, Gmail, Microsoft/Office365, Yahoo, and Thundermail/Thundermail Stage) with their specific IMAP/SMTP server hosts, client IDs, scopes, and endpoints. This enables users of the beta version to authenticate with these providers using OAuth 2.0 instead of app-specific passwords or basic auth, provided the provider is supported and the client IDs are valid.
app-thunderbird/src/beta/kotlin/net/thunderbird/android/auth · high confidence
Added OAuth configuration for AOL, Fastmail, Microsoft, Yahoo, and Thundermail
The release build now includes built-in OAuth support for AOL, Fastmail, Microsoft (Office 365/Outlook), Yahoo, and Thundermail (including stage environments). This allows users to authenticate with these providers using OAuth tokens instead of app passwords or basic auth, improving security and compatibility, particularly for Microsoft accounts where specific IMAP/SMTP scopes are now configured.
app-thunderbird/src/release/kotlin/net/thunderbird/android/auth · high confidence
Added OAuth support for AOL, Fastmail, Gmail, Microsoft, Yahoo, and Thundermail
The app now supports OAuth authentication for AOL, Fastmail, Gmail, Microsoft (Office 365/Outlook), Yahoo, and Thundermail accounts. This change introduces the \TbOAuthConfigurationFactory\ which registers the specific OAuth endpoints, client IDs, and required scopes for these providers, enabling users to sign in using their existing credentials without needing to generate app-specific passwords.
app-thunderbird/src/daily/kotlin/net/thunderbird/android/auth · high confidence
Added configuration migration API interface
The Configstore API now exposes a \ConfigMigration\ interface and associated result types, enabling the system to handle versioned configuration updates. This change introduces the contract for migrating configuration data between versions, allowing for structured updates and cleanup of obsolete keys during the migration process.
core/configstore/api · high confidence_
Added empty Koin DI modules for Thundermail feature in k9mail and thunderbird apps
New empty Koin dependency injection modules (FeatureThundermailModule) have been added for the Thundermail feature in both the k9mail and thunderbird application modules. These modules currently contain no bindings but serve as the wiring points for future feature-specific dependencies.
feature/thundermail/k9mail/src/main/kotlin/net/thunderbird/feature/thundermail, feature/thundermail/thunderbird/src/main/kotlin/net/thunderbird/feature/thundermail · high confidence
Added funding configuration store implementation
The funding feature now includes a local configuration store to manage donation appeal settings. This implementation defines the configuration schema (including fields for the last funding reminder shown activity amount and funding reminder count), handles serialization/deserialization of these values, and provides a migration layer to support future configuration updates.
app-common/src/main/kotlin/net/thunderbird/app/common/feature/funding/configstore · high confidence
Added preview for Thundermail OAuth redirect screen
Developers can now preview the Thundermail OAuth redirect screen in Compose Preview, covering default, browser-not-available, canceled, and unknown error states.
feature/thundermail/internal/common/src/debug/kotlin/net/thunderbird/feature/thundermail · high confidence
Added startup benchmarks and baseline profile generators for K-9 Mail and Thunderbird
New benchmark modules have been added for both K-9 Mail and Thunderbird to measure cold startup performance to the message list and generate startup baseline profiles. These additions include the necessary AndroidManifest files and Kotlin test classes that extend common base implementations, enabling automated performance tracking for these specific applications.
app-k9mail/benchmarks, app-thunderbird/benchmarks · high confidence
Added startup performance benchmarks with automated account setup
The benchmarks module now includes infrastructure to measure cold startup performance, reporting both time to initial display and time to full display (when message list items appear). This includes a shared baseline profile generator and a comprehensive account setup runner that automates the onboarding flow—including welcome, email entry, auto-discovery, server settings, and permissions—so benchmarks can run against a pre-configured account state.
benchmarks · high confidence
Adds Link-specific funding infrastructure for FOSS donation appeals
This change introduces the Link (FOSS) module's implementation of the funding feature, enabling donation appeals for the Thunderbird FOSS version. It registers Koin dependencies for the funding reminder system (including lifecycle observers and the reminder dialog) and provides the \LinkFundingManager\ which exposes the \FundingType.LINK\ type and handles reminder registration. The \LinkFundingNavigation\ is also added as a no-op implementation, indicating that while the reminder logic is active, no specific in-app funding flow routes are currently defined for this module.
feature/funding/link/src/main/kotlin/net/thunderbird/feature/funding · high confidence
Build plugin adds feature flag catalog validation and versioning data model
The Gradle build plugin now includes a data model for app versioning (VersionInfo) and a structured representation of feature flag catalogs (FeatureFlagCatalog) with support for per-app (Thunderbird, K-9) and per-build-type overrides. It also introduces validation logic that checks catalog consistency—ensuring overrides reference existing flag keys and do not duplicate default values—and validates catalog files against JSON schema definitions, with an option to enable format assertions.
plugin · high confidence
Catalog UI introduces theme and variant switching capabilities
The catalog component now supports switching between two distinct UI themes (K-9 UI and Thunderbird UI) and two display variants (Light and Dark). This change introduces the underlying contract and state management logic to cycle through these options, allowing users to preview the catalog under different visual configurations.
catalog · high confidence
Centralized deep-link targets for account, debug, and funding screens
The launcher now uses a new \FeatureLauncherTarget\ sealed class to define deep-link destinations for various app sections. This change consolidates navigation targets for account management (including incoming/outgoing server settings, general settings, reading/fetching/search mail settings, and account setup), debug features (secret debug settings for notifications and feature flags, plus remote feature flag configuration), and other areas like funding (renamed to Contribution) and changelog. Users benefit from a more structured and type-safe navigation foundation within the launcher, ensuring consistent routing to these specific settings and informational screens.
launcher · high confidence
Custom ItemTouchHelper supports non-destructive horizontal swipes
The app now uses a custom ItemTouchHelper implementation that allows horizontal swipe actions without removing the list item. When a user swipes an item horizontally, the view animates only to the maximum swipe distance rather than sliding completely off-screen, enabling actions like archiving or marking as read without deletion.
ui-utils/item-touch-helper · high confidence
Debug builds now include demo backend and auto-discovery for easier testing
Debug builds of the Thunderbird Android app now automatically register a demo backend and demo auto-discovery provider. This allows developers to quickly test account setup and backend interactions without configuring real credentials, streamlining the development and debugging workflow.
app-thunderbird/src/debug/kotlin/net/thunderbird/android/dev · high confidence
Debug builds now support OAuth for AOL, Fastmail, Gmail, Microsoft, Yahoo, and Thundermail
Debug builds of the Thunderbird Android app now include built-in OAuth configuration for several major email providers, including AOL, Fastmail, Gmail, Microsoft (Outlook/Office 365), Yahoo, and Thundermail (including stage environments). This allows developers to test authentication flows for these services without needing to manually configure client IDs or endpoints in the debug build. The configuration covers both IMAP and SMTP servers for each provider, enabling end-to-end testing of incoming and outgoing mail with OAuth2 authentication.
app-thunderbird/src/debug/kotlin/net/thunderbird/android/auth · high confidence
Demo backend and debug feature flags added to Thunderbird daily builds
The Thunderbird daily build variant now includes a demo backend and debug feature flag overrides. A new \developmentModuleAdditions\ Koin module registers a \DemoBackendFactory\ (which creates \DemoBackend\ instances) and a \DemoAutoDiscovery\ provider, enabling users to test with demo accounts. Additionally, \RuntimeDebugOverrideFeatureFlagProvider\ is registered to allow runtime feature flag overrides during development.
app-thunderbird/src/daily/kotlin/net/thunderbird/android/dev · high confidence
Google Play funding implementation added
This change introduces the Google Play-specific implementation for the in-app contribution feature. It includes the Koin dependency injection module, the \GooglePlayFundingManager\ and navigation logic, and a complete data layer with a \ContributionRepository\ that aggregates remote product details and local purchase history. The implementation handles one-time and recurring contributions via the Google Billing Client, including a thread-safe \BillingConnector\, product caching, and local persistence of the last purchased contribution.
feature/funding/googleplay/src/main/kotlin/net/thunderbird/feature/funding · high confidence
HTML signature support added to account identity model
The account identity model now includes fields to support HTML-formatted email signatures. Specifically, the Identity data class has been updated with a \signatureIsHtml\ boolean flag and a \signature\ string field, allowing users to define and store signatures in HTML format. This change enables the application to distinguish between plain text and HTML signatures, enhancing the flexibility of email composition for users who require rich text formatting in their signatures.
core/android/account · high confidence_
IMAP backend rewritten in Kotlin with modular commands and push support
The IMAP backend has been rewritten in Kotlin, replacing the previous Java implementation. The architecture is now split into dedicated command classes (e.g., CommandDelete, CommandSync, CommandUploadMessage) for better modularity. A new push notification system has been added, featuring ImapBackendPusher and ImapFolderPusher to manage IMAP IDLE connections and listen for folder changes. Additionally, a BackendIdleRefreshManager has been introduced to optimize alarm scheduling for idle refreshes, reducing unnecessary device wake-ups.
backend/imap · high confidence
IMAP client sends app identity and preserves folder path delimiters
The IMAP protocol implementation now includes the application name and version in the IMAP ID command sent to servers, improving server-side identification and logging. Additionally, the connection logic has been updated to retrieve and store the folder path delimiter provided by the server, ensuring that folder names are displayed and parsed correctly in the user interface.
mail/protocols/imap · high confidence_
Initial JMAP backend implementation for Thunderbird
This change introduces a new JMAP backend module that enables Thunderbird to connect to and synchronize email accounts using the JMAP protocol. It provides core functionality including account discovery, folder list synchronization (with delta updates), and message synchronization (supporting both full and delta sync). The implementation also supports setting message flags, marking messages as read, deleting messages, and moving or copying messages between folders. This allows users to add JMAP-based email accounts to the app.
jmap · high confidence
Initial repository setup and configuration
This change establishes the foundational structure for the Thunderbird for Android repository, introducing essential configuration files such as \.editorconfig\ for code formatting, \.gitignore\ and \.gitattributes\ for version control hygiene, and \gradlew\ scripts for the build system. It also adds project documentation including \README.md\, \SECURITY.md\ (with certificate fingerprints and audit details), \CODE\_OF\_CONDUCT.md\, and an \AGENTS.md\ guide for AI-assisted development, while setting the Java version to 21 via \.java-version\ and \mise.toml\.
(repo-wide) · high confidence
Initialize beta build variant configuration
The beta build variant now includes a dedicated configuration module that registers empty maps and lists for development backend factories and extra auto-discovery services, establishing the baseline dependency injection setup for this build type.
app-thunderbird/src/beta/kotlin/net/thunderbird/android/dev · high confidence
Introduce AutoDiscovery CLI for testing mail server configuration
A new command-line interface has been added to the Thunderbird for Android codebase, allowing users to manually trigger the auto-discovery process for a given email address. This tool replicates the logic used by the Android app to find mail server settings, running provider, ISP database, and MX lookup strategies in sequence. The output displays the discovered incoming (IMAP) and outgoing (SMTP) server details, including hostnames, ports, security types, and authentication methods, along with a trust indicator showing whether the settings were retrieved via trusted channels. This provides a convenient way to debug or verify autodiscovery behavior outside the mobile application.
cli/autodiscovery-cli · high confidence
Introduce ConfigStore API with automatic migration support
The \core/configstore/api\ module now provides a new configuration management system. It introduces a \ConfigStore\ interface and a \BaseConfigStore\ implementation that manages typed configuration data via \ConfigDefinition\ objects. A key capability is automatic migration: when a configuration's version increases, the store executes a defined migration strategy to transform old data and update the version, ensuring backward compatibility. The API includes type-safe \ConfigKey\ types (String, Int, Boolean, etc.), a \ConfigMapper\ for serialization, and a backend abstraction (\ConfigBackend\) with a \DefaultConfigBackendProvider\ for caching. This change establishes the foundational API for versioned, migratable configuration storage.
core/configstore/api · high confidence
Introduce DefaultAppVersionProvider for retrieving app version
A new DefaultAppVersionProvider implementation has been added to the app-common module. This component implements the AppVersionProvider interface to retrieve the current application version name from the Android package manager, handling potential errors by logging them and returning a fallback value.
app-common/src/main/kotlin/net/thunderbird/app/common/appVersion · high confidence
Introduce FeatureLauncherActivity as a unified navigation host
A new FeatureLauncherActivity has been added to serve as a central entry point for launching various app features. This activity hosts a Compose-based navigation graph that integrates multiple modules, including onboarding, account setup and editing, settings import, debug settings, funding, changelog, and Thundermail-specific flows. It manages deep-link navigation and delegates post-completion actions, such as launching the message list or finishing the activity, to injected contracts.
feature/launcher/src/main/kotlin/app/k9mail/feature/launcher · high confidence
Introduce Glean-based telemetry collection
The app now uses the Glean SDK for telemetry. This change adds a new TelemetryModule that wires up a GleanTelemetryManager, which initializes Glean with a custom HTTP uploader and build info, and provides a method to enable or disable data collection via the user-facing telemetry setting.
feature/telemetry/glean/src/main/kotlin/app/k9mail/feature/telemetry · high confidence
Introduce Google Play contribution domain and UI contracts
This change establishes the foundational domain models and UI contracts for the Google Play funding feature. It adds data classes for one-time and recurring contributions, purchase records, and contribution IDs, along with a preselection mechanism to highlight default options. The UI layer is structured using a unidirectional flow with distinct slices for the contribution list and the purchase flow, enabling users to browse available contribution tiers and initiate or manage purchases through a defined state machine.
googleplay · high confidence
Introduce K2 PiiSafe compiler plugin for compile-time PII protection
The PiiSafe compiler plugin is now available for the K2 compiler, enabling compile-time enforcement of PII handling rules and safe string representation. When a data class is annotated with @PiiSafe.HasPii, the plugin generates a custom toString() that masks properties marked with @PiiSafe.Mask (displaying "\<sensitive\>") and hides those marked with @PiiSafe.Hide, while also appending a count of hidden properties. The plugin includes two FIR checkers: one ensures that any class holding a property of a @HasPii-annotated type is itself annotated with @HasPii, and the other requires that every @HasPii-annotated class has at least one property explicitly annotated with @Mask or @Hide. The plugin is enabled via the "enabled" command-line option and is registered through standard Kotlin compiler plugin service files.
library/pii-safe/compiler-plugin · high confidence
Introduce MVI-based ViewModel and Slice contracts with Compose integration
The core UI contract module now provides a Model-View-Intent (MVI) architecture foundation for building UI components. This includes the \UnidirectionalViewModel\ interface and \BaseViewModel\ implementation for managing state, events, and side-effects in ViewModels, as well as the \UnidirectionalSlice\ interface and \BaseUnidirectionalSlice\ implementation for modularizing specific feature logic. To simplify UI layer integration, Compose extension functions (\observe\ and \observeWithoutEffect\) are added to automatically collect state and handle side-effects within composables. Comprehensive tests are included to verify state updates, effect emissions, and one-time event handling for both ViewModels and Slices.
core/ui/contract · high confidence
Introduce MessageReaderViewContract for reply actions and attachment state
The MessageReaderViewContract interface has been added to define the UI contract for the message reader, introducing support for a bottom sheet with reply actions (Reply, ReplyAll) and attachment rendering. This contract exposes state for toggling the bottom sheet visibility, managing the set of available message reader actions, and handling attachment metadata updates, along with corresponding events for opening/closing the sheet and triggering reply listeners.
feature/mail/message/reader/api · high confidence_
Introduce NotificationRegistry for managing notification lifecycle
The notification implementation now includes a DefaultNotificationRegistry that tracks notifications by unique IDs, allowing components to register, unregister, and check for the existence of specific notifications. This change enables more precise control over notification visibility and lifecycle, supporting features like dismissal and state-driven updates by maintaining a central registry of active notifications.
feature/notification/impl · high confidence_
Introduce OnboardingMigrationManager API for migration screen navigation
The onboarding module now exposes an \OnboardingMigrationManager\ interface that defines the contract for the migration screen. This API allows the UI to trigger specific user actions, including scanning a QR code, clicking to sign in with Thundermail, adding a new account, or initiating an import, thereby enabling the wiring of the Thundermail sign-in flow to the migration screen.
feature/onboarding/migration/api/src/main/kotlin/app/k9mail/feature/onboarding · high confidence
Introduce POP3 protocol support
Added a new POP3 mail protocol implementation, including the core store, folder, and message classes, along with a server settings validator and connection handling logic. This enables users to configure and use POP3 accounts for incoming mail retrieval.
mail/protocols/pop3 · high confidence
Introduce PiiSafe annotations and compiler enforcement for PII handling
This change introduces the PiiSafe library, providing annotations to control how Personally Identifiable Information (PII) is handled in data classes. Developers can now use @PiiSafe.HasPii to mark classes containing sensitive data, and apply @PiiSafe.Hide or @PiiSafe.Mask to specific properties to exclude them from logs or redact their values. The accompanying compiler plugin enforces these rules, generating errors if a class marked with @HasPii lacks annotated properties or if a class containing a PII type is not itself annotated, ensuring consistent PII protection at compile time.
compiler-plugin, library/pii-safe/annotations · high confidence
Introduce Thundermail account setup and OAuth sign-in flow
This change adds the core infrastructure for the Thundermail account setup experience, including the Add Account screen which offers a 'Sign with Thundermail' option, and the OAuth redirect screen that handles the browser-based authentication flow. It wires up the navigation routes for signing in, scanning QR codes, and completing account setup, while introducing the ThundermailOAuthViewModel to manage auto-discovery and OAuth state, all registered via a new Koin module.
feature/thundermail/internal/common/src/main/kotlin/net/thunderbird/feature/thundermail · high confidence
Introduce Thundermail onboarding navigation and UI components
This change adds the foundational navigation structure and user interface for the Thundermail account setup flow. It defines the \ThundermailRoute\ sealed interface with specific paths for adding an account, signing in via Thundermail, scanning a QR code, and completing onboarding. Additionally, it introduces the \ThundermailButtonPanel\ composable, which presents users with 'Sign in with Thundermail' and 'Scan QR code' options, gated by the \THUNDERMAIL\_ONBOARDING\_ENABLED\ feature flag.
feature/thundermail/api/src/main/kotlin/net/thunderbird/feature/thundermail · high confidence
Introduce WebView configuration interface and settings data class
The webkit module now exposes a new \ThunderbirdWebViewSettings\ interface and a \WebViewConfig\ data class to centralize WebView configuration. This allows the application to control specific rendering behaviors such as overview mode, network data blocking, dark mode preference, auto-fit width, and text zoom levels through a structured configuration object.
core/android/webkit · high confidence
Introduce Weblate CLI for managing translation components
A new Weblate CLI tool is available to synchronize local translation resources with the Weblate platform. It provides commands to create new components for local modules, update existing managed components to match a common configuration, and delete specific components. The tool supports dry-run mode for safe testing, configurable logging, and caching of API responses to improve performance.
cli/weblate-cli · high confidence
Introduce account profile repository with distinct emission handling
The account core module now exposes an AccountProfileRepository interface and its DefaultAccountProfileRepository implementation, providing methods to retrieve all account profiles, fetch a profile by ID, and update a profile. The repository ensures that flows emitted by the local data source are deduplicated using distinctUntilChanged, preventing redundant updates to consumers.
feature/account/core/src/commonMain/kotlin/net/thunderbird/feature/account · high confidence
Introduce account settings navigation routes and account removal API
This change establishes the navigation structure for the account settings feature by defining specific routes for General, Reading Mail, Fetching Mail, Advanced Fetching Mail, and Search settings, all scoped to a specific account ID. It also introduces the \BackgroundAccountRemover\ interface, providing the API contract for asynchronously removing an account by its ID.
feature/account/settings/api/src/main/kotlin/net/thunderbird/feature/account · high confidence
Introduce centralized build convention plugins
The project now uses a new \build-plugin\ module to centralize build logic, replacing scattered configurations with a set of convention plugins. This introduces standardized setups for Android applications (\thunderbird.app.android\), Android libraries (\thunderbird.library.android\), and Kotlin Multiplatform libraries (\thunderbird.library.kmp\), along with specific variants for Jetpack Compose. Users benefit from consistent compiler options, dependency management via BOMs, and integrated quality tools (Detekt, Spotless, coverage) across all modules. The change also adds support for modular signing configurations for different release types (K9, Thunderbird Beta/Daily) and enables Android resources in KMP host tests.
build-plugin · high confidence
Introduce changelog feature with version tracking and recent changes UI
This change adds the internal implementation for the changelog feature, including a new UI screen that displays release history with categorized changes (new, fixed, other) and a toggle to show recent changes. It introduces a version tracking system that persists first and last seen version codes to detect first-time and subsequent updates, and a provider that loads changelog data from JSON resources. The feature includes ViewModels for managing the changelog state and recent changes hint, along with navigation wiring and Koin dependency injection modules.
feature/changelog/internal/src/main/kotlin/net/thunderbird/feature/changelog · high confidence
Introduce changelog navigation API and configuration provider
This change adds the API layer for the new changelog feature, defining the navigation contract and configuration interface. It introduces the \ChangelogRoute\ with a base path of \app://changelog\ and two modes (\CHANGE\_LOG\ and \RECENT\_CHANGES\), along with the \ChangelogNavigation\ interface to handle navigation to this route. Additionally, it provides the \ChangelogConfigProvider\ interface, allowing consumers to supply the resource ID for the changelog index.
feature/changelog/api/src/commonMain/kotlin/net/thunderbird/feature/navigation · high confidence
Introduce core UI settings API with new setting types and view provider
This change introduces the core UI settings API module, defining a new \Setting\ interface and a \SettingViewProvider\ for rendering settings screens. It adds several new setting value types: \Text\ (with validation and transformation support), \ActionText\ (for clickable actions without an edit view), \Color\, \IconList\, \SegmentedButton\ (restricted to 2-4 options), \Select\ (with an option to display the value as secondary text), and \Switch\. Additionally, it includes \SettingDecoration\ types for \Custom\ UI, \SectionHeader\, and \SectionDivider\ to enhance the visual structure of settings screens.
core/ui/setting/api · high confidence
Introduce core feature flag infrastructure with remote catalog support
This change establishes the foundational data models, domain contracts, and UI components for the feature flag system. It introduces a \FeatureFlagResult\ sealed interface to handle enabled, disabled, and unavailable states, along with shorthand methods for checking these states. The update adds domain contracts for fetching and updating remote feature flags, including configuration for remote catalog fetch frequency and cache metadata. It also defines the data models for the feature flag catalog, flag registry, and app-specific overrides, including serialization support for different app variants. Finally, it provides the UI contract and navigation route for a new settings screen where users can view and manage remote feature flag configurations.
featureflag · high confidence
Introduce core file module with cross-platform file operations
The new core/file module provides a unified API for file management across Android and JVM platforms. It introduces a FileManager interface supporting copy, delete, and createDirectories operations, backed by platform-specific FileSystemManager implementations (AndroidFileSystemManager using ContentResolver and JvmFileSystemManager using java.io). The module also adds WriteMode (Truncate/Append) for controlling file write behavior, a DirectoryProvider for accessing platform-specific cache and files directories, and a MimeTypeResolver for identifying file types (JPEG, PNG, PDF). Comprehensive tests cover all operations on both platforms.
core/file · high confidence
Introduce core navigation abstractions for type-safe Compose navigation
The \core/ui/navigation\ module now provides the foundational interfaces and extensions for the app's navigation system. It introduces the \Route\ interface to define typed navigation destinations with base paths, and the \Navigation\ interface to allow components to register their routes with the navigation graph. Additionally, a \deepLinkComposable\ extension is added to \NavGraphBuilder\, enabling easy registration of Composable screens that support deep linking.
core/ui/navigation · high confidence
Introduce dedicated POP3 backend implementation
A new \Pop3Backend\ class has been added to handle POP3 account operations, implementing the standard \Backend\ interface. This implementation enables core email functionality such as syncing folders, downloading complete messages, setting flags, and sending messages via SMTP. However, due to protocol limitations, several advanced features are explicitly unsupported and will throw \UnsupportedOperationException\ when invoked, including uploading messages, expunging folders, moving or copying messages, marking all messages as read, searching, fetching message parts, and push notifications.
backend/pop3 · high confidence_
Introduce dedicated account editing module with server settings workflow
The new \feature/account/edit\ module provides a structured, type-safe navigation flow for editing account server settings. It introduces a three-step wizard for both incoming and outgoing servers: modify, validate, and save. The implementation includes domain use cases for loading and saving account state, Koin modules wiring the \Modify\ and \Save\ ViewModels, and UI screens that handle the transition between these states, including validation feedback and error handling.
feature/account/edit/src/main/kotlin/app/k9mail/feature/account · high confidence
Introduce dedicated serialization and SQL generation for local message search
The local search implementation now includes a dedicated serializer for LocalMessageSearch, enabling these search specifications to be persisted and restored via JSON. Additionally, a new SqlWhereClause builder has been added to convert the search condition tree into executable SQL WHERE clauses, supporting complex logical expressions (AND, OR, NOT) and custom field templates.
feature/search/impl-legacy/src/commonMain/kotlin/net/thunderbird/feature/search · high confidence
Introduce dialog-based settings implementation
This change adds a new implementation of the settings view that presents configuration options within a dialog overlay. The \DialogSettingViewProvider\ and \DialogSettingView\ compose a top bar and a list of settings, and when a user selects an item, a \SettingDialog\ appears to allow value modification. This dialog supports Text, Color, and Select setting types with dedicated input views (including text validation and debouncing for text, and color/option selection for others), while other types like Switch or SegmentedButton are handled directly in the list without a dialog. The implementation includes supporting components like \SettingItemLayout\ for list items, \AutoHeightLazyVerticalGrid\ for color selection, and various preview files for UI testing.
core/ui/setting/impl-dialog · high confidence
Introduce global database migration state tracking
Added the API and internal placeholder implementations for tracking the state of the global database migration. This includes \AccountMigrationState\ and \AppMigrationState\ models to represent statuses like NotStarted, InProgress, Completed, and Failed, along with corresponding repositories (\AccountMigrationStateRepository\ and \AppMigrationStateRepository\) to manage these states. The internal module registers these repositories via Koin, with the current implementation returning default states (NotStarted or Completed based on app state) while persistence logic is marked as TODO. Tests were added to verify the account migration state repository correctly reflects the global app migration status.
(repo-wide) · high confidence
Introduce internal changelog data models and view logic
This change adds the internal implementation for the changelog feature, introducing data classes (ReleaseItem, ChangelogIndex, ReleaseEntry, ChangelogRelease, ChangelogNote) to represent release data and JSON structures. It also defines the ChangelogContract (State, Event, Effect) and ChangelogViewModel, which loads changelog data via ChangeLogManager, respects user preferences for showing recent changes, and maps raw release items into UI-friendly ReleaseUiModel objects categorized by change type (New, Fixed, Changed).
feature/changelog/internal · high confidence_
Introduce legacy core module with foundational account, settings, and Autocrypt infrastructure
The \legacy/core\ module now provides the foundational infrastructure for the application, including the \Core\ object for early initialization and service management, the \Preferences\ class for account and settings persistence, and the \K9\ singleton for global state. It introduces the \LegacyAccountDto\ model and \LegacyAccountDtoManager\ to manage accounts, alongside \FontSizes\ for UI customization. The module also integrates Autocrypt support via header parsers and transfer message creation, and establishes the \BackendManager\ to handle mail backend instantiation and caching. Additionally, it includes the \ArchiveOperations\ controller, which now respects a feature flag to determine whether archiving marks messages as read, and adds \EmailAddressValidator\ for input validation.
legacy/core · high confidence
Introduce legacy mailstore module with folder and message store repositories
The new \legacy/mailstore\ module centralizes legacy mail storage logic by introducing dedicated repositories for folder queries (\DefaultFolderQueryRepository\) and folder details (\DefaultFolderDetailsRepository\), along with a \MessageStoreManager\ to manage \ListenableMessageStore\ instances per account. This change provides a unified interface for accessing and modifying locally stored messages and folder settings, supporting features like push notification tracking and unified inbox inclusion.
legacy/mailstore · high confidence
Introduce message export API with filename suggestion and error handling
This change adds the core API module for exporting email messages, introducing a format-agnostic interface for exporting messages via URIs, a default filename suggester that generates filesystem-safe names from subject and date, and a sealed error type to handle export failures. The result type uses a shared Outcome abstraction to represent success or failure, providing a consistent way to handle export operations across platforms.
feature/mail/message/export/api/src/commonMain/kotlin/net/thunderbird/feature/mail · high confidence
Introduce new account settings contracts and domain interfaces
This change introduces the domain and UI contracts for the new account settings implementation, defining the structure for general, reading, sending, fetching, search, and sync/notification settings. It establishes the \AccountSettingsDomainContract\ with use cases for retrieving and updating account profiles, avatars, and various mail settings, alongside specific UI contracts (e.g., \GeneralSettingsContract\, \SendingMailSettingContract\) that define the state, events, and effects for each settings screen.
feature/account/settings/impl · high confidence_
Introduce new account setup flow with auto-discovery, validation, and Thundermail integration
The account setup experience has been rebuilt to use a new type-safe navigation structure (AccountSetupNavHost) that guides users through auto-discovery, server validation, special folder selection, and display/sync options. Auto-discovery now validates OAuth support for discovered server settings and integrates Thundermail sign-in and QR code scanning flows. The new flow includes dedicated validation use cases for account configuration and special folder options, ensuring users receive clear feedback on missing or invalid settings before account creation.
feature/account/setup/src/main/kotlin/app/k9mail/feature/account · high confidence
Introduce server validation UI contract
Added the ServerValidationContract interface, which defines the MVI (Model-View-Intent) contract for the account server validation feature. This contract specifies the State, Events, and Effects required for validating server settings, including handling OAuth results, navigation, and various error conditions such as network issues, certificate errors, and authentication failures.
feature/account/server/validation · high confidence_
Introduce standalone UI component catalog app
A new standalone Android application has been added at components/ui/catalog to serve as a showcase for the Bolt design system. The app features a navigation drawer and top app bar that allow users to browse UI components organized by design system hierarchy (Atoms, Molecules, Organisms, and Templates). It supports live theme switching between K9 and Thunderbird styles, with both light and dark variants, enabling developers to preview component rendering across different themes.
components/ui/catalog · high confidence
Introduce translation CLI for Weblate integration
Added a new translation CLI tool that connects to the Weblate API to retrieve current Android language codes based on a configurable translation completion threshold. The tool provides formatted output for Android resource configurations and supported language arrays, and includes a new --log-level option to control API client logging.
cli/translation-cli · high confidence
Introduces account avatar API with support for images, icons, and monograms
The account avatar feature now exposes a unified API for managing account profile pictures. Users can have avatars represented as images (via a new \AvatarImageRepository\ for updating and deleting image URIs), system icons (defined through a new \AvatarIcon\ interface and \AvatarIconCatalog\ for lookup), or generated monograms (created via \AvatarMonogramCreator\ from names or emails). The \Avatar\ sealed interface consolidates these three display types, allowing the application to handle different avatar sources consistently.
feature/account/avatar/api/src/commonMain/kotlin/net/thunderbird/feature/account · high confidence
Introduces core common utilities: StateMachine, TimeLimitedCache, PriorityQueue, and SwipeActions
This change adds several new foundational components to the core common library. It introduces a generic, thread-safe StateMachine with history tracking and side-effect handling to manage application state transitions. A new TimeLimitedCache provides automatic expiration for cached values, and a PriorityQueue implementation offers heap-based ordering for collections. Additionally, it defines SwipeAction and SwipeActions enums/data classes to standardize swipe gesture configurations, and adds HtmlSettings and NotificationActionTokens to support UI rendering and notification action ordering.
core/common · high confidence_
Introduces domain models and identifiers for mail messages and attachments
This change defines the core domain types for the mail feature, including \Message\, \MessageThread\, \MessageAttachment\, and related value objects like \MessageEnvelope\, \MessageBody\, and \MessageSecurity\. It also introduces global identifiers (\MessageId\, \ThreadId\, \AttachmentId\) and their factories, along with interfaces for querying messages (\MessageQueryRepository\) and mapping data (\MessageDataMapper\). These models provide a protocol-agnostic representation of email content, attachments, and threading, serving as the foundation for the new database repository layer.
feature/mail/message/api/src/commonMain/kotlin/net/thunderbird/feature/mail · high confidence
Introduces funding reminder configuration storage
The app now persists funding reminder settings using a new \DefaultFundingConfigStore\ backed by a Datastore, replacing previous in-memory or ad-hoc approaches. This change registers the store in Koin via \FundingModule\, ensuring that reminder state (such as whether a second reminder has been shown) is reliably saved and retrieved, which prevents crashes caused by file collisions and improves concurrency when reading configuration values.
app-common/src/main/kotlin/net/thunderbird/app/common/feature/funding · high confidence
Introduces new data layer implementations for account profile and legacy account management
This change adds three new data source/repository classes to the account module: DefaultAccountProfileLocalDataSource, DefaultLegacyAccountManager, and DefaultLegacyAccountRepository. DefaultAccountProfileLocalDataSource now handles fetching, observing, and updating account profiles by delegating to LegacyAccountManager and mapping data via AccountProfileDataMapper. DefaultLegacyAccountManager provides a concrete implementation of LegacyAccountManager, wrapping LegacyAccountDtoManager to handle account retrieval, observation, and updates with domain mapping. DefaultLegacyAccountRepository acts as a thin wrapper around LegacyAccountManager for observing and updating legacy accounts. These components establish the data access layer for account profile and legacy account operations.
app-common/src/main/kotlin/net/thunderbird/app/common/account/data · high confidence
Introduces onboarding permissions screen contract
The onboarding flow now includes a dedicated screen for managing app permissions. This change introduces the UI contract (MVI pattern) for the permissions screen, defining the state model for contacts and notifications permissions, user events for requesting or allowing permissions, and effects for navigation and permission requests. This establishes the foundation for the new onboarding permissions step.
feature/onboarding/permissions · high confidence_
Introduces structured error types for file operations
The file module now defines a sealed interface \FileOperationError\ to categorize failures during file handling. This change introduces specific error states for when an endpoint is unavailable, when reading from a source fails, when writing to a destination fails, and a fallback for unknown errors, enabling more precise error handling for users of the file system.
file · high confidence
Introduction of MailServerDirection enum
The mail server module now includes a new \MailServerDirection\ enum to explicitly distinguish between INCOMING and OUTGOING mail server connections. This provides a structured way to identify the direction of mail server operations within the application.
core/mail/mailserver · high confidence
Introduction of TelemetryManager API for telemetry control
A new TelemetryManager interface has been added to the telemetry feature API, providing a standardized contract for managing telemetry capabilities. This interface allows the application to check if telemetry is included, enable or disable telemetry reporting, and initialize the underlying telemetry library with specific configuration details such as upload status, release channel, and version information.
feature/telemetry/api/src/main/kotlin/app/k9mail/feature/telemetry · high confidence
JMAP backend adds email management and synchronization capabilities
The JMAP backend module now supports core email operations including syncing messages (with delta sync support), deleting messages, moving and copying emails between folders, setting message flags (such as seen, flagged, draft, answered, forwarded), marking all messages in a folder as read, and uploading new messages. Additionally, it implements folder synchronization to keep local folder structures in sync with the server.
backend/jmap · high confidence
K-9 Mail app initialization and branding configuration
This change introduces the core application setup for the K-9 Mail variant, including the \K9App\ entry point and Koin dependency injection modules. It configures app-specific branding (name, theme, notification icons, and changelog), registers feature flags with K-9-specific overrides, and sets up widget providers while explicitly disabling certain components like the launcher shortcut and message compose activity in the default configuration.
app-k9mail/src/main/kotlin · high confidence
Legacy common module provides account, backend, and notification infrastructure
The new legacy/common module establishes the foundational services for the legacy email stack. It registers Koin modules for account management (including state loading, server settings updates, and activation), IMAP/POP3 backend factories with OAuth2 token handling, and notification logic that respects quiet-time settings and unified inbox preferences. The module also declares Android components such as MessageHomeActivity, MessageCompose, and various settings activities, along with required permissions and intent filters for mailto actions and NFC discovery.
legacy/common · high confidence
Message reader API introduces structured styling and reply action contracts
The message reader API now exposes a set of interfaces to decouple and standardize the message viewer's presentation and interaction logic. For styling, it introduces \CssClassNameProvider\, \CssStyleProvider\ (with subtypes for global, plain text, and signature styles), and \CssVariableNameProvider\, allowing the reader to consume centralized CSS rules and variable names rather than building them inline. For interactions, it defines \MessageReaderAction\ (Reply, ReplyAll) and a \MessageReaderBottomSheet\ composable contract, enabling the reader to present a bottom sheet for reply actions. Additionally, it establishes a domain model for attachments via \AttachmentUiItem\ (distinguishing remote/inlined images and files) and an \AttachmentViewInfoMapper\ to bridge domain and UI layers, alongside a \ReplyActionStrategy\ to determine available reply options.
feature/mail/message/reader/api/src/commonMain/kotlin/net/thunderbird/feature/mail · high confidence
Modernized message list item UI with new preview components
The message list item UI has been modernized, introducing new preview files for atoms like FavouriteButtonIcon and MessageBadge, molecules such as AdaptiveMessageItemHeaderRow, MessageBodyContent, MessageConversationCounterBadge, MessageItemAvatarCircle, and MessageItemSenderText, and organisms including MessageItem, NewMessageItem, and ReadMessageItem. These previews demonstrate configurable layouts, responsive header rows, avatar circles with monogram/image/icon support, conversation counter badges, and various message states (new, read, selected, threaded, with attachments).
feature/mail/message/list/api/src/debug/kotlin/net/thunderbird/feature/mail · high confidence
Modular Maestro UI automation framework for Thunderbird and K-9 Mail
The quality/e2e directory now provides a structured, modular framework for running end-to-end UI tests using Maestro. It introduces reusable, task-focused YAML flows (such as account setup, onboarding, and email composition) that can be combined into comprehensive test scenarios. The setup includes launcher scripts for various build variants (Debug, Daily, Beta, Release) for both Thunderbird and K-9 Mail, along with helper scripts to manage account types (demo vs. real) and environment variables, enabling consistent and reproducible testing across different app configurations.
quality · high confidence
Navigation drawer refactored into a new modular architecture with unified account support
The navigation drawer has been restructured into a new module (feature/navigation/drawer/dropdown) featuring a clean separation of concerns with dedicated UI, domain, and data layers. This change introduces support for unified accounts, allowing users to view a consolidated inbox across multiple accounts, and adds account error indications to alert users of authentication issues. The drawer now includes quick account switching via the avatar, improved folder tree rendering with configurable nesting levels, and settings access for managing folders and account options. The implementation uses Koin for dependency injection and Koin ViewModel for state management, ensuring a more maintainable and testable codebase.
feature/navigation/drawer/dropdown/src/main/kotlin/net/thunderbird/feature/navigation · high confidence
New Android permission checking infrastructure for onboarding
The app now includes a dedicated core module for managing Android permissions required during onboarding. This introduces a new \AndroidPermissionChecker\ that verifies access to Contacts and Notifications, handling API-level differences (such as implicitly granting notifications on Android 5.x and below). The change also adds a Koin dependency injection module to wire the checker and includes unit tests to validate permission states across different Android versions.
core/android/permissions · high confidence
New Autoconfig-based mail server discovery mechanism
The autodiscovery feature now includes a new implementation that discovers mail server settings using the Thunderbird Autoconfig protocol. This mechanism supports fetching configuration via provider-specific URLs (e.g., autoconfig.{domain}) and the ISPDB service (autoconfig.thunderbird.net). It also introduces an MX lookup step that queries DNS MX records to find alternative domains for configuration, with support for DNSSEC validation to mark trusted lookups. The system parses XML configuration files to extract incoming (IMAP) and outgoing (SMTP) server settings, including hostname, port, connection security (StartTLS/TLS), and authentication types (PasswordCleartext, PasswordEncrypted, OAuth2).
feature/autodiscovery · high confidence
New Compose preview helpers, foldable device support, and MVI base ViewModel
Developers can now use the new \koinPreview\ helper to render Compose previews when dependencies are injected via Koin, and \annotatedStringResource\ to display formatted strings correctly in IDE previews. The module adds support for foldable devices through \FoldableStateObserver\, which exposes the current fold/unfold state via a \StateFlow\ with debouncing. Additionally, \BaseStateMachineViewModel\ provides an abstract MVI base class that integrates a \StateMachine\ with the UI, handling state flows, one-time side effects, and event processing.
core/ui/compose/common · high confidence
New DataStore-based configuration backend implementation
The application now includes a new configuration backend implementation using AndroidX DataStore Preferences. This change introduces a factory and default backend that persist configuration data (booleans, integers, strings, longs, floats, doubles) to local preference files, along with platform-specific file managers for Android and JVM environments to handle storage paths. Tests have been added to verify read, update, clear, versioning, and key removal operations.
core/configstore/impl-backend · high confidence
New Gradle plugins for app badging, versioning, feature flags, and PII-safe compilation
The build-plugin module introduces several new Gradle plugins to enhance build automation and quality. The BadgingPlugin adds tasks to generate and verify APK badging against golden files to prevent regressions. The VersioningPlugin provides a task to print detailed application version information, including resolving labels from merged manifests and resource files. The FeatureFlagRootPlugin validates feature flag catalogs against JSON schemas, while the FeatureFlagLibraryPlugin generates type-safe Kotlin enums from those catalogs and bundles the catalog as a raw resource. Additionally, the PiiSafeGradleSubplugin integrates a K2 compiler plugin to enforce PII safety checks at compile time, and the CodeCoveragePlugin configures Kover with coverage thresholds that are disabled by default.
build-plugin/plugin · high confidence
New HTML Cleaner CLI tool for K-9 Mail and Thunderbird
A new command-line interface has been added to clean and sanitize HTML emails, supporting both K-9 Mail and Thunderbird as target applications. Users can now process HTML input files to strip disallowed elements and attributes, with the output either written to a specified file or printed to the console. The tool automatically applies the correct namespace classes and viewport meta tags based on the selected target app.
cli/html-cleaner-cli · high confidence
New Kotlin mail common library components and validation types
The mail/common module introduces several new Kotlin classes and interfaces that support server configuration, MIME parsing, and validation. ServerSettings is now a Kotlin data class that validates usernames and passwords against line breaks and exposes an isMissingCredentials property that accounts for AuthType.NONE and AuthType.EXTERNAL. ServerSettingsValidationResult is a new sealed interface that categorizes validation outcomes (Success, NetworkError, CertificateError, ClientCertificateError, AuthenticationError, ServerError, MissingServerCapabilityError, UnknownError). MIME handling gains MimeHeaderChecker for unstructured header syntax validation, MimeParameterDecoder for RFC 2045/2231 parameter decoding, FormatFlowedHelper for checking format=flowed/delsp, and MimeValue as a result container. A new Header data class and a Base64OutputStream filter are also added.
mail/common · high confidence_
New OAuth account sign-in flow with Google support
The account setup process now includes a dedicated OAuth sign-in interface for supported providers. Users can sign in with Google using a branded button that respects system dark mode, while other providers use a standard filled button. The flow handles authorization requests, token exchange, and errors such as missing browsers or canceled sessions, and displays a support link for Google sign-in issues.
feature/account/oauth/src/main/kotlin/app/k9mail/feature/account · high confidence
New QR code scanner UI for account import
The account import flow now includes a dedicated QR code scanning interface. This change introduces the domain data models (AccountData, QrCodeData) required to parse and represent account configuration from QR payloads, and defines the UI contract (QrCodeScannerContract) that manages the scanner's state, camera permissions, and user feedback (such as help text or unsupported code warnings). This provides the frontend foundation for scanning QR codes to import email accounts.
qrcode · high confidence
New RemoteFolderCreator API for folder creation
A new RemoteFolderCreator interface has been added to the backend API, allowing clients to create folders on remote mail servers. The API supports specifying whether creation is mandatory (to handle existing folders gracefully) and defines specific outcomes for success, already-exists scenarios, and various error conditions such as unsupported operations or server-side failures.
backend/api · high confidence_
New SettingsProvider ContentProvider for secure app-to-app migration
A new SettingsProvider ContentProvider has been added to the migration module, enabling secure export of user settings and passwords to trusted applications. This provider restricts access to a specific allowlist of packages (including K-9 Mail and various Thunderbird for Android builds) by verifying the caller's signing certificate SHA-256 fingerprint. When accessed by a trusted app, it exports preferences via a pipe, allowing for seamless migration of account data between apps.
feature/migration/provider/src/main/kotlin/app/k9mail/feature/migration · high confidence
New ToolbarBottomSheetDialog component with layout-aware callbacks
The ui-utils/toolbar-bottom-sheet module now includes a new ToolbarBottomSheetDialog and ToolbarBottomSheetDialogFragment that provide a modal bottom sheet with a toolbar, replacing the standard Material bottom sheet dialog. This change introduces LayoutAwareBottomSheetBehavior and LayoutAwareBottomSheetCallback to expose layout events that were previously inaccessible, enabling the toolbar to be shown when the sheet is fully expanded. The dialog also supports dismissal with a bottom sheet animation rather than a window fade-out, and handles system window insets to prevent the toolbar from appearing under the status bar when the sheet does not cover the full screen.
ui-utils/toolbar-bottom-sheet · high confidence
New UI contract for the dropdown navigation drawer
The dropdown module now exposes a formal UI contract (DrawerContract) that defines the state, events, and effects for the side menu. This contract introduces support for unified folders and starred counts within the drawer configuration, manages account selection states, and handles folder navigation events, laying the groundwork for the new dropdown-specific UI implementation.
dropdown · high confidence
New account avatar system with monograms, icons, and image support
The account avatar feature now supports three display types: monograms (derived from the user's name or email), selectable icons from a built-in catalog, and uploaded images. The implementation includes a local data source for storing avatar images, a dependency injection module wiring the repository, and UI components that render the avatar with a circular layout, selection state indicator, and click handling.
feature/account/avatar/impl/src/main/kotlin/net/thunderbird/feature/account · high confidence
New account common module for shared account setup logic and UI
A new \feature/account/common\ module has been introduced to host shared code for account setup and OAuth flows. This includes domain contracts and entities for managing \AccountState\ (including display and sync options), an in-memory repository implementation, and reusable UI components such as the \WizardNavigationBar\ (with configurable next/back button states), \AccountTopAppBar\, \AppTitleTopHeader\, and list item wrappers. The module also defines interaction modes (Create/Edit) and standardizes wizard navigation constants.
feature/account/common/src/main/kotlin/app/k9mail/feature/account · high confidence
New account image fallback and caching components added to core UI
The core UI account module now includes an AccountFallbackImageProvider that generates a drawable with the account's color as the background and a centered person icon, and an AccountImage data class that implements Glide's Key interface for disk caching based on the email address and color.
core/ui/account · high confidence
New account profile API module
A new module has been introduced to manage account profiles, exposing an API that allows retrieving account profiles (including ID, name, color, and avatar) via a repository interface. This change provides a dedicated contract for fetching and updating account profile data, decoupling profile management from the core account logic.
feature/account/profile/api/src/commonMain/kotlin/net/thunderbird/feature/account · high confidence
New account settings screens and navigation wiring
This change introduces the implementation layer for the new account settings experience. It adds the \AccountSettingsModule\ to wire up Koin dependencies for the General, Reading Mail, Fetching Mail, and Search settings screens, including their ViewModels, UseCases, and UI builders. It also registers the navigation routes in \DefaultAccountSettingsNavigation\, enabling users to access these specific configuration areas from the account settings menu.
feature/account/settings/impl/src/main/kotlin/net/thunderbird/feature/account · high confidence
New attachment card UI component with thumbnail support
The message reader now includes a new \AttachmentCard\ Compose component that displays email attachments with visual thumbnails. This component supports rendering thumbnails for remote images, inlined images (via base64 data URIs), and generic file types, along with appropriate icons and download actions. It utilizes the Bolt design system for consistent styling and theming.
feature/mail/message/reader/api/src/androidMain/kotlin/net/thunderbird/feature/mail · high confidence
New automation scripts for PR validation, release management, and changelog generation
This change introduces a suite of new scripts to the \scripts/\ directory to support CI/CD, release automation, and development workflows. The PR Sentinel system (\scripts/ci/pr-sentinel/\) enforces mandatory checks on pull requests, including Conventional Commit formatting, issue linking, AI disclosure compliance, and co-author restrictions, with automated labeling and escalation to close non-compliant PRs after three days. Release management is streamlined with \scripts/ci/merges/do\_merge.sh\ and a custom Gradle merge driver (\merge\_gradle.py\) that handles version suffix transitions between main, beta, and release branches. Changelog generation is enhanced with Python scripts (\generate\_changelog\_json.py\, \migrate\_changelog\_to\_json.py\) that convert release notes and historical XML data into validated JSON resources for in-app display. Additional utilities include a monthly merged PR report generator, a contributor list script, an Android app cycler for crash testing, and wrappers for CLI tools like autodiscovery and translation.
scripts · high confidence
New base UI module with edge-to-edge layout and language management
The legacy/ui/base module introduces a new BaseActivity that enables edge-to-edge display, automatically adjusting the status bar appearance for light and dark themes and handling system insets for the app bar and content container. It also adds AppLanguageManager to handle app-specific language overrides and listen for system locale changes, ensuring the UI updates correctly when the language is switched. Additionally, the module provides a standard toolbar layout and includes translations for common UI strings like 'Okay', 'Cancel', and 'Star button description' across multiple languages.
legacy/ui/base · high confidence
New contact intent helper for Android
A new ContactIntentHelper utility has been added to the core Android contact module, providing static methods to generate Android Intents for picking email contacts, adding email addresses to existing or new contacts, and adding phone numbers to contacts.
core/android/contact · high confidence
New core Android network connectivity module
A new \:core:android:network\ module has been introduced to centralize network state management. It provides a \ConnectivityManager\ interface and a \DefaultConnectivityManager\ implementation that uses Android's \ConnectivityManager\ with \NetworkCallback\ to track connectivity changes. The module includes a Koin DI module for dependency injection and declares the \ACCESS\_NETWORK\_STATE\ permission in its manifest, allowing other parts of the app to depend on this standardized network availability service.
core/android/network · high confidence
New core architecture APIs for identifiers and data mapping
This release introduces foundational types in the core architecture API to standardize entity identification and data conversion. It adds \BaseIdentifier\ and \BaseUuidIdentifier\ as type-safe wrappers for unique IDs, with \BaseUuidIdentifierFactory\ generating UUIDv7s to ensure time-ordered uniqueness. A \LegacyEntityIdFactory\ is provided to encode existing numeric IDs into UUIDs for seamless migration. Additionally, \DataMapper\ and \AsyncDataMapper\ interfaces are defined to enforce consistent conversion between domain models and DTOs, while the \Identifiable\ interface ensures type safety when handling entity IDs.
core/architecture/api · high confidence
New core common library for multiplatform utilities
The core/common module now provides a suite of shared utilities for the application, including an RFC-compliant email address parser with configurable validation rules, domain and hostname validation helpers, and a generic caching system with expiration and synchronization support. It also introduces a state machine with history debugging, Koin multibinding extensions for list injection, and resource management annotations to enable string resource usage in ViewModels without direct Android context dependencies.
core/common · high confidence
New core validation input field models
The core validation module now provides immutable input field models for String, Integer, Number, and Boolean types. These classes manage field state (value, error, validity) and allow updates via value changes, error setting, or applying validation outcomes, enabling consistent validation logic across the application.
core/validation · high confidence
New core/android/common module with camera, contact, and utility support
A new \core/android/common\ module has been introduced to centralize shared Android capabilities. It includes a camera capture handler that persists the captured image URI across process death to prevent crashes, a contact repository with caching and permission resolution to look up contact details and photos by email, and a \BundleCompat\ utility to safely retrieve serializable objects across Android API levels. The module also provides \CursorExtensions\ for safer database access, an \ActivityProvider\ for dependency injection, a \ResourceManager\ for accessing string resources from ViewModels, and \WebViewExtensions\ to enable algorithmic darkening.
core/android/common · high confidence
New data transfer objects for account profile and avatar storage
This change introduces new Data Transfer Objects (DTOs) and corresponding mappers to handle account profile and avatar data within the storage layer. Specifically, it adds \ProfileDto\ and \AvatarDto\ classes to represent account details and avatar information (including monograms, images, and icons), along with \AccountProfileDataMapper\ and \AvatarDataMapper\ interfaces to facilitate conversion between domain models and storage formats. This supports the decoupling of account management from legacy preferences by providing a structured way to persist and retrieve profile and avatar data.
feature/account/storage/api/src/commonMain/kotlin/net/thunderbird/feature/account · high confidence
New debug preview screens and legacy UI module wiring
Added debug-only Compose preview screens for the Account Setup Composition signature settings, the Message List item content, and the About screen to aid in visual development. Wired the legacy UI layer by introducing the \legacyUiModules\ Koin module to aggregate UI dependencies, an \AndroidManifest.xml\ declaring required permissions and intent queries, and base activity classes (\BaseListActivity\, \AccountList\) to support account and identity management screens.
legacy/ui/legacy · high confidence
New documentation and tooling for the Bolt design system and UI testing
Developers now have dedicated documentation and tooling for the Bolt Compose design system and its UI testing infrastructure. The \components/ui/bolt\ module includes a README explaining the atomic design methodology and links to the Thunderbird Bolt design system, along with an atomic design diagram. A new \components/ui/testing\ module provides a \ComposeUiTestHarness\ and \runComposeTest\ utility to standardize Compose UI tests across platforms, with clear guidance on dispatcher handling. The \components/ui/catalog\ module offers a local catalog app to preview Bolt components, and the \components/\ directory now includes an \.editorconfig\ and a README defining rules for independently buildable components.
components · high confidence
New domain entities for account configuration and folder mapping
The account setup flow now uses a new set of domain models in the common module to define account settings and folder structures. Users will see these changes reflected in the new configuration screens for display options, sync frequency, and authentication types (including a new 'None' option). Additionally, the system now supports explicit mapping of special folders (archive, drafts, sent, spam, trash) via new \SpecialFolderOption\ models, allowing for more granular control over how mail is organized.
feature/account/common · high confidence_
New domain models for message identification, flags, and attachments
The mail message API now exposes core domain types to represent message metadata and structure. Users can now work with strongly-typed identifiers for messages, including \MessageHeaderId\ for the RFC 5322 Message-ID and \MessageServerId\ for server-assigned identifiers like IMAP UIDs. Message state is represented via the \MessageFlag\ sealed interface, covering standard flags such as Read, Starred, Answered, Forwarded, Draft, Deleted, and Junk, along with support for custom flags. Additionally, \MessageAttachmentContentId\ provides a value class for handling attachment Content-IDs, including a helper to format them as 'cid:' URIs for use in HTML bodies.
feature/mail/message/api · high confidence_
New feature flag system with remote catalog support and debug UI
The app now uses a new feature flag architecture that supports both local (bundled) and remote catalogs. Users can now enable or disable remote feature flag fetching via a new debug settings screen, which also displays the current flag states and allows runtime overrides for debugging. The system evaluates flags from multiple sources (in-memory, remote, local) in a chain, with remote flags taking precedence when enabled. This enables dynamic feature control without app updates.
core/featureflag · high confidence
New folder API module and repository interfaces
The \:feature:mail:folder:api\ module now provides the core data models and repository contracts for the mail folder system. This includes new domain types such as \FolderId\, \FolderType\, \Folder\, \RemoteFolder\, and \FolderDetails\, along with a \FolderPathDelimiter\ constant and an \OutboxFolderManager\ interface for managing outbox folders. The module also introduces several repository interfaces—\FolderDetailsRepository\, \FolderQueryRepository\, \PushFolderTrackingRepository\, \PushFoldersQueryRepository\, \RemoteFolderDetailsRepository\, and \RemoteFolderQueryRepository\—which define the data access layer for folder operations.
feature/mail/folder/api/src/commonMain/kotlin/net/thunderbird/feature/mail · high confidence
New funding feature API module for donation appeal tracking
A new API module has been introduced in the funding feature to support donation appeal logic, specifically enabling the tracking of funding reminders. This includes new configuration models (FundingConfig) and keys for storing the last shown reminder timestamp and reminder count, as well as a FundingConfigStore interface for managing these settings. The module also defines a FundingManager interface for adding funding reminders tied to the current activity lifecycle, a FundingSettings interface for detailed timestamp and activity counter management, and navigation routes for the funding contribution screen.
feature/funding/api/src/commonMain/kotlin/net/thunderbird/feature/funding · high confidence
New in-app notification banners and error dialog
The Android notification API now provides Compose-based UI components for displaying in-app notifications. Users will see global banners at the top of the screen for errors, warnings, and info, as well as an inline list of notifications that scrolls with the content and collapses when scrolling down. If there are more inline notifications than can be displayed, a summary card appears with an option to open the full list in a new Error Notifications dialog. The system also supports action buttons on notifications, custom icons for different notification types, and slide-in/slide-out animations for smoother transitions.
feature/notification/api/src/androidMain/kotlin/net/thunderbird/feature/notification · high confidence
New message list API and UI contract
The message list feature now exposes a new API module defining the core contracts and UI components for the redesigned message list. This includes the MVI-based \MessageListContract\ (ViewModel and ScreenRenderer), a \MessageListScope\ for controlling scroll behavior, and a suite of atomic and molecular UI components (such as \MessageItemConfiguration\, \AdaptiveMessageItemHeaderRow\, and \MessageBodyContent\) that support configurable layouts, secondary sorting, and account indicators. The diff also introduces domain models for sorting (\SortCriteria\, \SortType\) and preferences (\MessageListPreferences\), alongside utility interfaces like \LocalDeleteOperationDecider\ and \LocalMessageUidPrefixProvider\.
feature/mail/message/list/api/src/main/kotlin/net/thunderbird/feature/mail · high confidence
New message list feature with swipe actions, archive folder setup, and accessibility support
The message list feature now includes a new UI implementation with support for swipe actions (such as delete, archive, and mark as read) on message items. Users can now set up an archive folder through a dedicated dialog, and the system automatically handles local and remote folder creation. The feature also includes accessibility improvements, providing state descriptions for screen readers and swipe gesture actions. Additionally, the message list displays avatars for contacts and supports account indicators based on folder account IDs.
feature/mail/message/list/internal/src/main/kotlin/net/thunderbird/feature/mail · high confidence
New message list home screen widget
A new Android home screen widget has been added to display a list of messages from the unified inbox. The widget shows message details such as sender, subject, date, and preview, with visual indicators for read status, attachments, and thread counts. Tapping a message opens it in the new MessageHomeActivity, while tapping the header navigates to the unified folders search view. The widget also includes a button to compose a new message and automatically refreshes when the message list changes.
feature/widget/message-list/src/main/kotlin/app/k9mail/feature/widget · high confidence
New message mapping and attachment resolution logic
The app now uses a new set of mappers in the message mapper module to convert between legacy K-9 Mail message structures and the internal domain model. This includes \DefaultMessageDataMapper\ for bidirectional conversion, \AttachmentResolver\ for handling attachment metadata and content caching, and specific mappers for legacy-to-domain and domain-to-legacy transformations. Users will benefit from more robust handling of message bodies, headers, and attachments during these conversions, ensuring data integrity when interacting with the mail system.
app-common/src/main/kotlin/net/thunderbird/app/common/feature/mail/message/mapper · high confidence
New message query repository and DI module for legacy message handling
This change introduces a new Koin module (MailMessageModule) and a DefaultMessageQueryRepository implementation within the app-common feature. The module wires up dependencies for message data mapping, attachment resolution, and sort criteria management, bridging legacy K9 sort types to the new SortCriteria domain model. The repository provides a concrete implementation for querying message IDs by criteria against the local database, enabling the message list and reader features to retrieve message identifiers efficiently.
app-common/src/main/kotlin/net/thunderbird/app/common/feature/mail/message · high confidence
New notification API types and settings for system and in-app notifications
The notification API now exposes a comprehensive set of types to define how notifications behave and appear. Users can configure sound, vibration patterns, and LED light colors via the new NotificationSettings, NotificationVibration, VibratePattern, and NotificationLight types. The API introduces NotificationSeverity to categorize urgency (Fatal, Critical, Warning, etc.) and NotificationChannel to group notifications (Messages, Miscellaneous, PushService) with specific importance levels. Lock screen visibility is controlled by LockscreenNotificationAppearance. The API also defines the core content models (SystemNotification, InAppNotification) and specific notification types like AuthenticationErrorNotification, CertificateErrorNotification, and MailNotification variants, along with a NotificationRegistry to manage notification IDs and a command system for handling user actions.
feature/notification/api/src/commonMain/kotlin/net/thunderbird/feature/notification · high confidence
New preference API and scoped change notifications
The core preference API now exposes a structured set of settings data classes (GeneralSettings, DisplaySettings, DebuggingSettings, InteractionSettings, NetworkSettings, NotificationPreference, PrivacySettings) and dedicated PreferenceManager interfaces for each category, replacing the previous monolithic access pattern. Additionally, a new scoped notification system (PreferenceScope, PreferenceChangeBroker, PreferenceChangePublisher, PreferenceChangeSubscriber) allows components to subscribe to specific categories of preference changes rather than receiving global updates, improving efficiency and decoupling.
core/preference/api · high confidence
New secret debug settings screen for feature flags and notifications
A new secret debug settings screen has been added, accessible via a feature flag, allowing users to manage feature flags and test notifications. The screen includes a Feature Flag tab where users can toggle, apply, or restore default values for runtime debug overrides, with unsaved change warnings. It also includes a Notification tab that lets users select an account and trigger various system and in-app notifications (such as new mail, authentication errors, and push service states) to verify notification behavior, with a status log showing the results of these triggers.
feature/debug-settings/src/main/kotlin/net/thunderbird/feature/debug · high confidence
New server certificate error screen with detailed certificate inspection
The server certificate error handling now presents a dedicated screen that allows users to review certificate details before accepting or rejecting the connection. This screen displays the server name, subject alternative names, validity dates, subject, issuer, and SHA-1/SHA-256/SHA-512 fingerprints. Users can expand an advanced view to see these details, accept the certificate to add it to the local key store, or navigate back. The implementation uses the Bolt UI component library and includes formatters for fingerprints and server names to ensure proper display of long strings.
feature/account/server/certificate/src/main/kotlin/app/k9mail/feature/account · high confidence
New server validation feature for account setup
The account setup flow now includes a dedicated server validation step that verifies incoming (IMAP/POP3) and outgoing (SMTP) server settings before proceeding. This feature validates server configurations, handles OAuth authorization when required, and displays specific error messages for issues like authentication failures, network errors, or certificate problems. The validation screen uses the Bolt UI theme and Material 3 components, with separate handling for incoming and outgoing server validation states.
feature/account/server/validation/src/main/kotlin/app/k9mail/feature/account · high confidence
New settings import feature for migrating from other apps
Users can now import settings and accounts from supported applications (including K-9 Mail and Thunderbird) via a new import screen. The feature allows importing from a document file, scanning a QR code, or selecting a supported app installed on the device. It handles server password prompts and OAuth authorization flows required to activate imported accounts, and integrates into the onboarding flow.
feature/settings/import/src/main/kotlin/app/k9mail/feature/settings · high confidence
New theme API interfaces for cross-platform theming
The core UI theme module now exposes a set of Kotlin Multiplatform (KMP) interfaces to define and manage application theming. This includes the \Theme\ enum for LIGHT and DARK modes, a \ThemeProvider\ interface for accessing Android resource IDs for app and dialog themes, and a \ThemeManager\ interface that extends this to include specific themes for message views and composition. Additionally, a \FeatureThemeProvider\ interface provides Compose-specific composables to apply themes to feature content, enabling consistent theme handling across the application.
core/ui/theme/api · high confidence
Onboarding navigation routes defined for Thundermail sign-in flow
The onboarding module now defines specific navigation routes for the Thundermail account setup process, including dedicated paths for signing in, scanning a QR code, and adding an account. These routes are implemented as type-safe serializable objects that extend the core navigation interface, enabling structured and predictable navigation within the onboarding experience.
main · high confidence
QR code account import feature
Users can now import existing email accounts by scanning a QR code. This change introduces a dedicated scanner screen that uses the device camera to read account configuration data, validates the payload, and writes the settings to an XML file for import. The implementation includes the camera preview UI, permission handling, and the domain logic to parse and map the QR code data into account settings.
feature/migration/qrcode/src/main/kotlin/app/k9mail/feature/migration · high confidence
Thunderbird app initialization and configuration
The Thunderbird Android app now initializes with Glean telemetry support, respecting the user's telemetry settings and release channel. It also registers specific OAuth configuration factories for AOL and Yahoo accounts and defines a Koin module that includes feature flags, widgets, and providers. Notably, the app configuration disables the MessageCompose activity, LauncherShortcutActivity, and both the MessageList and Unread widgets, indicating these features are not yet enabled or are handled differently in this specific app variant.
app-thunderbird/src/main/kotlin/net/thunderbird/android · high confidence
Thunderbird-specific feature flag configuration module
The Thunderbird app now includes a dedicated feature flag module that supports build-variant-specific overrides for daily and beta channels. This allows feature flags to be configured differently across these specific Thunderbird build variants, extending the base variant overrides with app-specific serialization and Koin dependency injection.
app-thunderbird/src/main/kotlin/net/thunderbird/android/featureflag · high confidence
Thundermail OAuth integration and account creation logic
This change introduces the core domain and UI contract for the Thundermail OAuth flow. The new CreateAccountStateUseCase handles the extraction of user identity (email, name) from the OAuth ID token and persists the resulting account state, while the ThundermailContract defines the UI state machine, including events for sign-in and OAuth results, and effects for launching the browser or navigating to server settings.
feature/thundermail/internal/common · high confidence_
API
Composer API exposes interfaces for signature sanitization and preview configuration
The mail composer module now exposes specific API contracts for handling HTML signatures. A new \HtmlSignatureSanitizer\ interface allows implementations to sanitize user-supplied HTML signatures before they are included in outgoing messages. Additionally, a \configureForSignaturePreview\ function is provided to configure WebViews for signature previews, specifically unblocking network data and disabling overview mode to ensure user-authored content renders correctly within the composer.
feature/mail/message/composer/api/src/main/kotlin/net/thunderbird/feature/mail · high confidence
Introduce navigation drawer API contracts for configuration and control
The navigation drawer feature now exposes a formal API layer defining the \NavigationDrawer\ interface for controlling drawer state (open, close, lock, unlock) and account/folder selection, alongside the \NavigationDrawerExternalContract\ which defines the \DrawerConfig\ data class and associated loader/writer interfaces. This allows external components to load and persist drawer settings such as \showUnifiedFolders\, \showStarredCount\, and the new \expandAllFolder\ preference, which controls the initial collapsed or expanded state of side menu folders.
feature/navigation/drawer/api/src/main/kotlin/net/thunderbird/feature/navigation · high confidence
Introduces FolderServerId API type
The folder API module now exposes a new FolderServerId value class, providing a type-safe wrapper for server folder identifiers within the mail feature's public interface.
feature/mail/folder/api · high confidence_
Message list API contract and event definitions
The message list feature now exposes a formal API contract module defining the domain use cases (such as managing sort criteria, folder operations, and preferences) and a comprehensive set of UI events. These events cover user interactions like message selection, swiping, archiving, moving, and searching, as well as system events for loading configurations and handling pagination, establishing the interface for the message list's behavior.
feature/mail/message/list/api · high confidence_
New AccountManager API for account management
The account management API has been refactored to use a new \AccountManager\ interface in the \:feature:mail:account:api\ module. This interface provides methods for finding, observing, creating, updating, and moving accounts, including both asynchronous and synchronous versions of create and update operations. The API uses \AccountId\ for account identification and returns flows for observing account changes, enabling more consistent and observable account management across the application.
feature/mail/account/api/src/commonMain/kotlin/net/thunderbird/feature/mail · high confidence
Architecture
Centralize core dependency wiring in the composition module
The app now consolidates the configuration of core services—specifically the config store, file management, and logging—into the \app-composition\ module. This change introduces \CoreCompositionModule\ which aggregates sub-modules for each area, ensuring that components like \FileManager\, \ConfigBackendProvider\, and the logging infrastructure (including the sync debug logger) are registered via Koin in a single, unified location.
app-composition/src/commonMain/kotlin/net/thunderbird/app/composition/core · high confidence
Centralized app initialization and startup routing in app-common
The app-common module now provides the foundational application lifecycle and startup logic for the client. A new BaseApplication class centralizes core initialization tasks, including Koin dependency injection setup, language/locale management, notification channel updates, and crash handling. This is extended by FeatureFlagApplication to handle asynchronous feature flag resolution. Startup navigation is managed by a new MainActivity that displays a splash screen until feature flags are resolved and database upgrades are handled, then routes the user to the appropriate screen via StartupRouter. Common infrastructure such as platform configuration and activity providers are also registered here.
app-common/src/main/kotlin/net/thunderbird/app/common · high confidence
Centralized core dependency wiring via Koin modules
The app now consolidates the registration of core platform services into a unified Koin module structure. This change wires up the application version provider, config store backend (using Android's file manager), file system operations (including directory providers and MIME type resolution), and the settings UI provider (using a dialog-based view). Users benefit from a more consistent and modular foundation for core app functionalities, ensuring these services are correctly initialized and available throughout the application.
app-common/src/main/kotlin/net/thunderbird/app/common/core · high confidence
Introduce :backend:api module with new Backend and BackendStorage interfaces
A new \:backend:api\ module has been created, defining the core abstractions for mail backend operations. This introduces the \Backend\ interface, which standardizes capabilities (such as push, flag support, and trash handling) and operations like syncing, message downloading, flag management, and sending. It also defines \BackendStorage\ and \BackendFolder\ for local message and folder state management, along with \SyncConfig\ and \SyncListener\ to control and report on synchronization progress. Factory interfaces (\BackendFactory\, \BackendStorageFactory\) are provided to instantiate these components per account, and a \BackendPusher\ interface handles push notification lifecycle.
backend/api · high confidence
Migrate legacy account storage to a new modular handler system
The legacy account storage implementation has been refactored into a new modular structure within the \feature/account/storage/legacy\ module. This change introduces dedicated storage handlers for account data, profiles, and avatars (\LegacyAccountStorageHandler\, \LegacyProfileDtoStorageHandler\, \LegacyAvatarDtoStorageHandler\), which manage the persistence of account settings, user profile information, and avatar details. A new \AccountKeyGenerator\ ensures consistent key generation for storage operations, while \ServerSettingsDtoSerializer\ handles the serialization of server configuration. The migration includes new data mappers (\DefaultLegacyAccountDataMapper\, \DefaultAccountProfileDataMapper\, \DefaultAvatarDataMapper\) to convert between domain objects and DTOs, and a Koin module (\AccountStorageLegacyModule\) to wire these components together. This restructuring isolates legacy storage logic, improving maintainability and separation of concerns for account data management.
feature/account/storage/legacy/src/main/kotlin/net/thunderbird/feature/account · high confidence
Move folder and message data classes to legacy mailstore module
The \CreateFolderInfo\, \FolderSettings\, and \SaveMessageData\ data classes have been moved into the \:legacy:mailstore\ module. This change consolidates the core data structures for folder configuration and message storage within the legacy mailstore component, ensuring these definitions are co-located with the storage logic they support.
mailstore · high confidence
ThemeManager implementation moved to core UI theme manager module
The ThemeManager implementation has been relocated to the core:ui:theme:manager module. This change consolidates the logic for managing app-wide and message-specific themes (light, dark, follow system) within a dedicated core component, ensuring that theme settings are persisted via GeneralSettingsManager and applied to the Android UI via AppCompatDelegate.
core/ui/theme/manager · high confidence
Behavioural changes
Account configuration defaults and data models consolidated
Account setup and management now rely on a centralized \AccountDefaultsProvider\ for default values (such as the 15-minute sync interval and 25-message visible limit) and a unified \LegacyAccount\ data class to store account settings. This change introduces dedicated enums for configuration options like \DeletePolicy\, \Expunge\, \FolderMode\, \MessageFormat\, \QuoteStyle\, \ShowPictures\, and \SortType\, ensuring consistent handling of account preferences across the application.
core/android/account · high confidence
Account removal moved to app-common with background worker support
The account removal logic has been consolidated into the app-common module, introducing a new AccountRemover class that handles the deletion of avatars, local stores, message stores, backends, and certificates, along with a DefaultBackgroundAccountRemover that triggers this process via an AccountRemoverWorker. This change ensures account removal runs asynchronously in the background with a foreground notification, decoupling the removal mechanics from legacy preferences and providing a consistent, immutable account ID-based approach for deleting accounts and their associated data.
app-common/src/main/kotlin/net/thunderbird/app/common/feature/account · high confidence
Add JVM stubs for notification icons and lights
The notification API module now includes JVM-specific implementations for notification UI resources. Notification icons (such as those for new mail, errors, and push service states) and action icons (like reply, delete, and mark as read) are now defined as stubs that throw errors if accessed on the JVM, enforcing that these resources are only used on Android. Additionally, a default notification light color is defined for the JVM target.
feature/notification/api/src/jvmMain/kotlin/net/thunderbird/feature/notification · high confidence
Add hashCode implementation to Range class
The Range class now includes a hashCode implementation consistent with its equals method, ensuring correct behavior when Range instances are used in hash-based collections like HashMap or HashSet.
token-auto-complete · high confidence
Android notification actions now route to specific app screens
The Android notification implementation now uses a pluggable intent-creator system to handle user interactions with notifications. Tapping a notification or using its action buttons now launches specific in-app destinations rather than just opening the app generically. For example, tapping an authentication error notification can now navigate directly to the incoming or outgoing server settings edit screen, and notifications requiring alarm permissions open the system settings to grant that permission. This change also introduces a dedicated dialog fragment to display error notifications as in-app banners.
feature/notification/impl/src/androidMain/kotlin/net/thunderbird/feature/notification · high confidence
Animation manager respects system settings on older Android versions
The new AnimationManager now checks the user's animation preference setting. When set to 'Follow System', it uses the device's global animation state on Android 8.0 (API 26) and above, but defaults to showing animations on older Android versions to ensure compatibility and expected behavior.
core/ui/animation/manager · high confidence
Biometric authentication prompt is now displayed in account settings
Users can now authenticate using biometrics (fingerprint, face unlock, or device credential) when configuring account server settings. This change introduces a new biometric authentication flow that leverages Android's BiometricPrompt API, ensuring the prompt is correctly shown and handled within the account settings UI.
feature/account/server/settings/src/main/kotlin/net/thunderbird/feature/account · high confidence
Bolt UI theme integration and Android accessibility fix
The Bolt UI module now provides the core theming and localization assets for the application, including the new BoltTheme, Thunderbird and K-9 logos, and localized strings for password fields and sign-in panels. On Android, password fields are now protected against a crash on API 25 and below by conditionally applying password semantics only on affected versions.
components/ui/bolt · high confidence
Centralized feature wiring and navigation drawer configuration in app-common
The app-common module now hosts the unified feature wiring module (AppCommonFeatureModule), consolidating dependency injection for account, mail, avatar, launcher, composer, and Thundermail components. It introduces concrete implementations for the navigation drawer configuration contract, allowing the app to load and save drawer settings via the existing DrawerConfigManager, and provides a MessageListLauncher that opens the MessageHomeActivity. Additionally, a LoggerLifecycleObserver ensures file logs are flushed and closed when the app goes to the background, improving log reliability.
app-common/src/main/kotlin/net/thunderbird/app/common/feature · high confidence
Centralized mail feature dependency injection in composition module
The mail feature's dependency injection configuration has been consolidated into a new \MailCompositionModule\. This module now explicitly includes the message reader module and registers the default message file name suggester and EML message exporter, centralizing the wiring for these components within the app composition layer.
app-composition/src/commonMain/kotlin/net/thunderbird/app/composition/feature/mail · high confidence
Comprehensive legacy storage preference migrations and storage editor
The legacy storage module now includes a full suite of database migrations (StorageMigrationTo2 through StorageMigrationTo30) that automatically update user preferences during app upgrades. These migrations handle critical data transformations, including converting server settings from old URI formats to JSON, fixing invalid email addresses in identities, marking Gmail accounts for OAuth migration, rewriting notification light and IMAP compression settings, and renaming preference keys like 'account\_setup\_auto\_expand\_folder' to 'auto\_select\_folder'. Additionally, the module introduces a new K9StorageEditor class that manages preference changes with transactional support, ensuring data integrity when saving user settings.
legacy/storage · high confidence
Consolidated app dependency injection wiring
The app's dependency injection configuration has been consolidated into a single \AppCompositionModule\ that aggregates the core, account, mail, and notification modules. This change centralizes the wiring of these key features, ensuring they are all included in the application's Koin setup through one unified module.
app-composition/src/commonMain/kotlin/net/thunderbird/app/composition · high confidence
Core email processing and Autocrypt handling refactored into Kotlin
The legacy core module has been significantly refactored to migrate Autocrypt operations, message view extraction, and HTML text processing from Java to Kotlin. This change introduces new Kotlin data classes and classes for handling Autocrypt headers (AutocryptHeader, AutocryptGossipHeader, AutocryptDraftStateHeader) and status (AutocryptStatusInteractor), replacing previous Java implementations. Message view extraction is now handled by the new MessageViewInfoExtractor, which processes crypto annotations and attachments, while HTML rendering logic for email sections and URI linkification has been moved to dedicated Kotlin classes (EmailSection, EmailSectionExtractor, UriLinkifier). Additionally, new data structures like MessageDetails, NotificationMessage, and OutboxState have been added to support these core email processing and notification features.
legacy/core · high confidence_
Debug settings screen is disabled in release builds
In release builds, the secret debug settings screen is now effectively disabled. The dependency injection module registers a no-op implementation for the secret debug settings navigation, ensuring that the screen's routes are not registered and the feature remains inaccessible to end users.
feature/debug-settings/src/release/kotlin/net/thunderbird/feature/debug · high confidence
Demo backend now supports folder synchronization and message sending
The demo backend has been updated to support folder synchronization and message sending. It now includes commands to refresh the folder list, sync folders, and send messages. The demo store has been updated to flatten nested folders and load message data from the mailbox folder. The demo data loader has been updated to load folder and message data from the mailbox folder.
backend/demo · high confidence
Funding feature disabled via no-op implementation
The funding feature is now effectively disabled by default, as the module registers no-op implementations for the funding manager and navigation. Users will not see any funding-related UI or functionality, and the system will report that no funding is available.
feature/funding/noop/src/commonMain/kotlin/net/thunderbird/feature/funding · high confidence
Funding reminder dialog moved to common module
The FundingReminder UI classes, including the contract, container fragment, and Compose-based dialog implementation, have been moved to the common module. This change enables the funding reminder feature to be shared between the Google Play and Link (FOSS) app variants, ensuring consistent behavior and appearance for donation appeals across different distribution channels.
feature/funding/common/src/main/kotlin/net/thunderbird/feature/funding · high confidence
IMAP protocol layer rewritten in Kotlin with new interfaces and capabilities
The IMAP protocol implementation has been converted from Java to Kotlin, introducing a set of new interfaces (ImapStore, ImapFolder, ImapConnection) to decouple the logic and improve testability. This change adds support for modern IMAP features including OAuth 2.0 authentication, UTF-8 data handling, and the IDLE command for real-time notifications. It also introduces new components like ImapFolderFetcher for remote folder management and ImapFolderIdler for background sync, while refactoring core parsing and command handling classes for better performance and maintainability.
mail/protocols/imap · high confidence
Improved activity tracking stability in the funding purchase flow
The app now uses a new DefaultActivityProvider to track the current foreground activity, which supports the decoupled purchase flow. This implementation uses WeakReferences to store the last resumed activity, helping prevent memory leaks and ensuring the app correctly identifies the active screen during funding transactions.
app-common/src/main/kotlin/net/thunderbird/app/common/activity · high confidence
Improved search type serialization with backward compatibility
The legacy search module now uses a dedicated serializer for LocalMessageSearchType that preserves the search type during serialization. To ensure backward compatibility, the serializer gracefully falls back to the 'Account' search type when encountering unknown or malformed values, preventing crashes during deserialization of older search data.
impl-legacy · high confidence
Incoming and Outgoing Server Settings UI contracts refactored
The UI contracts for incoming and outgoing server settings have been restructured to use a dedicated MVI (Model-View-Intent) architecture. The \IncomingServerSettingsContract\ and \OutgoingServerSettingsContract\ now define explicit \State\, \Event\, and \Effect\ interfaces, along with a \Validator\ interface for input validation. This change standardizes how server configuration data (such as server address, port, security type, and authentication details) is managed and validated within the settings flow, ensuring consistent behavior across both incoming and outgoing mail server configurations.
settings · high confidence
Initialize empty development module for release builds
A new ReleaseConfig.kt file has been added to the release build variant's source set. This file defines a Koin module that registers empty collections for development-specific backend factories and extra auto-discovery providers, ensuring these dependency injection bindings exist even when no debug overrides are active.
app-k9mail/src/release/kotlin/app/k9mail/dev · high confidence
Internal refactoring of the mail composer and introduction of HTML signature sanitization
The message composer module has been split into API and internal layers, with the internal layer now housing the concrete implementations for dependency injection (Koin modules), HTML settings, and signature handling. A new \DefaultHtmlSignatureSanitizer\ has been added to clean user-supplied HTML signatures before they are inserted into outgoing mail, specifically removing scripting constructs like \on\*\ event handlers and \javascript:\ URLs to prevent potential security issues. Additionally, the \SentFolderNotFoundConfirmationDialog\ has been moved to this internal module, maintaining its role in prompting users to assign a sent folder or delete a message when the configured folder is missing.
feature/mail/message/composer/internal/src/main/kotlin/net/thunderbird/feature/mail · high confidence
Introduce command-based notification handling with feature flag gating
The notification implementation has been refactored to use a command pattern for displaying and dismissing both in-app and system notifications. This change introduces specific command classes (e.g., \DisplayInAppNotificationCommand\, \DismissSystemNotificationCommand\) that gate execution on generated feature flags (\DISPLAY\_IN\_APP\_NOTIFICATIONS\ and \USE\_NOTIFICATION\_SENDER\_FOR\_SYSTEM\_NOTIFICATIONS\). The \DefaultNotificationManager\ now delegates to \DefaultNotificationSender\ and \DefaultNotificationDismisser\, which route notifications to the appropriate commands based on type. Additionally, \DefaultInAppNotificationStream\ and \DefaultSystemNotificationStream\ provide decoupled \StateFlow\ access to registered notifications for UI consumption.
feature/notification/impl/src/commonMain/kotlin/net/thunderbird/feature/notification · high confidence
Introduce new Welcome screen with responsive layout and Bolt UI components
The onboarding welcome screen has been replaced with a new implementation that uses the Bolt UI component library (net.thunderbird.components.ui.bolt). The layout is now responsive, dynamically adjusting the logo and background circle sizes for small screens, and utilizes a scrollable column structure. The screen title is now dynamically sourced via AppNameProvider instead of being hardcoded, and the visual theme has been updated to use Bolt's Surface, ButtonFilled, and TextDisplayMediumAutoResize components.
feature/onboarding/welcome/src/main/kotlin/app/k9mail/feature/onboarding · high confidence
Introduce platform-specific MailPart type aliases for message reader
Added platform-specific implementations for the MailPart abstraction: on Android, MailPart is now an alias for the K-9 Mail Part class, while on JVM it remains an interface. This change enables the message reader to access underlying mail part data structures directly on Android, supporting the integration of attachment rendering with Compose in the legacy MessageContainerView.
feature/mail/message/reader/impl/src/androidMain/kotlin/net/thunderbird/feature/mail, feature/mail/message/reader/impl/src/jvmMain/kotlin/net/thunderbird/feature/mail · medium confidence
Introduces CSS class name provider for message reader styling
A new DefaultCssClassNameProvider has been added to manage CSS class names for the message reader, allowing styling to be driven by a provider rather than hardcoded values. This implementation supports a feature flag (USE\_NEW\_MESSAGE\_READER\_CSS\_STYLES) that determines whether new, namespaced CSS classes are used for plain text messages and signatures, or if legacy K-9 Mail classes are retained for backward compatibility.
app-common/src/main/kotlin/net/thunderbird/android/feature/mail · high confidence
Introduces structured domain models and UI contract for server certificate errors
The certificate feature now defines specific domain entities to represent server certificate errors and their properties. \ServerCertificateError\ captures the hostname, port, and certificate chain, while \ServerCertificateProperties\ exposes detailed certificate metadata such as subject alternative names, validity dates, issuer, and SHA fingerprints. A new \FormattedServerCertificateError\ entity combines the hostname with these properties for display. Additionally, the \ServerCertificateErrorContract\ establishes the UI state and event handling for the error screen, including actions to show advanced details, accept the certificate, or navigate back.
certificate · high confidence
Introduces typed account identifiers and unified account support
The account API now uses a dedicated \AccountId\ type (backed by a UUID) and an \Account\ interface that implements \Identifiable\, replacing previous loose identifier handling to improve type safety. A new \UnifiedAccountId\ constant (nil UUID) and associated helpers (\isUnified\, \requireReal\) allow the system to distinguish and protect against operations on the special unified aggregation account. Additionally, a \GetDefaultAccountId\ use-case interface is provided to retrieve the default account identifier.
feature/account/api/src/commonMain/kotlin/net/thunderbird/feature/account · high confidence
Localized folder display names and locale-sensitive sorting
The legacy folder UI module now provides localized display names for special mailboxes (Inbox, Outbox, Drafts, Sent, Trash) across many languages and implements locale-sensitive alphabetical sorting for folder lists, ensuring that folder names appear in the correct order for the user's language settings.
legacy/ui/folder · high confidence
Message reader styling and reply actions
The message reader now uses a new CSS styling system that applies consistent global styles (such as font size, overflow handling, and blockquote borders) and specific styles for plain text pre-elements and signatures, replacing the previous direct CSS construction. This change is gated by the UseNewMessageReaderCssStyles feature flag, which allows users to opt out if they prefer the legacy dark-mode-specific styling. Additionally, a bottom sheet has been added to the message reader interface, providing quick access to reply actions like Reply and Reply All.
feature/mail/message/reader/impl/src/commonMain/kotlin/net/thunderbird/feature/mail · high confidence
Migrate legacy UI components to MVI architecture
The legacy UI module has been refactored to adopt a Unidirectional ViewModel (MVI) pattern. New contract interfaces have been introduced for the Account Setup Composition screen, the About settings screen, and the Message Details view, defining explicit State, Event, and Effect types. This change decouples UI logic from presentation, providing a structured foundation for future feature additions and bug fixes in these areas.
legacy/ui/legacy · high confidence_
Migration of mail/common module to Kotlin
The core mail library components in the mail/common module have been converted from Java to Kotlin. This includes fundamental classes such as Address, AuthType, Message, and various filter utilities (Base64, Hex, PeekableInputStream), as well as new abstractions like MimeType and MessageDownloadState. For users, this change primarily ensures consistent language usage within the codebase and may introduce minor behavioral nuances in string handling or null-safety, but the public API and functional behavior of the mail protocol handling remain preserved.
mail/common · high confidence
New HTML sanitization library with strict security and formatting rules
The \html-cleaner\ module has been extracted into a dedicated library to provide robust HTML sanitization for email display. This new cleaner removes dangerous \meta http-equiv="refresh"\ tags to prevent automatic redirects, moves \\<style\>\ tags out of anchor elements to ensure valid HTML structure, and preserves \\<s\>\ (strikethrough) tags for better text formatting. It also normalizes table structures by adding missing \\<tbody\>\ tags and ensures output is compact and valid.
library/html-cleaner · high confidence
New account setup screens and configuration defaults
The account setup flow now includes dedicated screens for Display Options (account name, display name, signature) and Sync Options, allowing users to configure how their account behaves. The default sync interval has been changed to 15 minutes, and the default number of messages to display has been increased to 100. Additionally, notifications are enabled for new accounts by default.
setup · high confidence
New accounts now enable push notifications for the inbox by default
When creating a new account, the app now automatically enables push notifications for the inbox folder if the \push\_enabled\_on\_inbox\_by\_default\ feature flag is active. This behavior is implemented in the \AccountCreator\ within \app-common\, which checks the feature flag and uses the \SetPushForFolderUseCase\ to activate push on the newly created inbox. Additionally, account creation now includes logic to automatically assign a chip color from a shared pool and generate a monogram avatar for the new account profile.
app-common/src/main/kotlin/net/thunderbird/app/common/account · high confidence
New server settings UI with biometric-protected passwords and stricter validation
The server settings feature now uses a new UI implementation that enforces stricter validation rules and adds biometric protection for password visibility. Server names are validated as legal hostnames or IP addresses, and IMAP prefix fields reject blank (but allow empty) values. When editing existing accounts, the password field requires biometric or screen-lock authentication before the password can be unmasked, and the secure window flag is applied to prevent screenshots. The incoming server settings screen also handles unsupported protocols gracefully by falling back to manual configuration defaults instead of crashing.
feature/account/server/settings/src/main/kotlin/app/k9mail/feature/account · high confidence
New startup routing and database upgrade interception
The app now intercepts startup to check if a database upgrade is required; if so, it launches the UpgradeDatabaseActivity and finishes the current activity. Additionally, startup routing has been extracted into a StartupRouter that deletes incomplete accounts and directs users to the onboarding flow if no accounts are set up, or to the MessageHomeActivity otherwise.
app-common/src/main/kotlin/net/thunderbird/app/common/startup · high confidence
Notification resources centralized in legacy common module
The notification resource provider has been moved to the legacy common module, centralizing the definitions for notification icons (such as warning, mark-as-read, delete, and star), channel names, and action labels. This change ensures that notification UI elements are consistently sourced from a single location within the legacy codebase.
legacy/common · high confidence_
OAuth flow now handles browser unavailability and refines result modeling
The OAuth account setup screen now explicitly handles scenarios where the device browser is unavailable, surfacing a specific error state to the user rather than failing silently or with a generic exception. This change introduces new domain models (AuthorizationIntentResult, AuthorizationResult, OAuthResult) and a UI contract that distinguish between success, cancellation, and browser-not-supported conditions, ensuring the user receives clear feedback during the authentication process.
oauth · high confidence
OAuth import flow handles missing browser gracefully
The settings import UI now includes an authentication view model that manages the OAuth login process for legacy accounts. A key behavioral improvement is that if no browser is available on the device to complete the OAuth handshake, the import flow no longer crashes; instead, it catches the resulting exception and displays a specific 'Browser not found' error state to the user.
import · high confidence
OAuth sign-in UI previews updated to use Bolt theme 2
The debug preview files for the account OAuth feature (AccountOAuthContent, SignInView, and SignInWithGoogleButton) now use the \net.thunderbird.components.ui.bolt.PreviewWithTheme\ utilities. This switches the preview rendering from the previous theme setup to Bolt theme 2, ensuring that design previews for the OAuth sign-in flow reflect the updated theming.
feature/account/oauth/src/debug/kotlin/app/k9mail/feature/account · high confidence
Onboarding flow restructured with dedicated navigation host and module
The onboarding entry point has been refactored to use a new \OnboardingModule\ for dependency injection and a \DefaultOnboardingNavigation\ implementation that registers the main onboarding route. The internal flow is now managed by an \OnboardingNavHost\, which orchestrates navigation between the Welcome, Migration, Account Setup, Settings Import, and Permissions screens. This change consolidates the onboarding logic into a single, type-safe navigation graph, ensuring that actions like importing settings or completing account setup correctly transition users to the next appropriate step, such as the permissions screen.
feature/onboarding/main/src/main/kotlin/app/k9mail/feature/onboarding · high confidence
Onboarding migration module defaults to no-op implementation
The onboarding migration feature now includes a default no-op implementation that disables migration functionality and renders an empty screen. Users will not see any migration options or screens during onboarding unless a specific migration manager is provided to replace this default.
feature/onboarding/migration/noop/src/main/kotlin/app/k9mail/feature/onboarding · high confidence
OpenPGP API library updated to version 12 with new result models
The openpgp-api library has been updated to version 12, introducing new Parcelable models for handling cryptographic results. AutocryptPeerUpdate now supports mutual encryption preferences via the PreferEncrypt enum. OpenPgpDecryptionResult has been versioned to include session keys and decrypted session keys. OpenPgpSignatureResult now uses enums for sender status and includes confirmed user IDs, improving signature verification accuracy.
openpgp-api · high confidence
OpenPGP API library v12 with modernized service connection and Android 14 support
The OpenPGP API library has been updated to version 12, introducing a new \OpenPgpApiManager\ that manages the connection to the crypto provider using \DefaultLifecycleObserver\ to automatically handle binding and unbinding with the host app's lifecycle. The underlying AIDL interface has been upgraded from \IOpenPgpService\ to \IOpenPgpService2\, which uses pipe IDs for output streams to prevent data truncation issues found in the previous version. Additionally, the library now supports Android 14 (API 34) and Baklava (API 35) background activity start modes via \OpenPgpIntentStarter\, ensuring that crypto provider intents can be launched correctly on modern Android versions without being blocked by background start restrictions.
plugins/openpgp-api-lib · high confidence
POP3 backend rewritten in Kotlin with improved message download handling
The POP3 backend implementation has been converted from Java to Kotlin, introducing dedicated command classes (CommandDownloadMessage, CommandRefreshFolderList, CommandSetFlag) to handle specific operations. Message downloading now explicitly persists the full download state (MessageDownloadState.FULL) upon completion, ensuring local storage accurately reflects the downloaded content. Folder list synchronization has been refined to correctly create the INBOX folder with the appropriate FolderType if it is missing from the local storage, and flag updates are now handled via a dedicated command that respects server-side flag support.
backend/pop3 · high confidence
Preference settings are now managed by scoped, modular managers with live state updates
The core preference system has been refactored to replace the monolithic K9 object with a set of specialized, scoped preference managers (e.g., for display, debugging, interaction, network, notification, and privacy settings). Each manager now exposes configuration via StateFlow, allowing UI components to react to changes in real-time. The system introduces a scoped notification mechanism via DefaultPreferenceChangeBroker, ensuring that when settings change, only the relevant managers (e.g., DisplayCore, DisplayVisual, Interaction) reload their state, improving performance and consistency. This change also migrates storage to a structured Storage/StorageEditor pattern, ensuring that settings like debug logging levels, display themes, and notification behaviors are persisted and updated reliably across the app.
core/preference/impl · high confidence
Refactor account edit navigation and server settings save flow
The account edit feature has been refactored to use type-safe navigation routes for incoming and outgoing server settings, replacing previous navigation patterns. The save server settings flow now utilizes a dedicated contract with a unidirectional view model, introducing specific events for saving and navigating back, and effects for navigating to the next step or returning. An external contract defines the interface for updating server settings, handling success and failure states including account not found and unknown errors.
edit · medium confidence
Refactor autoconfig result types to include MX lookup trust status
The autoconfig module now uses a sealed interface \AutoconfigParserResult\ to represent either successfully extracted server settings or a parser error, replacing the previous return structure. Additionally, a new \MxLookupResult\ type has been introduced for MX resolution, which includes an \isTrusted\ boolean property indicating whether the DNS results were securely retrieved (e.g., via DNSSEC or a secure channel).
autoconfig · high confidence
Refactored IMAP folder list refresh to use new BackendStorage API
The IMAP backend now uses a dedicated \CommandRefreshFolderList\ class to synchronize folder lists, replacing previous inline logic. This change introduces support for \FolderType\ in the storage layer and correctly handles IMAP server prefixes by normalizing server IDs before comparison, ensuring that folder names are displayed correctly and prefixes are not duplicated. It also captures and returns the folder path delimiter from the server during the sync process.
backend/imap · high confidence_
Refactored folder creation and dependency injection for IMAP accounts
The mail feature module has been refactored to streamline dependency injection and improve folder creation logic. A new RemoteFolderCreatorResolver now selects the appropriate folder creation strategy based on the account protocol, using an IMAP-specific factory for IMAP accounts and a no-op creator for others, which prevents crashes when creating folders on non-IMAP (e.g., POP3) accounts. Additionally, the module introduces a LegacyMessageSource wrapper to maintain backward compatibility with legacy message formats while preserving PII safety, and updates the Koin module to use concrete factories instead of named injections.
app-common/src/main/kotlin/net/thunderbird/app/common/feature/mail · high confidence
Refactored notification command outcomes to use mobile components
The notification API module has been refactored to replace the previous outcome handling with a new structure based on mobile components. This change introduces a type-safe \NotificationId\ value class to wrap integer identifiers, ensuring type safety for notification IDs. It also redefines command execution results using a new \NotificationCommandOutcome\ typealias that leverages the \Outcome\ type from the core components, distinguishing between \Success\ (including \Executed\ and \NoOperation\ states) and \Failure\ (including \UnsupportedCommand\ with specific reasons like disabled feature flags). This provides a more robust and consistent way to handle notification command results across the application.
feature/notification/api · high confidence_
Refactored storage layer with new abstraction and message save behavior change
The storage module has been refactored to introduce a Storage interface, replacing the concrete DefaultStorage class (now renamed to InMemoryStorage) to provide a cleaner abstraction for preference handling. Additionally, the message save operation behavior has changed from a replace strategy to an update strategy, affecting how existing messages are persisted in the database.
storage · high confidence
Rewrite SMTP transport in Kotlin with improved error handling and OAuth support
The SMTP transport implementation has been rewritten in Kotlin, introducing more robust network error handling and proper support for the OAUTHBEARER SASL method. This change fixes STARTTLS negotiation issues, ensures standard read and connect timeouts are applied, and adds logging for sensitive responses when debug mode is enabled. It also introduces new exception types like MissingCapabilityException and EnhancedStatusCode to provide clearer feedback on server capability mismatches and authentication failures.
smtp · high confidence
SMTP protocol layer rewritten in Kotlin with new response parser
The SMTP transport implementation in the mail/protocols/smtp module has been converted from Java to Kotlin. This change introduces a new \SmtpResponseParser\ to handle SMTP greeting and EHLO responses, including support for enhanced status codes (RFC 2034) and more robust parsing of multi-line replies. The \SmtpServerSettingsValidator\ has been updated to use this new parser and transport, improving the reliability of server settings validation. Additionally, the module now includes a \MockSmtpServer\ for testing, allowing for more comprehensive unit tests of the SMTP interaction flow.
mail/protocols/smtp · high confidence
Support for updating message list sort criteria via legacy account management
The message list feature now includes a new use case, LegacyUpdateSortCriteria, which allows users to change how messages are sorted. This implementation bridges the new domain model with the legacy account system, handling sort updates for both specific accounts (via the LegacyAccountManager) and the unified account (via K9 settings).
app-common/src/main/kotlin/net/thunderbird/app/common/feature/mail/message/list · high confidence
Telemetry feature defaults to no-op implementation
The telemetry module now registers a NoOpTelemetryManager as the default implementation of TelemetryManager. This ensures that telemetry calls are safely ignored (returning false for inclusion checks and performing no operations for enable/init) when the active telemetry build variant does not include a real analytics provider, preventing runtime errors while keeping the feature interface consistent.
feature/telemetry/noop/src/main/kotlin/app/k9mail/feature/telemetry · high confidence
Thunderbird app branding and theme providers are now concrete
The app now registers specific implementations for core providers, ensuring that the app name, brand name, and file prefix are derived from Thunderbird-specific resources (e.g., 'thunderbird' prefix). Push notification icons are now explicitly set to the Thunderbird white logo. Additionally, the feature theme provider is wired to use the new \ThunderbirdBoltTheme\, and the changelog config points to the Thunderbird-specific changelog index, replacing any previous generic or placeholder configurations.
app-thunderbird/src/main/kotlin/net/thunderbird/android/provider · high confidence
Thunderbird migration launcher now uses QR code scanning
The migration launcher module for Thunderbird has been updated to replace the previous no-op implementation with a functional K9MigrationManager. This change introduces support for QR code scanning during the migration process by integrating the QrCodeScannerActivityContract, allowing users to initiate migration via QR code rather than a blank or inactive interface.
feature/migration/launcher/noop/src/main/kotlin/app/k9mail/feature/migration · high confidence
Thunderbird release build initializes empty development service providers
The Thunderbird release build now includes a dedicated configuration module that registers empty collections for development backend factories and extra auto-discovery services. This ensures that the application's dependency injection container is properly initialized with these specific development-oriented services, even when no custom implementations are provided in the release variant.
app-thunderbird/src/release/kotlin/net/thunderbird/android/dev · high confidence
Thunderbird-specific account migration via QR code
The account migration feature is now limited to Thunderbird users. This change introduces a new \MigrationManager\ API and a Thunderbird-specific implementation (\TbMigrationManager\) that enables importing accounts by scanning QR codes. Users migrating from Thunderbird can now use the integrated QR code scanner to import their account settings directly.
feature/migration/launcher/api/src/main/kotlin/app/k9mail/feature/migration, feature/migration/launcher/thunderbird/src/main/kotlin/app/k9mail/feature/migration · high confidence
Thunderbird-specific funding and CSS configuration wired into feature module
The app now registers Thunderbird-specific implementations for funding settings and CSS class name generation within the core feature module. TbFundingSettings bridges the funding logic to K9's existing settings storage (K9.fundingReminderReferenceTimestamp, etc.) and the new FundingConfigStore, ensuring funding reminders and activity tracking are persisted correctly. Additionally, a DefaultCssClassNameProvider is registered to generate CSS class names based on the application ID, supporting consistent styling in the message reader.
app-thunderbird/src/main/kotlin/net/thunderbird/android/feature · high confidence
Thunderbird-specific widget providers and configuration
Thunderbird now registers its own widget providers (MessageListWidgetProvider and UnreadWidgetProvider) via a dedicated Koin module, ensuring that the app uses its specific package namespace for these widgets. This change maintains compatibility with existing home-screen widgets created by previous versions by preserving the fully qualified class names, while allowing the widget behavior to be configured specifically for the Thunderbird build.
app-thunderbird/src/main/kotlin/net/thunderbird/android/widget · high confidence
Unread widget restructured with new configuration and migration logic
The unread widget has been refactored into a dedicated feature module with a new configuration flow and data layer. Users can now configure the widget to display unread counts for a specific account, a specific folder, or the unified folders view. The widget configuration activity and fragment have been updated to support this selection, including handling account and folder choices via new result contracts. A migration layer has been added to upgrade existing widget configurations from using folder names to folder IDs, ensuring compatibility with the new data model. The widget provider now uses a coroutine-based scope for updates and integrates with the new account and folder repositories.
feature/widget/unread/src/main/kotlin/app/k9mail/feature/widget · high confidence
Update legacy design system icons to Material 3 outlined style
The legacy design system's icon assets have been replaced with Material 3 outlined versions. This change updates the visual appearance of UI elements across the app to align with the Material 3 design language, ensuring consistency with the outlined icon style.
core/ui/legacy/designsystem · high confidence
Updated OAuth configuration for K-9 Mail builds
The K-9 Mail-specific OAuth configuration factory has been updated to include Thundermail (tb.pro) and its stage environment, alongside existing support for AOL, Fastmail, Gmail, Microsoft, and Yahoo. This change ensures that users connecting to Thundermail accounts can authenticate via OAuth, while also updating the client IDs and redirect URIs for debug and release builds to match the respective application identifiers.
app-k9mail/src/debug/kotlin/app/k9mail/auth, app-k9mail/src/release/kotlin/app/k9mail/auth · high confidence
Updated app icon assets and added debug build variants
The images folder now includes new SVG source files for the K-9 Mail logo, specifically adding versions for the debug build (\K-9\_Mail-debug.svg\, \K-9\_Mail-compose-demo.svg\) and a no-shadow variant (\K-9\_Mail-no-shadows-debug.svg\). These updates replace or supplement the existing standard and EPS assets to support distinct visual identities for development builds and specific UI contexts.
images · high confidence
Fixes
TokenCompleteTextView state restoration no longer duplicates tokens
Restoring the view's state after a configuration change (such as a screen rotation) now correctly preserves the token list and any trailing text without duplicating the token content. Previously, restoring from a collapsed state could result in the raw token text appearing multiple times in the full text; this fix ensures the internal hidden content is restored accurately, maintaining data integrity and preventing visual glitches.
library/token-auto-complete · high confidence
Test coverage
Add InMemoryBackendFolder for testing; Add InMemoryBackendStorage for testing; Add debug previews for account settings UI components; Add preview for Thunderbird migration onboarding screen; Added Changelog screen preview for design verification; Added Compose UI previews for the message list screen and archive dialogs; Added Compose UI testing utilities and validation tests; Added JVM tests for Java-compatible notification sender; Added TestMessage for mail testing utilities; Added UI previews for server validation screens; Added UI previews for the Google Play contribution screen; Added UI previews for the navigation drawer components; Added debug previews for account edit server settings; Added debug previews for account server settings screens; Added debug previews for server certificate error screens; Added debug previews for the QR code scanner UI; Added debug previews for the onboarding permissions screen; Added debug-time UI previews and test fakes for account components; Added dependency injection and notification icon provider tests; Added dependency injection and notification icon tests for the Thunderbird app module; Added fake notification icon implementations for testing; Added fake notification implementations for testing; Added host tests for notification banner UI components; Added layout previews for the account avatar component; Added preview for the message list widget content; Added quality tests to enforce standard logging usage; Added test fakes for notification registry and stream; Added test utilities and assertions for Kotlin Multiplatform; Added tests for AccountIdFactory and UnifiedAccountId; Added tests for CreateAccountStateUseCase; Added tests for DefaultActivityProvider lifecycle tracking; Added tests for DefaultFundingConfigStore; Added tests for EML message export functionality; Added tests for InMemoryAccountCache; Added tests for QR code migration feature; Added tests for SortCriteria validation; Added tests for Theme2 light theme text selection highlighting; Added tests for account and app migration state validation; Added tests for account and folder creation utilities; Added tests for account color selection, creation, and default configuration; Added tests for account edit server settings; Added tests for account profile repository operations; Added tests for account server settings validation and UI components; Added tests for avatar icon catalog, monogram creation, and local image data source; Added tests for feature flag build type resolution; Added tests for folder ID factory and legacy ID conversion; Added tests for funding navigation routes; Added tests for legacy account storage components; Added tests for message and attachment ID factories; Added tests for message composer signature and HTML settings; Added tests for message export file name suggestion; Added tests for message query, attachment resolution, and data mapping; Added tests for message reader CSS styling and attachment handling; Added tests for notification registry, command execution, and dismissal logic; Added tests for server certificate module components; Added tests for the account server validation feature; Added tests for the in-memory TestConfigBackend utility; Added tests for unread widget data provider and migration logic; Added unit tests for ChangelogProvider and ChangelogVersionHistory; Added unit tests for Google Play funding feature; Added unit tests for account data layer components; Added unit tests for account domain entities and state repository; Added unit tests for account settings implementation; Added unit tests for account setup module; Added unit tests for notification action intent creation; Added unit tests for the OAuth account flow; Added unit tests for the Thunderbird onboarding migration screen; Added unit tests for the message list feature; Added unit tests for the new dropdown navigation drawer module; Fake account profile now includes avatar data; New Compose testing utilities for MVI ViewModels and UI components; New in-memory account manager for testing; New mail testing utilities and test infrastructure; New testing utilities for Robolectric and storage mocking.
Dependencies
Introduce modular build-plugin and Thunderbird Mobile Components
The project now includes a dedicated \build-plugin\ module that centralizes Gradle plugin configuration (Kotlin, Android, Compose, Detekt, Spotless, Kover) and a new \components\ module hosting the Thunderbird Mobile Components library. This library provides the \ui:bolt\ design system (JetBrains Compose Material 3, Landscapist, Navigation), a \ui:catalog\ demo app, and a \ui:testing\ framework for Compose UI tests. The main app modules (\app-common\, \app-k9mail\, \app-thunderbird\) are wired to these new shared dependencies, establishing a unified UI and testing foundation for the Thunderbird application.
(dependencies) · high confidence
Upgraded Gradle wrapper to 9.7.0 and configured JVM toolchain
The project now uses Gradle 9.7.0 for builds, replacing the previous version. Additionally, a new \gradle-daemon-jvm.properties\ file has been added to configure the JVM toolchain (version 21) for the Gradle daemon across various operating systems and architectures, ensuring consistent build environments.
gradle · 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 65 → 58 (-6.1)
Lenses
- Code Health 87 → 87 (+0.0)
- Architecture 95 → 95 (+0.0)
- Maturity 82 → 84 (+1.4)
- Readiness 69 → 65 (-4.6)
- Security 81 → 80 (-1.2)
- Domain Modelling 87 → 87 (+0.0)
- Accessibility 51 → 40 (-11.3)
- Performance 78 → 80 (+2.0)
Resolved (57)
- Ambiguous naming convention for synchronous/asynchronous operations. While Sync suffix is used, it is unclear if updateSpecialFolders is asynchronous (e.g., returns Unit but runs in background) or if Sync implies a blocking call. In Kotlin, suspend functions are preferred for async operations, and Sync suffixes are often discouraged unless they are truly blocking. This creates inconsistency with other parts of the codebase that might use suspend.
- Change coupling: AccountSettingsDescriptions.java ↔ AccountSettingsDataStore.kt (legacy/core/src/main/java/com/fsck/k9/preferences/AccountSettingsDescriptions.java)
- Change-coupling hub: GeneralSettingsDataStore.kt → DisplayVisualSettings.kt, NotificationPreference.kt, GeneralSettingsDescriptions.java (legacy/ui/legacy/src/main/java/com/fsck/k9/ui/settings/general/GeneralSettingsDataStore.kt)
- Change-coupling hub: K9.kt → GeneralSettings.kt, DisplayVisualSettings.kt, DefaultInteractionSettingsPreferenceManager.kt, DefaultDrawerConfigManager.kt, GeneralSettingsDescriptions.java, MessageListActivityConfig.kt, GeneralSettingsDataStore.kt (legacy/core/src/main/java/com/fsck/k9/K9.kt)
- ClassTooLong: LegacyAccountDto (core/android/account/src/main/kotlin/net/thunderbird/core/android/account/LegacyAccountDto.kt)
- Documentation: no installation or build instructions (README.md)
- Documentation: no licence statement (README.md)
- Documentation: no usage examples (README.md)
- Duplicated block (10 lines × 2) (legacy/core/src/main/java/com/fsck/k9/message/extractors/BodyTextExtractor.java)
- Duplicated block (10 lines × 2) (legacy/core/src/main/java/com/fsck/k9/provider/AttachmentTempFileProvider.java)
- Duplicated block (11 lines × 2) (feature/account/server/settings/src/main/kotlin/app/k9mail/feature/account/server/settings/ui/incoming/IncomingServerSettingsContent.kt)
- Duplicated block (11 lines × 2) (legacy/common/src/main/java/com/fsck/k9/backends/ImapBackendFactory.kt)
- Duplicated block (11 lines × 2) (legacy/core/src/main/java/com/fsck/k9/provider/AttachmentTempFileProvider.java)
- Duplicated block (12 lines × 2) (legacy/core/src/main/java/com/fsck/k9/provider/AttachmentTempFileProvider.java)
- Duplicated block (12 lines × 2) (mail/protocols/imap/src/main/java/com/fsck/k9/mail/store/imap/RealImapConnection.kt)
- Duplicated block (12–14 lines × 2) (backend/imap/src/main/java/com/fsck/k9/backend/imap/ImapSync.kt)
- Duplicated block (13 lines × 2) (legacy/core/src/main/java/com/fsck/k9/controller/MessagingController.java)
- Duplicated block (13 lines × 2) (legacy/ui/legacy/src/main/java/com/fsck/k9/ui/messagelist/LegacyMessageListFragment.kt)
- Duplicated block (14 lines × 2) (legacy/ui/legacy/src/main/java/com/fsck/k9/ui/messagelist/LegacyMessageListFragment.kt)
- Duplicated block (14–16 lines × 2) (backend/imap/src/main/java/com/fsck/k9/backend/imap/ImapSync.kt)
- …and 37 more
New (295)
- ADR has no Consequences section (docs/engineering/adr/0001-switch-from-java-to-kotlin.md)
- ADR has no Consequences section (docs/engineering/adr/0002-ui-wrap-material-components-in-atomic-design-system.md)
- ADR has no Consequences section (docs/engineering/adr/0003-switch-test-assertions-from-truth-to-assertk.md)
- ADR has no Consequences section (docs/engineering/adr/0004-naming-conventions-for-interfaces-and-their-implementations.md)
- ADR has no Consequences section (docs/engineering/adr/0005-central-project-configuration.md)
- ADR has no Consequences section (docs/engineering/adr/0006-white-label-architecture.md)
- ADR has no Consequences section (docs/engineering/adr/0007-project-structure.md)
- ADR has no Consequences section (docs/engineering/adr/0008-change-shared-modules-package-name.md)
- ADR has no Consequences section (docs/engineering/adr/0009-api-internal-split.md)
- ADR has no Consequences section (docs/engineering/adr/0010-adopt-project-wide-repository-pattern.md)
- Change-coupling hub: GeneralSettingsDataStore.kt → DisplayVisualSettings.kt, NotificationPreference.kt, DefaultDisplayVisualSettingsPreferenceManager.kt, GeneralSettingsDescriptions.java (legacy/ui/legacy/src/main/java/com/fsck/k9/ui/settings/general/GeneralSettingsDataStore.kt)
- Change-coupling hub: K9.kt → GeneralSettings.kt, DisplayVisualSettings.kt, DefaultDrawerConfigManager.kt, MessageListActivityConfig.kt, GeneralSettingsDataStore.kt (legacy/core/src/main/java/com/fsck/k9/K9.kt)
- ClassTooLong: LegacyAccountStorageHandler (feature/account/storage/legacy/src/main/kotlin/net/thunderbird/feature/account/storage/legacy/LegacyAccountStorageHandler.kt)
- ClassTooLong: Pop3Sync (backend/pop3/src/main/java/com/fsck/k9/backend/pop3/Pop3Sync.kt)
- Duplicate intent across distinct repository types. Both FolderDetailsRepository and FolderQueryRepository expose an findById method with identical signatures. It is unclear why the API is split between 'Details' and 'Query' repositories if they share the same primary lookup operation.
- Duplicate operation across class and companion object/extension. OutboxFolderManagerKt.getOutboxFolderIdSync has the exact same signature as OutboxFolderManager.getOutboxFolderIdSync. This creates ambiguity for callers on whether to use the instance method or the static/extension function.
- Duplicated block (10 lines × 2) (feature/widget/message-list-glance/src/main/kotlin/net/thunderbird/feature/widget/message/list/MessageListLoader.kt)
- Duplicated block (10 lines × 2) (legacy/core/src/main/java/com/fsck/k9/message/extractors/BodyTextExtractor.java)
- Duplicated block (10 lines × 2) (legacy/core/src/main/java/com/fsck/k9/provider/AttachmentTempFileProvider.java)
- Duplicated block (10 lines × 2) (legacy/core/src/main/java/com/fsck/k9/provider/AttachmentTempFileProvider.java)
- …and 275 more
Changes since last survey
- 164 commits — 128 feature/other, 36 fixes
By area
- feature/account — 43 commits
- (repo) — 29 commits
- legacy/ui — 19 commits
- legacy/core — 17 commits
- gradle/libs.versions.toml — 9 commits
- app-common/src — 5 commits
- app-thunderbird/dependencies — 5 commits
- core/ui — 5 commits
- .github/workflows — 3 commits
- benchmarks/src — 3 commits
- core/logging — 3 commits
- feature/launcher — 3 commits
- (root) — 2 commits
- build-plugin/src — 2 commits
- core/android — 2 commits
- feature/navigation — 2 commits
- legacy/storage — 2 commits
- app-k9mail/benchmarks — 1 commit
- app-thunderbird/badging — 1 commit
- build-plugin/plugin — 1 commit
Notable commits
- fix: fix(account): fail with precise errors when account data is missing
- fix: fix(account): keep account changes consistent after moving to immutable accounts
- fix: fix(account): preserve account state during setup and storage migration
- fix: fix(account-settings): adapt to the new update method
- fix: fix(ci): Contributor list incorrectly listed contributions (#11764)
- fix: fix(ci): Correct Rev used to generate contributor list
- fix: fix(drawer): placeholder should not block folder access
- fix: fix(drawer): use bundle-storable keys for the account list
- fix: fix(logging): restore sync debug log and log level behavior
- fix: fix(logging): use component library in new code
- fix: fix(message-composer): layout crash when rotating screen
- fix: fix(message-composer): layout crash when rotating screen (#11721)
- fix: fix(message-list): remember the folder chosen for move and copy again
- fix: fix(notification-settings): Abstract sync¬if VM
- fix: fix(notification-settings): Explanation of legacy usage and tickets
- fix: fix(notification-settings): remove bang operator
- fix: fix(preference): read settings from the cached storage snapshot to reduce startup reads
- fix: fix(preference): read settings from the cached storage snapshot to reduce startup reads (#11749)
- fix: fix(search): don't pass a null account ID to the search intent
- fix: fix(search): keep the search type when serializing searches
- …and 144 more
Architecture
- Containers 0 added · 0 removed · contexts 30 added · 31 removed · edges 158 added · 156 removed
Added bounded contexts (30)
- backend/api
- backend/demo
- backend/imap
- backend/pop3
- backend/testing
- core/android/account
- core/android/common
- core/common
- core/configstore/api
- feature/account/common
- feature/account/fake
- feature/account/server/validation
- feature/account/settings/impl
- feature/changelog/internal
- feature/mail/folder/api
- feature/mail/message/api
- feature/mail/message/list/api
- feature/mail/message/reader/api
- feature/mail/storage/global-db-migration/api
- feature/notification/api
- …and 10 more
Removed bounded contexts (31)
- backend/api
- backend/demo
- backend/imap
- backend/pop3
- backend/testing
- core/android/account
- core/android/common
- core/common
- core/configstore/api
- core/logging/testing
- fake
- feature/account/common
- feature/account/server/validation
- feature/account/settings/impl
- feature/changelog/internal
- feature/mail/folder/api
- feature/mail/message/api
- feature/mail/message/list/api
- feature/mail/message/reader/api
- feature/mail/storage/global-db-migration/api
- …and 11 more
Added dependency edges (158)
- backend/api → core/common
- backend/api → feature/mail/folder/api (coupling)
- backend/api → mail/common
- backend/demo → backend/api (coupling)
- backend/demo → core/common
- backend/demo → mail/common
- backend/imap → backend/api (coupling)
- backend/imap → core/common
- backend/imap → feature/mail/folder/api (coupling)
- backend/imap → mail/common
- backend/imap → mail/protocols/imap (coupling)
- backend/imap → smtp
- backend/pop3 → backend/api (coupling)
- backend/pop3 → core/common
- backend/pop3 → smtp
- backend/testing → backend/api (coupling)
- backend/testing → core/common
- backend/testing → mail/common
- core/android/account → backend/api (coupling)
- core/android/account → feature/mail/folder/api (coupling)
- …and 138 more
Removed dependency edges (was a dependency, now gone) (156)
- app-common → backend/api
- app-common → backend/imap
- app-common → core/android/account (coupling)
- app-common → core/android/common
- app-common → core/common
- app-common → core/configstore/api (coupling)
- app-common → feature/account/common
- app-common → feature/mail/folder/api (coupling)
- app-common → feature/mail/message/api (coupling)
- app-common → feature/mail/message/list/api (coupling)
- app-common → feature/mail/message/reader/api
- app-common → legacy/common
- app-common → legacy/core (coupling)
- app-common → mail/common
- autoconfig → core/common
- backend/api → core/common
- backend/api → feature/mail/folder/api (coupling)
- backend/api → mail/common
- backend/demo → backend/api (coupling)
- backend/demo → core/common
- …and 136 more
Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.
Survey your own repository
thunderbird/thunderbird-android 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 24 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 de8a03268415ce8e0c8b0327d3bbcb6b40a06a91 — 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.6+preprod-d36780c2d857.