Skip to content
CAI
Software that uses CAICheck a score

thunderbird/thunderbird-android

58.5

Adequate · 24 October 2026

203.9k

lines of production code

Kotlin

with Java

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

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

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

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

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

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&notif 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.