docs(changelog): update release notes for version 2.2.6

The [strings.Fields](https://pkg.go.dev/strings#Fields) considers `'\t', '\n',
'\v', '\f', '\r', ' ', U+0085 (NEL), U+00A0 (NBSP).` as spaces, so no need to
remove them beforehand.

This is a continuation of f2f60a8f73

.devcontainer/docker-compose.yml

@@ -1,7 +1,7 @@
 version: '3.8'
 services:
   app:
-    image: mcr.microsoft.com/devcontainers/go:1.22
+    image: mcr.microsoft.com/devcontainers/go:1.23
     volumes:
       - ..:/workspace:cached
     command: sleep infinity

.github/ISSUE_TEMPLATE/feature_request.md

@@ -2,7 +2,7 @@
 name: Feature request
 about: Suggest an idea for this project
 title: ''
-labels: feature request
+labels: wishlist
 assignees: ''
 
 ---

.github/pull_request_template.md

@@ -1,7 +1,7 @@
-Do you follow the guidelines?
+Have you followed these guidelines?
 
 - [ ] I have tested my changes
-- [ ] There is no breaking changes
-- [ ] I really tested my changes and there is no regression
-- [ ] Ideally, my commit messages use the same convention as the Go project: https://go.dev/doc/contribute#commit_messages
-- [ ] I read this document: https://miniflux.app/faq.html#pull-request
+- [ ] There are no breaking changes
+- [ ] I have thoroughly tested my changes and verified there are no regressions
+- [ ] My commit messages follow the [Conventional Commits specification](https://www.conventionalcommits.org/)
+- [ ] I have read this document: https://miniflux.app/faq.html#pull-request

.github/workflows/build_binaries.yml

@@ -9,13 +9,13 @@ jobs:
     name: Build
     runs-on: ubuntu-latest
     steps:
+      - name: Checkout
+        uses: actions/checkout@v4
       - name: Set up Golang
         uses: actions/setup-go@v5
         with:
-          go-version: "1.22.x"
+          go-version: "1.24.x"
           check-latest: true
-      - name: Checkout
-        uses: actions/checkout@v4
       - name: Compile binaries
         env:
           CGO_ENABLED: 0

.github/workflows/codeql-analysis.yml

@@ -5,9 +5,17 @@ permissions: read-all
 on:
   push:
     branches: [ main ]
+    paths:
+      - '**.js'
+      - '**.go'
+      - '!**_test.go'
   pull_request:
     # The branches below must be a subset of the branches above
     branches: [ main ]
+    paths:
+      - '**.js'
+      - '**.go'
+      - '!**_test.go'
   schedule:
     - cron: '45 22 * * 3'
 
@@ -22,8 +30,6 @@ jobs:
 
     strategy:
       fail-fast: false
-      matrix:
-        language: [ 'go', 'javascript' ]
 
     steps:
     - name: Checkout repository
@@ -31,7 +37,7 @@ jobs:
 
     - uses: actions/setup-go@v5
       with:
-        go-version: "1.22.x"
+        go-version: "1.24.x"
 
     - name: Initialize CodeQL
       uses: github/codeql-action/init@v3

.github/workflows/debian_packages.yml

@@ -5,11 +5,15 @@ on:
   push:
     tags:
       - '[0-9]+.[0-9]+.[0-9]+'
+  schedule:
+    - cron: '0 0 * * 1,4' # Runs at 00:00 UTC on Monday and Thursday
   pull_request:
     branches: [ main ]
+    paths:
+      - 'packaging/debian/**' # Only run on changes to the debian packaging files
 jobs:
   test-packages:
-    if: github.event.pull_request
+    if: github.event_name == 'schedule' || github.event_name == 'pull_request'
     name: Test Packages
     runs-on: ubuntu-latest
     steps:
@@ -30,7 +34,7 @@ jobs:
     - name: List generated files
       run: ls -l *.deb
   build-packages-manually:
-    if: github.event_name != 'pull_request' && github.event_name != 'push'
+    if: github.event_name == 'workflow_dispatch'
     name: Build Packages Manually
     runs-on: ubuntu-latest
     steps:

.github/workflows/docker.yml

@@ -7,36 +7,11 @@ on:
       - '[0-9]+.[0-9]+.[0-9]+'
   pull_request:
     branches: [ main ]
+    paths:
+      - 'packaging/docker/**'
 jobs:
-  test-docker-images:
-    if: github.event.pull_request
-    name: Test Images
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Build Alpine image
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          file: ./packaging/docker/alpine/Dockerfile
-          push: false
-          tags: ${{ github.repository_owner }}/miniflux:alpine-dev
-      - name: Test Alpine Docker image
-        run: docker run --rm ${{ github.repository_owner }}/miniflux:alpine-dev miniflux -i
-      - name: Build Distroless image
-        uses: docker/build-push-action@v5
-        with:
-          context: .
-          file: ./packaging/docker/distroless/Dockerfile
-          push: false
-          tags: ${{ github.repository_owner }}/miniflux:distroless-dev
-      - name: Test Distroless Docker image
-        run: docker run --rm ${{ github.repository_owner }}/miniflux:distroless-dev miniflux -i
-
-  publish-docker-images:
-    if: ${{ ! github.event.pull_request }}
-    name: Publish Images
+  docker-images:
+    name: Docker Images
     permissions:
       packages: write
     runs-on: ubuntu-latest
@@ -46,33 +21,33 @@ jobs:
         with:
           fetch-depth: 0
 
-      - name: Generate Alpine Docker tag
-        id: docker_alpine_tag
-        run: |
-          DOCKER_IMAGE=${{ github.repository_owner }}/miniflux
-          DOCKER_VERSION=dev
-          if [ "${{ github.event_name }}" = "schedule" ]; then
-          DOCKER_VERSION=nightly
-          TAGS="docker.io/${DOCKER_IMAGE}:${DOCKER_VERSION},ghcr.io/${DOCKER_IMAGE}:${DOCKER_VERSION},quay.io/${DOCKER_IMAGE}:${DOCKER_VERSION}"
-          elif [[ $GITHUB_REF == refs/tags/* ]]; then
-          DOCKER_VERSION=${GITHUB_REF#refs/tags/}
-          TAGS="docker.io/${DOCKER_IMAGE}:${DOCKER_VERSION},ghcr.io/${DOCKER_IMAGE}:${DOCKER_VERSION},quay.io/${DOCKER_IMAGE}:${DOCKER_VERSION},docker.io/${DOCKER_IMAGE}:latest,ghcr.io/${DOCKER_IMAGE}:latest,quay.io/${DOCKER_IMAGE}:latest"
-          fi
-          echo ::set-output name=tags::${TAGS}
+      - name: Generate Alpine Docker tags
+        id: docker_alpine_tags
+        uses: docker/metadata-action@v5
+        with:
+          images: |
+            docker.io/${{ github.repository_owner }}/miniflux
+            ghcr.io/${{ github.repository_owner }}/miniflux
+            quay.io/${{ github.repository_owner }}/miniflux
+          tags: |
+            type=ref,event=pr
+            type=schedule,pattern=nightly
+            type=semver,pattern={{raw}}
 
-      - name: Generate Distroless Docker tag
-        id: docker_distroless_tag
-        run: |
-          DOCKER_IMAGE=${{ github.repository_owner }}/miniflux
-          DOCKER_VERSION=dev-distroless
-          if [ "${{ github.event_name }}" = "schedule" ]; then
-          DOCKER_VERSION=nightly-distroless
-          TAGS="docker.io/${DOCKER_IMAGE}:${DOCKER_VERSION},ghcr.io/${DOCKER_IMAGE}:${DOCKER_VERSION},quay.io/${DOCKER_IMAGE}:${DOCKER_VERSION}"
-          elif [[ $GITHUB_REF == refs/tags/* ]]; then
-          DOCKER_VERSION=${GITHUB_REF#refs/tags/}-distroless
-          TAGS="docker.io/${DOCKER_IMAGE}:${DOCKER_VERSION},ghcr.io/${DOCKER_IMAGE}:${DOCKER_VERSION},quay.io/${DOCKER_IMAGE}:${DOCKER_VERSION},docker.io/${DOCKER_IMAGE}:latest-distroless,ghcr.io/${DOCKER_IMAGE}:latest-distroless,quay.io/${DOCKER_IMAGE}:latest-distroless"
-          fi
-          echo ::set-output name=tags::${TAGS}
+      - name: Generate Distroless Docker tags
+        id: docker_distroless_tags
+        uses: docker/metadata-action@v5
+        with:
+          images: |
+            docker.io/${{ github.repository_owner }}/miniflux
+            ghcr.io/${{ github.repository_owner }}/miniflux
+            quay.io/${{ github.repository_owner }}/miniflux
+          tags: |
+            type=ref,event=pr
+            type=schedule,pattern=nightly
+            type=semver,pattern={{raw}}
+          flavor: |
+            suffix=-distroless,onlatest=true
 
       - name: Set up QEMU
         uses: docker/setup-qemu-action@v3
@@ -81,12 +56,14 @@ jobs:
         uses: docker/setup-buildx-action@v3
 
       - name: Login to DockerHub
+        if: ${{ github.event_name != 'pull_request' && vars.PUBLISH_DOCKER_IMAGES == 'true' }}
         uses: docker/login-action@v3
         with:
           username: ${{ secrets.DOCKERHUB_USERNAME }}
           password: ${{ secrets.DOCKERHUB_TOKEN }}
 
       - name: Login to GitHub Container Registry
+        if: ${{ github.event_name != 'pull_request' && vars.PUBLISH_DOCKER_IMAGES == 'true' }}
         uses: docker/login-action@v3
         with:
           registry: ghcr.io
@@ -94,6 +71,7 @@ jobs:
           password: ${{ secrets.GITHUB_TOKEN }}
 
       - name: Login to Quay Container Registry
+        if: ${{ github.event_name != 'pull_request' && vars.PUBLISH_DOCKER_IMAGES == 'true' }}
         uses: docker/login-action@v3
         with:
           registry: quay.io
@@ -101,19 +79,21 @@ jobs:
           password: ${{ secrets.QUAY_TOKEN }}
 
       - name: Build and Push Alpine images
-        uses: docker/build-push-action@v5
+        uses: docker/build-push-action@v6
+        if: ${{ vars.PUBLISH_DOCKER_IMAGES == 'true' }}
         with:
           context: .
           file: ./packaging/docker/alpine/Dockerfile
           platforms: linux/amd64,linux/arm/v6,linux/arm/v7,linux/arm64
-          push: true
-          tags: ${{ steps.docker_alpine_tag.outputs.tags }}
+          push: ${{ github.event_name != 'pull_request' }}
+          tags: ${{ steps.docker_alpine_tags.outputs.tags }}
 
       - name: Build and Push Distroless images
-        uses: docker/build-push-action@v5
+        uses: docker/build-push-action@v6
+        if: ${{ vars.PUBLISH_DOCKER_IMAGES == 'true' }}
         with:
           context: .
           file: ./packaging/docker/distroless/Dockerfile
           platforms: linux/amd64,linux/arm64
-          push: true
-          tags: ${{ steps.docker_distroless_tag.outputs.tags }}
+          push: ${{ github.event_name != 'pull_request' }}
+          tags: ${{ steps.docker_distroless_tags.outputs.tags }}

.github/workflows/linters.yml

@@ -28,12 +28,33 @@ jobs:
       - uses: actions/checkout@v4
       - uses: actions/setup-go@v5
         with:
-          go-version: "1.22.x"
-      - run: "go vet ./..."
-      - uses: golangci/golangci-lint-action@v4
+          go-version: "1.24.x"
+      - uses: golangci/golangci-lint-action@v6
         with:
-          args: --timeout 10m --skip-dirs tests --disable errcheck --enable sqlclosecheck --enable misspell --enable gofmt --enable goimports --enable whitespace --enable gocritic
+          args: >
+            --timeout 10m
+            --exclude-dirs=tests
+            --disable errcheck
+            --enable sqlclosecheck,misspell,gofmt,goimports,whitespace,gocritic
       - uses: dominikh/staticcheck-action@v1.3.1
         with:
-          version: "2023.1.7"
+          version: "latest"
           install-go: false
+
+  commitlint:
+    name: Commit Linter
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "lts/*"
+      - name: Install commitlint
+        run: |
+          npm install --save-dev @commitlint/config-conventional @commitlint/cli
+          echo "module.exports = {extends: ['@commitlint/config-conventional']}" > commitlint.config.js
+      - name: Validate PR commits
+        run: npx commitlint --from ${{ github.event.pull_request.base.sha }} --to ${{ github.event.pull_request.head.sha }} --verbose

.github/workflows/rpm_packages.yml

@@ -5,11 +5,15 @@ on:
   push:
     tags:
       - '[0-9]+.[0-9]+.[0-9]+'
+  schedule:
+    - cron: '0 0 * * 1,4' # Runs at 00:00 UTC on Monday and Thursday
   pull_request:
     branches: [ main ]
+    paths:
+      - 'packaging/rpm/**' # Only run on changes to the rpm packaging files
 jobs:
   test-package:
-    if: github.event.pull_request
+    if: github.event_name == 'schedule' || github.event_name == 'pull_request'
     name: Test Packages
     runs-on: ubuntu-latest
     steps:
@@ -21,7 +25,7 @@ jobs:
     - name: List generated files
       run: ls -l *.rpm
   build-package-manually:
-    if: github.event_name != 'pull_request' && github.event_name != 'push'
+    if: github.event_name == 'workflow_dispatch'
     name: Build Packages Manually
     runs-on: ubuntu-latest
     steps:

.github/workflows/tests.yml

@@ -15,16 +15,20 @@ jobs:
       max-parallel: 4
       matrix:
         os: [ubuntu-latest, windows-latest, macOS-latest]
-        go-version: ["1.22.x"]
+        go-version: ["1.24.x"]
     steps:
+    - name: Checkout
+      uses: actions/checkout@v4
     - name: Set up Go
       uses: actions/setup-go@v5
       with:
         go-version: ${{ matrix.go-version }}
-    - name: Checkout
-      uses: actions/checkout@v4
-    - name: Run unit tests
+    - name: Run unit tests with coverage and race conditions checking
+      if: matrix.os == 'ubuntu-latest'
       run: make test
+    - name: Run unit tests without coverage and race conditions checking
+      if: matrix.os != 'ubuntu-latest'
+      run: go test ./...
 
   integration-tests:
     name: Integration Tests
@@ -40,12 +44,12 @@ jobs:
         - 5432:5432
         options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
     steps:
+    - name: Checkout
+      uses: actions/checkout@v4
     - name: Set up Go
       uses: actions/setup-go@v5
       with:
-        go-version: "1.22.x"
-    - name: Checkout
-      uses: actions/checkout@v4
+        go-version: "1.24.x"
     - name: Install Postgres client
       run: sudo apt update && sudo apt install -y postgresql-client
     - name: Run integration tests

.gitignore

@@ -1,6 +1,7 @@
-miniflux-*
+./*.sha256
 ./miniflux
-*.rpm
-*.deb
 .idea
-.vscode
+.vscode
+*.deb
+*.rpm
+miniflux-*

ChangeLog

@@ -1,3 +1,340 @@
+Version 2.2.6 (February 22, 2025)
+---------------------------------
+
+* test(encoding): add unit tests for `CharsetReader` function
+* refactor(xml): improve the performances of `NewXMLDecoder`
+* refactor(ui): remove superfluous cast
+* refactor(request): broaden an error condition when parsing cookies
+* refactor(processor): remove superfluous parenthesis
+* refactor(opml): don't define receivers on both values and pointer
+* refactor(model): simplify a condition
+* refactor(model): don't define methods both on instance and pointer
+* refactor(locale): sort JSON documents alphabetically by keys
+* refactor(locale): remove superfluous parenthesis
+* refactor(js): use proper types in `app.js`
+* refactor(js): replace the deprecated `window.pageYOffset` with `window.scollY`
+* refactor(js): remove a useless `return`
+* refactor(js): anchor `=` removal in `webauthn_handler.js` regex
+* refactor(js): add default value for parameter `fallbackSelf` in `goToPage` function
+* refactor(integration): don't use `defer` in a loop
+* refactor(icon): guard against a potential `null` dereference
+* refactor(date): use an else-if instead of two if statements
+* refactor(css): use shortcuts to declare padding
+* refactor(client): remove a useless cast
+* perf(sanitizer): remove two useless calls to `strings.ReplaceAll`
+* fix(ui): Redirect correctly post feed removal from category feeds list
+* fix(scraper): update TechCrunch scraper rule
+* fix(scraper): avoid encoding issue if charset meta tag is after 1024 bytes
+* fix(sanitizer): non-allowed attributes are not properly stripped
+* fix(sanitizer): correct HTML tag name from `tfooter` to `tfoot`
+* fix(rss): handle item title with `CDATA` content correctly
+* fix(locale): missing hyphen in `de_DE.json`
+* fix(css): avoid aside overflow on the pagination menu
+* fix(css): `--entry-content-aside-border-color` is missing from `system.css`
+* fix(api): return 500 response when JSON serialization fails
+* fix(api): JSON encoding is failing with dates at OAD and negative timezone offset
+* feat(urlcleaner): add trackers to the blocklist
+* feat(ui): open the `<details>` tag in edit feed page when the feature is enabled
+* feat(sanitizer): improve text truncation with better space handling
+* feat(sanitizer): allow `img` tags with only a `srcset` and no `src` attribute
+* feat(rss): add workaround for RSS item title with HTML content
+* feat(pushover): add integration with pushover.net
+* feat(processor): fetch YouTube watch time in bulk using the API
+* feat(locale): update Traditional Chinese translation
+* feat(locale): update Polish translation
+* feat(locale): update French translation
+* feat(locale): add Taiwanese POJ (nan-Latn-pehoeji)
+* feat(integration): update Linkace integration to support API v2
+* feat(integration): add webhook URL per feed
+* feat(integration): add Slack integration
+* feat(css): improve aside element position on smartphone
+* ci: update GitHub Actions workflows to use Go 1.24
+* ci: trigger packaging tests on pull requests
+* ci: add `commitlint` to validate PR commit messages
+* build(deps): bump `golang` in `/packaging/debian`
+* build(deps): bump `golang.org/x/term` from `0.28.0` to `0.29.0`
+* build(deps): bump `golang.org/x/oauth2` from `0.25.0` to `0.26.0`
+* build(deps): bump `golang.org/x/net` from `0.34.0` to `0.35.0`
+* build(deps): bump `golang.org/x/image` from `0.23.0` to `0.24.0`
+* build(deps): bump `golang.org/x/crypto` from `0.32.0` to `0.33.0`
+* build(deps): bump `github.com/PuerkitoBio/goquery` from `1.10.1` to `1.10.2`
+
+Version 2.2.5 (January 20, 2025)
+--------------------------------
+
+* test(js): improve `.jshintrc` (strict comparison, etc...)
+* test(sanitizer): add a fuzzer
+* refactor(rewriter): use custom title case converter implementation instead of `golang.org/x/text/cases.Title()`
+* refactor(readingtime): replace `whatlanggo` package with an ad-hoc implementation
+* refactor(oauth2): no need to use `io.WriteString` when sha256 provides a way to obtain a sum in a single call
+* refactor(js): simplify a bit `keyboard_handler.js`
+* refactor(js): remove an outdated check for `{passive: true}`
+* refactor(js): minor refactoring of `touch_handler.js`
+* refactor(js): minor improvements in `app.js`
+* refactor(database): add special handling for PostgreSQL-specific migrations
+* fix(ui): reading preferences are reset if the form values are incorrect
+* fix(sanitizer): allow `<hr>` tags
+* fix(finder): do not add redirections to the list of subscriptions to avoid confusion
+* fix: update Wallabag URL label to avoid confusion
+* fix: improve pagination when having identical publication date
+* fix: do not strip tags in Atom entry title
+* feat(ntfy): Add option to use internal links
+* feat(locale): update Polish translation
+* feat(locale): update German translation
+* feat(integration): add Discord integration
+* feat(database): add optional build support for SQLite
+* feat: validate usernames upon creation
+* feat: replace `%{?systemd_requires}` with `%{?systemd_ordering}`
+* feat: bump linter and minifier from ECMAScript 2017 to 2020 (ES11)
+* feat: add `fix_ghost_cards` rewrite rule
+* ci: tighten the CodeQL rules
+* ci: run Docker tests only when the Dockerfiles are modified
+* ci: run `-race -cover` only on Ubuntu jobs
+* ci: don't specify languages for CodeQL
+* ci: don't run `go vet ./...` as it's run as part of `golangci-lint`
+* ci: checkout before installing Go to improve cache efficiency
+* ci: avoid building Linux packages for each pull-request
+* build(deps): bump `golang.org/x/oauth2` from `0.24.0` to `0.25.0`
+* build(deps): bump `golang.org/x/net` from `0.33.0` to `0.34.0`
+* build(deps): bump `golang.org/x/crypto` from `0.31.0` to `0.32.0`
+* build(deps): bump `github.com/tdewolff/minify/v2` from `2.21.2` to `2.21.3`
+* build(deps): bump `github.com/PuerkitoBio/goquery` from `1.10.0` to `1.10.1`
+* build(deps): bump `github.com/coreos/go-oidc/v3` from `3.11.0` to `3.12.0`
+
+Version 2.2.4 (December 20, 2024)
+---------------------------------
+
+* test(rewrite): add unit test for referer rewrite function
+* refactor(subscription): use `strings.HasSuffix` instead of a regex in `FindSubscriptionsFromYouTubePlaylistPage`
+* refactor(sanitizer): use `token.String()` instead of `html.EscapeString(token.Data)`
+* refactor(sanitizer): simplify `isValidTag`
+* refactor(sanitizer): simplify `hasRequiredAttributes`
+* refactor(sanitizer): remove condition because `config.Opts` is guaranteed to never be nil
+* refactor(sanitizer): remove a now-useless function after refactoring
+* refactor(sanitizer): refactor conditions to highlight their similitude, enabling further refactoring
+* refactor(sanitizer): optimize `strip_tags.go`
+* refactor(sanitizer): micro-optimizations of `srcset.go`
+* refactor(sanitizer): merge two conditions
+* refactor(sanitizer): inline a function in `sanitizeAttributes` and fix a bug in it
+* refactor(sanitizer): inline a condition in `sanitizeSrcsetAttr`
+* refactor(sanitizer): improve `rewriteIframeURL()`
+* refactor(sanitizer): Google+ isn't a thing anymore
+* refactor(sanitizer): change the scope of a variable
+* refactor(rewriter): replace regex with URL parsing for referrer override
+* refactor(rewriter): avoid the use of regex in `addDynamicImage`
+* refactor(rewrite): remove unused function arguments
+* refactor(readability): various improvements and optimizations
+* refactor(readability): simplify the regexes in `readability.go`
+* refactor(processor): use URL parsing instead of a regex
+* refactor(processor): improve the `rewrite` URL rule regex
+* refactor(locale): delay parsing of translations until they're used
+* refactor(js): factorise a line in `app.js`
+* refactor(handler): delay `store.UserByID()` as much as possible
+* refactor(css): replace `-ms-text-size-adjust` with `text-size-adjust`
+* refactor(css): remove `-webkit-clip-path`
+* refactor(css): factorise `.pagination-next` and `.pagination-last` together
+* refactor: use a better construct than `doc.Find(…).First()`
+* refactor: use `min/max` instead of `math.Min/math.Max`
+* refactor: refactor `internal/reader/readability/testdata`
+* refactor: optimize `sanitizeAttributes`
+* refactor: get rid of `numberOfPluralFormsPerLanguage` test-only variable
+* fix(storage): replace timezone function call with view
+* fix(consistency): align feed modification behavior between API and UI
+* fix(ci): fix grammar in pull-request template
+* fix: load icon from site URL instead of feed URL
+* fix: feed icon from xml ignored during force refresh
+* feat(rewrite)!: remove `parse_markdown` rewrite rule
+* feat(mediaproxy): update predefined referer spoofing rules for restricted media resources
+* feat(locale): update translations to clarify readeck URL instead of readeck API endpoint
+* feat(locale): update German translations
+* feat(locale): update Chinese translations
+* feat(apprise): update `SendNotification` to handle multiple entries and add logging
+* feat(apprise): add title in notification request body
+* feat: resize favicons before storing them in the database
+* feat: optionally fetch watch time from YouTube API instead of website
+* feat: only show the commit URL if it's not empty on `/about`
+* feat: add predefined scraper rules for `arstechnica.com`
+* feat: add date-based entry filtering rules
+* chore: remove `blog.laravel.com` rewrite rule
+* build(deps): bump `library/alpine` in `/packaging/docker/alpine` to `3.21`
+* build(deps): bump `golang.org/x/term` from `0.26.0` to `0.27.0`
+* build(deps): bump `golang.org/x/net` from `0.31.0` to `0.33.0`
+* build(deps): bump `golang.org/x/crypto` from `0.30.0` to `0.31.0`
+* build(deps): bump `github.com/tdewolff/minify/v2` from `2.21.1` to `2.21.2`
+
+Version 2.2.3 (November 10, 2024)
+---------------------------------
+
+* fix: unable to change password due to a typo in SQL parameter
+* fix: show only one player when there are several audio/video enclosures
+* feat(mediaproxy): pass original filename in `Content-Disposition` header
+* feat(mediaproxy): implement referer spoofing for restricted media resources
+* feat(integration): update Shiori integration to use new API endpoints for login/bookmark
+* build(deps): bump `golang.org/x/text` from `0.19.0` to `0.20.0`
+* build(deps): bump `golang.org/x/term` from `0.25.0` to `0.26.0`
+* build(deps): bump `golang.org/x/oauth2` from `0.23.0` to `0.24.0`
+* build(deps): bump `golang.org/x/net` from `0.30.0` to `0.31.0`
+* build(deps): bump `golang.org/x/crypto` from `0.28.0` to `0.29.0`
+
+Version 2.2.2 (October 29, 2024)
+--------------------------------
+
+* fix(webauthn): add backup eligibility flag workaround to avoid a 401 response
+* fix: update `Last-Modified` if it changes in a 304 response
+* feat(webauthn): show help message regarding username and non-discoverable credentials
+* feat(rss): calculate hash based on item title/content for feeds without GUID and link
+* feat(locale): update Chinese translations
+* feat(locale): update Polish translations
+* feat(integration): add Cubox integration
+* feat(client): add `custom_js` field to Go API client
+* feat(api): add endpoint for user integration status
+* feat: update feed icon during force refresh
+* feat: take `Retry-After` header into consideration for rate limited feeds
+* feat: set entry URL to rewritten URL if a rewrite rule is defined
+* feat: replace `xurls` third-party module with an ad-hoc regexp
+* feat: add new settings option to allow external fonts
+* feat: add custom user JavaScript similar to custom CSS
+* chore: update test case comment
+* build(deps): bump `golang.org/x/net` from `0.29.0` to `0.30.0`
+* build(deps): bump `github.com/yuin/goldmark` from `1.7.4` to `1.7.8`
+* build(deps): bump `github.com/tdewolff/minify/v2` from `2.20.37` to `2.21.1`
+* build(deps): bump `github.com/prometheus/client_golang`
+* build(deps): bump `github.com/andybalholm/brotli` from `1.1.0` to `1.1.1`
+
+Version 2.2.1 (September 28, 2024)
+----------------------------------
+
+* refactor: split processor package into smaller files
+* fix(mediaproxy): forward client user-agent to origin to bypass bot protection
+* fix: use root URL to generate absolute proxy URL
+* fix: remove progression save on shared entry
+* fix: add datasource variable and upgrade depecrated panels on the Grafana dashboard
+* feat(locale): update zh_CN translations
+* feat(locale): update Ukrainian translations
+* feat(locale): update Spanish translations
+* feat(locale): update Dutch translations
+* feat: use Bilibili API instead of web scraping to get videos watch time
+* feat: add pagination to shared entries listing
+* feat: add button to show only starred entries per category
+* build(deps): bump `golang.org/x/term` from `0.23.0` to `0.24.0`
+* build(deps): bump `golang.org/x/oauth2` from `0.22.0` to `0.23.0`
+* build(deps): bump `golang.org/x/net` from `0.28.0` to `0.29.0`
+* build(deps): bump `github.com/PuerkitoBio/goquery` from `1.9.2` to `1.10.0`
+* build(deps): bump `github.com/prometheus/client_golang` from `1.20.3` to `1.20.4`
+* build(deps): bump `github.com/go-webauthn/webauthn` from `0.10.2` to `0.11.2`
+* build: update go.mod to Go 1.23
+* build: bump devcontainer version to go 1.23
+
+Version 2.2.0 (August 18, 2024)
+-------------------------------
+
+* refactor: simplify Youtube feeds discovery
+* fix(integration): define content encoding explicitly when sending article body to Readeck
+* fix(fever): correct sorting direction when using `max_id` argument
+* fix(client): Return `nil` and error if endpoint is an empty string
+* fix: video poster image URL is encoded twice when using `MEDIA_PROXY_MODE=all`
+* fix: use `BASE_URL` instead of `r.Host` to generate absolute media proxy URL
+* fix: panic during YouTube channel feed discovery
+* fix: honor `hide_globally` when creating a new feed through the api
+* fix: align pagination correctly on small screens with non-English text
+* fix: `store.GetEnclosure()` should return `nil` if no rows are returned
+* feat(locale): update Turkish translations
+* feat(locale): update French translations
+* feat(locale): update Chinese` translations
+* feat(integration): add ntfy integration
+* feat(api): add API routes `/v1/enclosures/{enclosureID}`
+* feat: validate `OAUTH2_PROVIDER` config option value
+* feat: remove YouTube video page subscription finder because `meta[itemprop="channelId"]` no longer exists
+* feat: remove well-known URL parameter trackers
+* feat: mark media as read when playback reaches 90%
+* feat: change log level to info when running migrations
+* feat: allow customizing the display name of the OpenID Connect provider
+* feat: add support for `base` HTML element when discovering feeds
+* feat: add support for `aside` HTML element in entry content
+* feat: Add option to disable local auth form
+* feat: add license info to Javascript files for LibreJS compatibility
+* feat: add `FETCH_BILIBILI_WATCH_TIME` config option
+* docs: update links to filtering rules
+* chore: avoid using legacy key/value format in Dockerfile
+* build(deps): bump `golang.org/x/oauth2` from `0.21.0` to `0.22.0`
+* build(deps): bump `golang.org/x/net` from `0.27.0` to `0.28.0`
+* build(deps): bump `golang.org/x/crypto` from `0.25.0` to `0.26.0`
+* build(deps): bump `github.com/tdewolff/minify/v2` from `2.20.36` to `2.20.37`
+* build(deps): bump `github.com/prometheus/client_golang`
+* build: update GitHub Actions to Go 1.23
+* build: publish OCI images only if `PUBLISH_DOCKER_IMAGES=true`
+* build: bump Alpine Linux build image to v3.20
+* build: add sha256 checksum file for published binaries
+
+Version 2.1.4 (July 9, 2024)
+----------------------------
+
+* test: add unit tests for `IsModified()` behaviour
+* refactor: improve YouTube page feed detection
+* fix(ui): settings form is not populated correctly after validation errors
+* fix(ui): playback speed indicator precision
+* fix(ui): playback speed indicator on shared entries
+* fix(integration): preserve existing Pinboard bookmarks
+* fix(googlereader): set `CrawlTimeMsec` to the correct precision
+* fix(build): failed to solve container image `arm64v8/golang:1.22-bookworm`
+* fix(build): add `distroless` suffix on `latest` tag in GitHub workflow
+* fix: use `ETag` as a stronger validator than `Last-Modified`
+* fix: update `theverge.com` rewrite rule to avoid duplicate image
+* fix: incorrect Go package comment `reader/readingtime`
+* fix: error out for improper rewrite regexp when processing feed entries
+* fix: ensures that session cookies are not expiring before the session is cleaned up from the database as per `CLEANUP_REMOVE_SESSIONS_DAYS`
+* fix: `<img>` aspect ratio with `height: auto`
+* feat(ui): add `viewport-fit=cover`
+* feat(sanitizer): add support for HTML hidden attribute
+* feat(locale): update French translations
+* feat(integration): add Raindrop integration
+* feat(integration): add feed name to Telegram message
+* feat(integration): add Betula integration
+* feat: use of insecure TLS ciphers when "Allow self-signed or invalid certificates" is enabled to workaround some broken websites
+* feat: discover feeds from a Youtube playlist pages
+* feat: add navigation to last/first page
+* feat: add global block and keep filters
+* feat: add description field to feed settings
+* feat: add `pitchfork.com` scraping rule
+* feat: add `FETCH_NEBULA_WATCH_TIME` config option
+* Bump `github.com/PuerkitoBio/goquery` from` 1.9.1` to` 1.9.2`
+* Bump `github.com/prometheus/client_golang` from `1.19.0` to `1.19.1`
+* build(deps): bump `library/alpine` in `/packaging/docker/alpine`
+* build(deps): bump `golangci/golangci-lint-action` from `4` to `6`
+* build(deps): bump `golang.org/x/term` from `0.19.0` to `0.22.0`
+* build(deps): bump `golang.org/x/oauth2` from `0.19.0` to `0.21.0`
+* build(deps): bump `golang.org/x/net` from `0.22.0` to `0.27.0`
+* build(deps): bump `golang.org/x/crypto` from `0.24.0` to `0.25.0`
+* build(deps): bump `github.com/yuin/goldmark` from `1.7.1` to `1.7.4`
+* build(deps): bump `github.com/tdewolff/minify/v2` from `2.20.20` to `2.20.36`
+* build(deps): bump `github.com/coreos/go-oidc/v3` from `3.10.0` to `3.11.0`
+* build(deps): bump `docker/build-push-action` from `5` to `6`
+
+Version 2.1.3 (April 27, 2024)
+------------------------------
+
+* `api`: `rand.Intn(math.MaxInt64)` causes tests to fail on 32-bit architectures (use `rand.Int()` instead)
+* `ci`: use `docker/metadata-action` instead of deprecated shell-scripts
+* `database`: remove `entries_feed_url_idx` index because entry URLs can exceeds btree index size limit
+* `finder`: find feeds from YouTube playlist
+* `http/response`: add brotli compression support
+* `integration/matrix`: fix function name in comment
+* `packaging`: specify container registry explicitly (e.g., Podman does not use `docker.io` by default)
+* `packaging`: use `make miniflux` instead of duplicating `go build` arguments (this leverages Go's PIE build mode)
+* `reader/fetcher`: add brotli content encoding support
+* `reader/processor`: minimize feed entries HTML content
+* `reader/rewrite`: add a rule for `oglaf.com`
+* `storage`: change `GetReadTime()` function to use `entries_feed_id_hash_key` index
+* `ui`: add seek and speed controls to media player
+* `ui`: add tag entries page
+* `ui`: fix JavaScript error when clicking on unread counter
+* `ui`: use `FORCE_REFRESH_INTERVAL` config for category refresh
+* Bump `github.com/tdewolff/minify/v2` from `2.20.19` to `2.20.20`
+* Bump `golang.org/x/net` from `0.22.0` to `0.24.0`
+* Bump `golang.org/x/term` from `0.18.0` to `0.19.0`
+* Bump `golang.org/x/oauth2` from `0.18.0` to `0.19.0`
+* Bump `github.com/yuin/goldmark` from `1.7.0` to `1.7.1`
+
 Version 2.1.2 (March 30, 2024)
 ------------------------------
 

Makefile

@@ -1,12 +1,12 @@
-APP          := miniflux
-DOCKER_IMAGE := miniflux/miniflux
-VERSION      := $(shell git describe --tags --abbrev=0 2>/dev/null)
-COMMIT       := $(shell git rev-parse --short HEAD 2>/dev/null)
-BUILD_DATE   := `date +%FT%T%z`
-LD_FLAGS     := "-s -w -X 'miniflux.app/v2/internal/version.Version=$(VERSION)' -X 'miniflux.app/v2/internal/version.Commit=$(COMMIT)' -X 'miniflux.app/v2/internal/version.BuildDate=$(BUILD_DATE)'"
-PKG_LIST     := $(shell go list ./... | grep -v /vendor/)
-DB_URL       := postgres://postgres:postgres@localhost/miniflux_test?sslmode=disable
-DEB_IMG_ARCH := amd64
+APP             := miniflux
+DOCKER_IMAGE    := miniflux/miniflux
+VERSION         := $(shell git describe --tags --abbrev=0 2>/dev/null)
+COMMIT          := $(shell git rev-parse --short HEAD 2>/dev/null)
+BUILD_DATE      := `date +%FT%T%z`
+LD_FLAGS        := "-s -w -X 'miniflux.app/v2/internal/version.Version=$(VERSION)' -X 'miniflux.app/v2/internal/version.Commit=$(COMMIT)' -X 'miniflux.app/v2/internal/version.BuildDate=$(BUILD_DATE)'"
+PKG_LIST        := $(shell go list ./... | grep -v /vendor/)
+DB_URL          := postgres://postgres:postgres@localhost/miniflux_test?sslmode=disable
+DOCKER_PLATFORM := amd64
 
 export PGPASSWORD := postgres
 
@@ -51,33 +51,43 @@ miniflux-no-pie:
 
 linux-amd64:
 	@ CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@ main.go
+	@ sha256sum $(APP)-$@ > $(APP)-$@.sha256
 
 linux-arm64:
 	@ CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@ main.go
+	@ sha256sum $(APP)-$@ > $(APP)-$@.sha256
 
 linux-armv7:
 	@ CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=7 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@ main.go
+	@ sha256sum $(APP)-$@ > $(APP)-$@.sha256
 
 linux-armv6:
 	@ CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=6 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@ main.go
+	@ sha256sum $(APP)-$@ > $(APP)-$@.sha256
 
 linux-armv5:
 	@ CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=5 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@ main.go
+	@ sha256sum $(APP)-$@ > $(APP)-$@.sha256
 
 darwin-amd64:
 	@ GOOS=darwin GOARCH=amd64 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@ main.go
+	@ sha256sum $(APP)-$@ > $(APP)-$@.sha256
 
 darwin-arm64:
 	@ GOOS=darwin GOARCH=arm64 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@ main.go
+	@ sha256sum $(APP)-$@ > $(APP)-$@.sha256
 
 freebsd-amd64:
 	@ CGO_ENABLED=0 GOOS=freebsd GOARCH=amd64 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@ main.go
+	@ sha256sum $(APP)-$@ > $(APP)-$@.sha256
 
 openbsd-amd64:
 	@ GOOS=openbsd GOARCH=amd64 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@ main.go
+	@ sha256sum $(APP)-$@ > $(APP)-$@.sha256
 
 windows-amd64:
 	@ GOOS=windows GOARCH=amd64 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@.exe main.go
+	@ sha256sum $(APP)-$@.exe > $(APP)-$@.exe.sha256
 
 build: linux-amd64 linux-arm64 linux-armv7 linux-armv6 linux-armv5 darwin-amd64 darwin-arm64 freebsd-amd64 openbsd-amd64 windows-amd64
 
@@ -104,7 +114,7 @@ run:
 	@ LOG_DATE_TIME=1 LOG_LEVEL=debug RUN_MIGRATIONS=1 CREATE_ADMIN=1 ADMIN_USERNAME=admin ADMIN_PASSWORD=test123 go run main.go
 
 clean:
-	@ rm -f $(APP)-* $(APP) $(APP)*.rpm $(APP)*.deb $(APP)*.exe
+	@ rm -f $(APP)-* $(APP) $(APP)*.rpm $(APP)*.deb $(APP)*.exe $(APP)*.sha256
 
 test:
 	go test -cover -race -count=1 ./...
@@ -163,15 +173,15 @@ rpm: clean
 		rpmbuild -bb --define "_miniflux_version $(VERSION)" /root/rpmbuild/SPECS/miniflux.spec
 
 debian:
-	@ docker build --load \
-		--build-arg BASE_IMAGE_ARCH=$(DEB_IMG_ARCH) \
-		-t $(DEB_IMG_ARCH)/miniflux-deb-builder \
+	@ docker buildx build --load \
+		--platform linux/$(DOCKER_PLATFORM) \
+		-t miniflux-deb-builder \
 		-f packaging/debian/Dockerfile \
 		.
-	@ docker run --rm \
-		-v ${PWD}:/pkg $(DEB_IMG_ARCH)/miniflux-deb-builder
+	@ docker run --rm --platform linux/$(DOCKER_PLATFORM) \
+		-v ${PWD}:/pkg miniflux-deb-builder
 
 debian-packages: clean
-	$(MAKE) debian DEB_IMG_ARCH=amd64
-	$(MAKE) debian DEB_IMG_ARCH=arm64v8
-	$(MAKE) debian DEB_IMG_ARCH=arm32v7
+	$(MAKE) debian DOCKER_PLATFORM=amd64
+	$(MAKE) debian DOCKER_PLATFORM=arm64
+	$(MAKE) debian DOCKER_PLATFORM=arm/v7

client/client.go

@@ -185,6 +185,25 @@ func (c *Client) MarkAllAsRead(userID int64) error {
 	return err
 }
 
+// IntegrationsStatus fetches the integrations status for the logged user.
+func (c *Client) IntegrationsStatus() (bool, error) {
+	body, err := c.request.Get("/v1/integrations/status")
+	if err != nil {
+		return false, err
+	}
+	defer body.Close()
+
+	var response struct {
+		HasIntegrations bool `json:"has_integrations"`
+	}
+
+	if err := json.NewDecoder(body).Decode(&response); err != nil {
+		return false, fmt.Errorf("miniflux: response error (%v)", err)
+	}
+
+	return response.HasIntegrations, nil
+}
+
 // Discover try to find subscriptions from a website.
 func (c *Client) Discover(url string) (Subscriptions, error) {
 	body, err := c.request.Post("/v1/discover", map[string]string{"url": url})
@@ -613,6 +632,28 @@ func (c *Client) Icon(iconID int64) (*FeedIcon, error) {
 	return feedIcon, nil
 }
 
+// Enclosure fetches a specific enclosure.
+func (c *Client) Enclosure(enclosureID int64) (*Enclosure, error) {
+	body, err := c.request.Get(fmt.Sprintf("/v1/enclosures/%d", enclosureID))
+	if err != nil {
+		return nil, err
+	}
+	defer body.Close()
+
+	var enclosure *Enclosure
+	if err := json.NewDecoder(body).Decode(&enclosure); err != nil {
+		return nil, fmt.Errorf("miniflux: response error(%v)", err)
+	}
+
+	return enclosure, nil
+}
+
+// UpdateEnclosure updates an enclosure.
+func (c *Client) UpdateEnclosure(enclosureID int64, enclosureUpdate *EnclosureUpdateRequest) error {
+	_, err := c.request.Put(fmt.Sprintf("/v1/enclosures/%d", enclosureID), enclosureUpdate)
+	return err
+}
+
 func buildFilterQueryString(path string, filter *Filter) string {
 	if filter != nil {
 		values := url.Values{}
@@ -685,6 +726,10 @@ func buildFilterQueryString(path string, filter *Filter) string {
 			values.Set("feed_id", strconv.FormatInt(filter.FeedID, 10))
 		}
 
+		if filter.GloballyVisible {
+			values.Set("globally_visible", "true")
+		}
+
 		for _, status := range filter.Statuses {
 			values.Add("status", status)
 		}

client/model.go

@@ -27,6 +27,7 @@ type User struct {
 	EntryDirection         string     `json:"entry_sorting_direction"`
 	EntryOrder             string     `json:"entry_sorting_order"`
 	Stylesheet             string     `json:"stylesheet"`
+	CustomJS               string     `json:"custom_js"`
 	GoogleID               string     `json:"google_id"`
 	OpenIDConnectID        string     `json:"openid_connect_id"`
 	EntriesPerPage         int        `json:"entries_per_page"`
@@ -42,6 +43,9 @@ type User struct {
 	CategoriesSortingOrder string     `json:"categories_sorting_order"`
 	MarkReadOnView         bool       `json:"mark_read_on_view"`
 	MediaPlaybackRate      float64    `json:"media_playback_rate"`
+	BlockFilterEntryRules  string     `json:"block_filter_entry_rules"`
+	KeepFilterEntryRules   string     `json:"keep_filter_entry_rules"`
+	ExternalFontHosts      string     `json:"external_font_hosts"`
 }
 
 func (u User) String() string {
@@ -68,6 +72,7 @@ type UserModificationRequest struct {
 	EntryDirection         *string  `json:"entry_sorting_direction"`
 	EntryOrder             *string  `json:"entry_sorting_order"`
 	Stylesheet             *string  `json:"stylesheet"`
+	CustomJS               *string  `json:"custom_js"`
 	GoogleID               *string  `json:"google_id"`
 	OpenIDConnectID        *string  `json:"openid_connect_id"`
 	EntriesPerPage         *int     `json:"entries_per_page"`
@@ -82,6 +87,9 @@ type UserModificationRequest struct {
 	CategoriesSortingOrder *string  `json:"categories_sorting_order"`
 	MarkReadOnView         *bool    `json:"mark_read_on_view"`
 	MediaPlaybackRate      *float64 `json:"media_playback_rate"`
+	BlockFilterEntryRules  *string  `json:"block_filter_entry_rules"`
+	KeepFilterEntryRules   *string  `json:"keep_filter_entry_rules"`
+	ExternalFontHosts      *string  `json:"external_font_hosts"`
 }
 
 // Users represents a list of users.
@@ -238,12 +246,17 @@ type Entries []*Entry
 
 // Enclosure represents an attachment.
 type Enclosure struct {
-	ID       int64  `json:"id"`
-	UserID   int64  `json:"user_id"`
-	EntryID  int64  `json:"entry_id"`
-	URL      string `json:"url"`
-	MimeType string `json:"mime_type"`
-	Size     int    `json:"size"`
+	ID               int64  `json:"id"`
+	UserID           int64  `json:"user_id"`
+	EntryID          int64  `json:"entry_id"`
+	URL              string `json:"url"`
+	MimeType         string `json:"mime_type"`
+	Size             int    `json:"size"`
+	MediaProgression int64  `json:"media_progression"`
+}
+
+type EnclosureUpdateRequest struct {
+	MediaProgression int64 `json:"media_progression"`
 }
 
 // Enclosures represents a list of attachments.
@@ -274,6 +287,7 @@ type Filter struct {
 	CategoryID      int64
 	FeedID          int64
 	Statuses        []string
+	GloballyVisible bool
 }
 
 // EntryResultSet represents the response when fetching entries.

client/request.go

@@ -27,6 +27,7 @@ var (
 	ErrServerError   = errors.New("miniflux: internal server error")
 	ErrNotFound      = errors.New("miniflux: resource not found")
 	ErrBadRequest    = errors.New("miniflux: bad request")
+	ErrEmptyEndpoint = errors.New("miniflux: empty endpoint provided")
 )
 
 type errorResponse struct {
@@ -62,6 +63,9 @@ func (r *request) Delete(path string) error {
 }
 
 func (r *request) execute(method, path string, data interface{}) (io.ReadCloser, error) {
+	if r.endpoint == "" {
+		return nil, ErrEmptyEndpoint
+	}
 	if r.endpoint[len(r.endpoint)-1:] == "/" {
 		r.endpoint = r.endpoint[:len(r.endpoint)-1]
 	}
@@ -141,7 +145,7 @@ func (r *request) execute(method, path string, data interface{}) (io.ReadCloser,
 
 func (r *request) buildClient() http.Client {
 	return http.Client{
-		Timeout: time.Duration(defaultTimeout * time.Second),
+		Timeout: defaultTimeout * time.Second,
 	}
 }
 

go.mod

@@ -1,48 +1,48 @@
 module miniflux.app/v2
 
-// +heroku goVersion go1.22
+// +heroku goVersion go1.23
 
 require (
-	github.com/PuerkitoBio/goquery v1.9.1
-	github.com/abadojack/whatlanggo v1.0.1
-	github.com/coreos/go-oidc/v3 v3.10.0
-	github.com/go-webauthn/webauthn v0.10.2
+	github.com/PuerkitoBio/goquery v1.10.2
+	github.com/andybalholm/brotli v1.1.1
+	github.com/coreos/go-oidc/v3 v3.12.0
+	github.com/go-webauthn/webauthn v0.11.2
 	github.com/gorilla/mux v1.8.1
 	github.com/lib/pq v1.10.9
-	github.com/prometheus/client_golang v1.19.0
-	github.com/tdewolff/minify/v2 v2.20.19
-	github.com/yuin/goldmark v1.7.0
-	golang.org/x/crypto v0.21.0
-	golang.org/x/net v0.22.0
-	golang.org/x/oauth2 v0.18.0
-	golang.org/x/term v0.18.0
-	golang.org/x/text v0.14.0
-	mvdan.cc/xurls/v2 v2.5.0
+	github.com/mattn/go-sqlite3 v1.14.24
+	github.com/prometheus/client_golang v1.20.5
+	github.com/tdewolff/minify/v2 v2.21.3
+	golang.org/x/crypto v0.33.0
+	golang.org/x/image v0.24.0
+	golang.org/x/net v0.35.0
+	golang.org/x/oauth2 v0.26.0
+	golang.org/x/term v0.29.0
 )
 
 require (
-	github.com/go-webauthn/x v0.1.9 // indirect
+	github.com/go-webauthn/x v0.1.14 // indirect
 	github.com/golang-jwt/jwt/v5 v5.2.1 // indirect
-	github.com/google/go-tpm v0.9.0 // indirect
+	github.com/google/go-tpm v0.9.1 // indirect
 )
 
 require (
-	github.com/andybalholm/cascadia v1.3.2 // indirect
+	github.com/andybalholm/cascadia v1.3.3 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
-	github.com/cespare/xxhash/v2 v2.2.0 // indirect
-	github.com/fxamacker/cbor/v2 v2.6.0 // indirect
-	github.com/go-jose/go-jose/v4 v4.0.1 // indirect
-	github.com/golang/protobuf v1.5.3 // indirect
+	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/fxamacker/cbor/v2 v2.7.0 // indirect
+	github.com/go-jose/go-jose/v4 v4.0.2 // indirect
 	github.com/google/uuid v1.6.0 // indirect
+	github.com/klauspost/compress v1.17.9 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // indirect
-	github.com/prometheus/client_model v0.5.0 // indirect
-	github.com/prometheus/common v0.48.0 // indirect
-	github.com/prometheus/procfs v0.12.0 // indirect
-	github.com/tdewolff/parse/v2 v2.7.12 // indirect
+	github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect
+	github.com/prometheus/client_model v0.6.1 // indirect
+	github.com/prometheus/common v0.55.0 // indirect
+	github.com/prometheus/procfs v0.15.1 // indirect
+	github.com/tdewolff/parse/v2 v2.7.19 // indirect
 	github.com/x448/float16 v0.8.4 // indirect
-	golang.org/x/sys v0.18.0 // indirect
-	google.golang.org/appengine v1.6.8 // indirect
-	google.golang.org/protobuf v1.33.0 // indirect
+	golang.org/x/sys v0.30.0 // indirect
+	golang.org/x/text v0.22.0 // indirect
+	google.golang.org/protobuf v1.34.2 // indirect
 )
 
-go 1.22
+go 1.23

go.sum

@@ -1,122 +1,149 @@
-github.com/PuerkitoBio/goquery v1.9.1 h1:mTL6XjbJTZdpfL+Gwl5U2h1l9yEkJjhmlTeV9VPW7UI=
-github.com/PuerkitoBio/goquery v1.9.1/go.mod h1:cW1n6TmIMDoORQU5IU/P1T3tGFunOeXEpGP2WHRwkbY=
-github.com/abadojack/whatlanggo v1.0.1 h1:19N6YogDnf71CTHm3Mp2qhYfkRdyvbgwWdd2EPxJRG4=
-github.com/abadojack/whatlanggo v1.0.1/go.mod h1:66WiQbSbJBIlOZMsvbKe5m6pzQovxCH9B/K8tQB2uoc=
-github.com/andybalholm/cascadia v1.3.2 h1:3Xi6Dw5lHF15JtdcmAHD3i1+T8plmv7BQ/nsViSLyss=
-github.com/andybalholm/cascadia v1.3.2/go.mod h1:7gtRlve5FxPPgIgX36uWBX58OdBsSS6lUvCFb+h7KvU=
+github.com/PuerkitoBio/goquery v1.10.2 h1:7fh2BdHcG6VFZsK7toXBT/Bh1z5Wmy8Q9MV9HqT2AM8=
+github.com/PuerkitoBio/goquery v1.10.2/go.mod h1:0guWGjcLu9AYC7C1GHnpysHy056u9aEkUHwhdnePMCU=
+github.com/andybalholm/brotli v1.1.1 h1:PR2pgnyFznKEugtsUo0xLdDop5SKXd5Qf5ysW+7XdTA=
+github.com/andybalholm/brotli v1.1.1/go.mod h1:05ib4cKhjx3OQYUY22hTVd34Bc8upXjOLL2rKwwZBoA=
+github.com/andybalholm/cascadia v1.3.3 h1:AG2YHrzJIm4BZ19iwJ/DAua6Btl3IwJX+VI4kktS1LM=
+github.com/andybalholm/cascadia v1.3.3/go.mod h1:xNd9bqTn98Ln4DwST8/nG+H0yuB8Hmgu1YHNnWw0GeA=
 github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM=
 github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw=
-github.com/cespare/xxhash/v2 v2.2.0 h1:DC2CZ1Ep5Y4k3ZQ899DldepgrayRUGE6BBZ/cd9Cj44=
-github.com/cespare/xxhash/v2 v2.2.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/coreos/go-oidc/v3 v3.10.0 h1:tDnXHnLyiTVyT/2zLDGj09pFPkhND8Gl8lnTRhoEaJU=
-github.com/coreos/go-oidc/v3 v3.10.0/go.mod h1:5j11xcw0D3+SGxn6Z/WFADsgcWVMyNAlSQupk0KK3ac=
+github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
+github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
+github.com/coreos/go-oidc/v3 v3.12.0 h1:sJk+8G2qq94rDI6ehZ71Bol3oUHy63qNYmkiSjrc/Jo=
+github.com/coreos/go-oidc/v3 v3.12.0/go.mod h1:gE3LgjOgFoHi9a4ce4/tJczr0Ai2/BoDhf0r5lltWI0=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/fxamacker/cbor/v2 v2.6.0 h1:sU6J2usfADwWlYDAFhZBQ6TnLFBHxgesMrQfQgk1tWA=
-github.com/fxamacker/cbor/v2 v2.6.0/go.mod h1:pxXPTn3joSm21Gbwsv0w9OSA2y1HFR9qXEeXQVeNoDQ=
-github.com/go-jose/go-jose/v4 v4.0.1 h1:QVEPDE3OluqXBQZDcnNvQrInro2h0e4eqNbnZSWqS6U=
-github.com/go-jose/go-jose/v4 v4.0.1/go.mod h1:WVf9LFMHh/QVrmqrOfqun0C45tMe3RoiKJMPvgWwLfY=
-github.com/go-webauthn/webauthn v0.10.2 h1:OG7B+DyuTytrEPFmTX503K77fqs3HDK/0Iv+z8UYbq4=
-github.com/go-webauthn/webauthn v0.10.2/go.mod h1:Gd1IDsGAybuvK1NkwUTLbGmeksxuRJjVN2PE/xsPxHs=
-github.com/go-webauthn/x v0.1.9 h1:v1oeLmoaa+gPOaZqUdDentu6Rl7HkSSsmOT6gxEQHhE=
-github.com/go-webauthn/x v0.1.9/go.mod h1:pJNMlIMP1SU7cN8HNlKJpLEnFHCygLCvaLZ8a1xeoQA=
+github.com/fxamacker/cbor/v2 v2.7.0 h1:iM5WgngdRBanHcxugY4JySA0nk1wZorNOpTgCMedv5E=
+github.com/fxamacker/cbor/v2 v2.7.0/go.mod h1:pxXPTn3joSm21Gbwsv0w9OSA2y1HFR9qXEeXQVeNoDQ=
+github.com/go-jose/go-jose/v4 v4.0.2 h1:R3l3kkBds16bO7ZFAEEcofK0MkrAJt3jlJznWZG0nvk=
+github.com/go-jose/go-jose/v4 v4.0.2/go.mod h1:WVf9LFMHh/QVrmqrOfqun0C45tMe3RoiKJMPvgWwLfY=
+github.com/go-webauthn/webauthn v0.11.2 h1:Fgx0/wlmkClTKlnOsdOQ+K5HcHDsDcYIvtYmfhEOSUc=
+github.com/go-webauthn/webauthn v0.11.2/go.mod h1:aOtudaF94pM71g3jRwTYYwQTG1KyTILTcZqN1srkmD0=
+github.com/go-webauthn/x v0.1.14 h1:1wrB8jzXAofojJPAaRxnZhRgagvLGnLjhCAwg3kTpT0=
+github.com/go-webauthn/x v0.1.14/go.mod h1:UuVvFZ8/NbOnkDz3y1NaxtUN87pmtpC1PQ+/5BBQRdc=
 github.com/golang-jwt/jwt/v5 v5.2.1 h1:OuVbFODueb089Lh128TAcimifWaLhJwVflnrgM17wHk=
 github.com/golang-jwt/jwt/v5 v5.2.1/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
-github.com/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk=
-github.com/golang/protobuf v1.5.2/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
-github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg=
-github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY=
-github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
 github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
-github.com/google/go-tpm v0.9.0 h1:sQF6YqWMi+SCXpsmS3fd21oPy/vSddwZry4JnmltHVk=
-github.com/google/go-tpm v0.9.0/go.mod h1:FkNVkc6C+IsvDI9Jw1OveJmxGZUUaKxtrpOS47QWKfU=
+github.com/google/go-tpm v0.9.1 h1:0pGc4X//bAlmZzMKf8iz6IsDo1nYTbYJ6FZN/rg4zdM=
+github.com/google/go-tpm v0.9.1/go.mod h1:h9jEsEECg7gtLis0upRBQU+GhYVH6jMjrFxI8u6bVUY=
 github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY=
 github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ=
+github.com/klauspost/compress v1.17.9 h1:6KIumPrER1LHsvBVuDa0r5xaG0Es51mhhB9BQB2qeMA=
+github.com/klauspost/compress v1.17.9/go.mod h1:Di0epgTjJY877eYKx5yC51cX2A2Vl2ibi7bDH9ttBbw=
+github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc=
+github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw=
 github.com/lib/pq v1.10.9 h1:YXG7RB+JIjhP29X+OtkiDnYaXQwpS4JEWq7dtCCRUEw=
 github.com/lib/pq v1.10.9/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
+github.com/mattn/go-sqlite3 v1.14.24 h1:tpSp2G2KyMnnQu99ngJ47EIkWVmliIizyZBfPrBWDRM=
+github.com/mattn/go-sqlite3 v1.14.24/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
 github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
 github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
+github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA=
+github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/prometheus/client_golang v1.19.0 h1:ygXvpU1AoN1MhdzckN+PyD9QJOSD4x7kmXYlnfbA6JU=
-github.com/prometheus/client_golang v1.19.0/go.mod h1:ZRM9uEAypZakd+q/x7+gmsvXdURP+DABIEIjnmDdp+k=
-github.com/prometheus/client_model v0.5.0 h1:VQw1hfvPvk3Uv6Qf29VrPF32JB6rtbgI6cYPYQjL0Qw=
-github.com/prometheus/client_model v0.5.0/go.mod h1:dTiFglRmd66nLR9Pv9f0mZi7B7fk5Pm3gvsjB5tr+kI=
-github.com/prometheus/common v0.48.0 h1:QO8U2CdOzSn1BBsmXJXduaaW+dY/5QLjfB8svtSzKKE=
-github.com/prometheus/common v0.48.0/go.mod h1:0/KsvlIEfPQCQ5I2iNSAWKPZziNCvRs5EC6ILDTlAPc=
-github.com/prometheus/procfs v0.12.0 h1:jluTpSng7V9hY0O2R9DzzJHYb2xULk9VTR1V1R/k6Bo=
-github.com/prometheus/procfs v0.12.0/go.mod h1:pcuDEFsWDnvcgNzo4EEweacyhjeA9Zk3cnaOZAZEfOo=
+github.com/prometheus/client_golang v1.20.5 h1:cxppBPuYhUnsO6yo/aoRol4L7q7UFfdm+bR9r+8l63Y=
+github.com/prometheus/client_golang v1.20.5/go.mod h1:PIEt8X02hGcP8JWbeHyeZ53Y/jReSnHgO035n//V5WE=
+github.com/prometheus/client_model v0.6.1 h1:ZKSh/rekM+n3CeS952MLRAdFwIKqeY8b62p8ais2e9E=
+github.com/prometheus/client_model v0.6.1/go.mod h1:OrxVMOVHjw3lKMa8+x6HeMGkHMQyHDk9E3jmP2AmGiY=
+github.com/prometheus/common v0.55.0 h1:KEi6DK7lXW/m7Ig5i47x0vRzuBsHuvJdi5ee6Y3G1dc=
+github.com/prometheus/common v0.55.0/go.mod h1:2SECS4xJG1kd8XF9IcM1gMX6510RAEL65zxzNImwdc8=
+github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc=
+github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk=
 github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg=
 github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-github.com/tdewolff/minify/v2 v2.20.19 h1:tX0SR0LUrIqGoLjXnkIzRSIbKJ7PaNnSENLD4CyH6Xo=
-github.com/tdewolff/minify/v2 v2.20.19/go.mod h1:ulkFoeAVWMLEyjuDz1ZIWOA31g5aWOawCFRp9R/MudM=
-github.com/tdewolff/parse/v2 v2.7.12 h1:tgavkHc2ZDEQVKy1oWxwIyh5bP4F5fEh/JmBwPP/3LQ=
-github.com/tdewolff/parse/v2 v2.7.12/go.mod h1:3FbJWZp3XT9OWVN3Hmfp0p/a08v4h8J9W1aghka0soA=
+github.com/tdewolff/minify/v2 v2.21.3 h1:KmhKNGrN/dGcvb2WDdB5yA49bo37s+hcD8RiF+lioV8=
+github.com/tdewolff/minify/v2 v2.21.3/go.mod h1:iGxHaGiONAnsYuo8CRyf8iPUcqRJVB/RhtEcTpqS7xw=
+github.com/tdewolff/parse/v2 v2.7.19 h1:7Ljh26yj+gdLFEq/7q9LT4SYyKtwQX4ocNrj45UCePg=
+github.com/tdewolff/parse/v2 v2.7.19/go.mod h1:3FbJWZp3XT9OWVN3Hmfp0p/a08v4h8J9W1aghka0soA=
 github.com/tdewolff/test v1.0.11-0.20231101010635-f1265d231d52/go.mod h1:6DAvZliBAAnD7rhVgwaM7DE5/d9NMOAJ09SqYqeK4QE=
 github.com/tdewolff/test v1.0.11-0.20240106005702-7de5f7df4739 h1:IkjBCtQOOjIn03u/dMQK9g+Iw9ewps4mCl1nB8Sscbo=
 github.com/tdewolff/test v1.0.11-0.20240106005702-7de5f7df4739/go.mod h1:XPuWBzvdUzhCuxWO1ojpXsyzsA5bFoS3tO/Q3kFuTG8=
 github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM=
 github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcYsOfg=
+github.com/xyproto/randomstring v1.0.5 h1:YtlWPoRdgMu3NZtP45drfy1GKoojuR7hmRcnhZqKjWU=
+github.com/xyproto/randomstring v1.0.5/go.mod h1:rgmS5DeNXLivK7YprL0pY+lTuhNQW3iGxZ18UQApw/E=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
-github.com/yuin/goldmark v1.7.0 h1:EfOIvIMZIzHdB/R/zVrikYLPPwJlfMcNczJFMs1m6sA=
-github.com/yuin/goldmark v1.7.0/go.mod h1:uzxRWxtg69N339t3louHJ7+O03ezfj6PlliRlaOzY1E=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
-golang.org/x/crypto v0.21.0 h1:X31++rzVUdKhX5sWmSOFZxx8UW/ldWx55cbf08iNAMA=
-golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs=
+golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliYc=
+golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
+golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
+golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk=
+golang.org/x/crypto v0.33.0 h1:IOBPskki6Lysi0lo9qQvbxiQ+FvsCC/YWOecCHAixus=
+golang.org/x/crypto v0.33.0/go.mod h1:bVdXmD7IV/4GdElGPozy6U7lWdRXA4qyRVGJV57uQ5M=
+golang.org/x/image v0.24.0 h1:AN7zRgVsbvmTfNyqIbbOraYL8mSwcKncEj8ofjgzcMQ=
+golang.org/x/image v0.24.0/go.mod h1:4b/ITuLfqYq1hqZcjofwctIhi7sZh2WaCjvsBNjjya8=
 golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
 golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/mod v0.15.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
+golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
 golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
 golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
 golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
 golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
-golang.org/x/net v0.9.0/go.mod h1:d48xBJpPfHeWQsugry2m+kC02ZBRGRgulfHnEXEuWns=
-golang.org/x/net v0.22.0 h1:9sGLhx7iRIHEiX0oAJ3MRZMUCElJgy7Br1nO+AMN3Tc=
-golang.org/x/net v0.22.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg=
-golang.org/x/oauth2 v0.18.0 h1:09qnuIAgzdx1XplqJvW6CQqMCtGZykZWcXzPMPUusvI=
-golang.org/x/oauth2 v0.18.0/go.mod h1:Wf7knwG0MPoWIMMBgFlEaSUDaKskp0dCfrlJRJXbBi8=
+golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
+golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk=
+golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
+golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
+golang.org/x/net v0.33.0/go.mod h1:HXLR5J+9DxmrqMwG9qjGCxZ+zKXxBru04zlTvWlWuN4=
+golang.org/x/net v0.35.0 h1:T5GQRQb2y08kTAByq9L4/bz8cipCdA8FbRTXewonqY8=
+golang.org/x/net v0.35.0/go.mod h1:EglIi67kWsHKlRzzVMUD93VMSWGFOMSZgxFjparz1Qk=
+golang.org/x/oauth2 v0.26.0 h1:afQXWNNaeC4nvZ0Ed9XvCCzXM6UHJG7iCg0W4fPqSBE=
+golang.org/x/oauth2 v0.26.0/go.mod h1:XYTD2NtWslqkgxebSiOHnXEap4TF09sJSc7H1sXbhtI=
 golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
 golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
+golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.10.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.7.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.18.0 h1:DBdB3niSjOA/O0blCZBqDefyWNYveAYMNF1Wum0DYQ4=
-golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.28.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
+golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
-golang.org/x/term v0.7.0/go.mod h1:P32HKFT3hSsZrRxla30E9HqToFYAQPCMs/zFMBUFqPY=
-golang.org/x/term v0.18.0 h1:FcHjZXDMxI8mM3nwhX9HlKop4C0YQvCVCdwYl2wOtE8=
-golang.org/x/term v0.18.0/go.mod h1:ILwASektA3OnRv7amZ1xhE/KTR+u50pbXfZ03+6Nx58=
+golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
+golang.org/x/term v0.12.0/go.mod h1:owVbMEjm3cBLCHdkQu9b1opXd4ETQWc3BhuQGKgXgvU=
+golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
+golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
+golang.org/x/term v0.27.0/go.mod h1:iMsnZpn0cago0GOrHO2+Y7u7JPn5AylBrcoWkElMTSM=
+golang.org/x/term v0.29.0 h1:L6pJp37ocefwRRtYPKSWOWzOtWSxVajvz2ldH/xi3iU=
+golang.org/x/term v0.29.0/go.mod h1:6bl4lRlvVuDgSf3179VpIxBF0o10JUpXWOnI7nErv7s=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
-golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=
 golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
 golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
-golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
+golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ=
+golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM=
+golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
 golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
+golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58=
+golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=
 golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-google.golang.org/appengine v1.6.8 h1:IhEN5q69dyKagZPYMSdIjS2HqprW324FRQZJcGqPAsM=
-google.golang.org/appengine v1.6.8/go.mod h1:1jJ3jBArFh5pcgW8gCtRJnepW8FzD1V44FJffLiz/Ds=
-google.golang.org/protobuf v1.26.0-rc.1/go.mod h1:jlhhOSvTdKEhbULTjvd4ARK9grFBp09yW+WbY/TyQbw=
-google.golang.org/protobuf v1.26.0/go.mod h1:9q0QmTI4eRPtz6boOQmLYwt+qCgq0jsYwAQnmE0givc=
-google.golang.org/protobuf v1.33.0 h1:uNO2rsAINq/JlFpSdYEKIZ0uKD/R9cpdv0T+yoGwGmI=
-google.golang.org/protobuf v1.33.0/go.mod h1:c6P6GXX6sHbq/GpV6MGZEdwhWPcYBgnhAHhKbcUYpos=
+google.golang.org/protobuf v1.34.2 h1:6xV6lTsCfpGD21XK49h7MhtcApnLqkfYgPcdHftf6hg=
+google.golang.org/protobuf v1.34.2/go.mod h1:qYOHts0dSfpeUzUFpOMr/WGzszTmLH+DiWniOlNbLDw=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-mvdan.cc/xurls/v2 v2.5.0 h1:lyBNOm8Wo71UknhUs4QTFUNNMyxy2JEIaKKo0RWOh+8=
-mvdan.cc/xurls/v2 v2.5.0/go.mod h1:yQgaGQ1rFtJUzkmKiHYSSfuQxqfYmd//X6PxvholpeE=

internal/api/api.go

@@ -72,6 +72,9 @@ func Serve(router *mux.Router, store *storage.Storage, pool *worker.Pool) {
 	sr.HandleFunc("/entries/{entryID}/fetch-content", handler.fetchContent).Methods(http.MethodGet)
 	sr.HandleFunc("/flush-history", handler.flushHistory).Methods(http.MethodPut, http.MethodDelete)
 	sr.HandleFunc("/icons/{iconID}", handler.getIconByIconID).Methods(http.MethodGet)
+	sr.HandleFunc("/enclosures/{enclosureID}", handler.getEnclosureByID).Methods(http.MethodGet)
+	sr.HandleFunc("/enclosures/{enclosureID}", handler.updateEnclosureByID).Methods(http.MethodPut)
+	sr.HandleFunc("/integrations/status", handler.getIntegrationsStatus).Methods(http.MethodGet)
 	sr.HandleFunc("/version", handler.versionHandler).Methods(http.MethodGet)
 }
 

internal/api/api_integration_test.go

@@ -8,7 +8,6 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"math"
 	"math/rand"
 	"os"
 	"strings"
@@ -58,7 +57,7 @@ func (c *integrationTestConfig) isConfigured() bool {
 }
 
 func (c *integrationTestConfig) genRandomUsername() string {
-	return fmt.Sprintf("%s_%10d", c.testRegularUsername, rand.Intn(math.MaxInt64))
+	return fmt.Sprintf("%s_%10d", c.testRegularUsername, rand.Int())
 }
 
 func TestIncorrectEndpoint(t *testing.T) {
@@ -68,10 +67,14 @@ func TestIncorrectEndpoint(t *testing.T) {
 	}
 
 	client := miniflux.NewClient("incorrect url")
-	_, err := client.Users()
-	if err == nil {
+	if _, err := client.Users(); err == nil {
 		t.Fatal(`Using an incorrect URL should raise an error`)
 	}
+
+	client = miniflux.NewClient("")
+	if _, err := client.Users(); err == nil {
+		t.Fatal(`Using an empty URL should raise an error`)
+	}
 }
 
 func TestHealthcheckEndpoint(t *testing.T) {
@@ -589,6 +592,88 @@ func TestUpdateUserEndpointByChangingDefaultTheme(t *testing.T) {
 	}
 }
 
+func TestUpdateUserEndpointByChangingExternalFonts(t *testing.T) {
+	testConfig := newIntegrationTestConfig()
+	if !testConfig.isConfigured() {
+		t.Skip(skipIntegrationTestsMessage)
+	}
+
+	adminClient := miniflux.NewClient(testConfig.testBaseURL, testConfig.testAdminUsername, testConfig.testAdminPassword)
+	regularTestUser, err := adminClient.CreateUser(testConfig.genRandomUsername(), testConfig.testRegularPassword, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer adminClient.DeleteUser(regularTestUser.ID)
+
+	regularUserClient := miniflux.NewClient(testConfig.testBaseURL, regularTestUser.Username, testConfig.testRegularPassword)
+
+	userUpdateRequest := &miniflux.UserModificationRequest{
+		ExternalFontHosts: miniflux.SetOptionalField("  fonts.example.org  "),
+	}
+
+	updatedUser, err := regularUserClient.UpdateUser(regularTestUser.ID, userUpdateRequest)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if updatedUser.ExternalFontHosts != "fonts.example.org" {
+		t.Fatalf(`Invalid external font hosts, got "%v"`, updatedUser.ExternalFontHosts)
+	}
+}
+
+func TestUpdateUserEndpointByChangingExternalFontsWithInvalidValue(t *testing.T) {
+	testConfig := newIntegrationTestConfig()
+	if !testConfig.isConfigured() {
+		t.Skip(skipIntegrationTestsMessage)
+	}
+
+	adminClient := miniflux.NewClient(testConfig.testBaseURL, testConfig.testAdminUsername, testConfig.testAdminPassword)
+	regularTestUser, err := adminClient.CreateUser(testConfig.genRandomUsername(), testConfig.testRegularPassword, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer adminClient.DeleteUser(regularTestUser.ID)
+
+	regularUserClient := miniflux.NewClient(testConfig.testBaseURL, regularTestUser.Username, testConfig.testRegularPassword)
+
+	userUpdateRequest := &miniflux.UserModificationRequest{
+		ExternalFontHosts: miniflux.SetOptionalField("'self' *"),
+	}
+
+	if _, err := regularUserClient.UpdateUser(regularTestUser.ID, userUpdateRequest); err == nil {
+		t.Fatal(`Updating the user with an invalid external font host should raise an error`)
+	}
+}
+
+func TestUpdateUserEndpointByChangingCustomJS(t *testing.T) {
+	testConfig := newIntegrationTestConfig()
+	if !testConfig.isConfigured() {
+		t.Skip(skipIntegrationTestsMessage)
+	}
+
+	adminClient := miniflux.NewClient(testConfig.testBaseURL, testConfig.testAdminUsername, testConfig.testAdminPassword)
+	regularTestUser, err := adminClient.CreateUser(testConfig.genRandomUsername(), testConfig.testRegularPassword, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer adminClient.DeleteUser(regularTestUser.ID)
+
+	regularUserClient := miniflux.NewClient(testConfig.testBaseURL, regularTestUser.Username, testConfig.testRegularPassword)
+
+	userUpdateRequest := &miniflux.UserModificationRequest{
+		CustomJS: miniflux.SetOptionalField("alert('Hello, World!');"),
+	}
+
+	updatedUser, err := regularUserClient.UpdateUser(regularTestUser.ID, userUpdateRequest)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if updatedUser.CustomJS != "alert('Hello, World!');" {
+		t.Fatalf(`Invalid custom JS, got %q`, updatedUser.CustomJS)
+	}
+}
+
 func TestUpdateUserEndpointByChangingDefaultThemeToInvalidValue(t *testing.T) {
 	testConfig := newIntegrationTestConfig()
 	if !testConfig.isConfigured() {
@@ -1987,6 +2072,176 @@ func TestGetAllEntriesEndpointWithFilter(t *testing.T) {
 	}
 }
 
+func TestGetGlobalEntriesEndpoint(t *testing.T) {
+	testConfig := newIntegrationTestConfig()
+	if !testConfig.isConfigured() {
+		t.Skip(skipIntegrationTestsMessage)
+	}
+
+	adminClient := miniflux.NewClient(testConfig.testBaseURL, testConfig.testAdminUsername, testConfig.testAdminPassword)
+
+	regularTestUser, err := adminClient.CreateUser(testConfig.genRandomUsername(), testConfig.testRegularPassword, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer adminClient.DeleteUser(regularTestUser.ID)
+
+	regularUserClient := miniflux.NewClient(testConfig.testBaseURL, regularTestUser.Username, testConfig.testRegularPassword)
+
+	feedID, err := regularUserClient.CreateFeed(&miniflux.FeedCreationRequest{
+		FeedURL:      testConfig.testFeedURL,
+		HideGlobally: true,
+	})
+
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	feedIDEntry, err := regularUserClient.Feed(feedID)
+
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if feedIDEntry.HideGlobally != true {
+		t.Fatalf(`Expected feed to have globally_hidden set to true, was false.`)
+	}
+
+	/* Not filtering on GloballyVisible should return all entries */
+	feedEntries, err := regularUserClient.Entries(&miniflux.Filter{FeedID: feedID})
+
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if len(feedEntries.Entries) == 0 {
+		t.Fatalf(`Expected entries but response contained none.`)
+	}
+
+	/* Feed is hidden globally, so this should be empty */
+	globallyVisibleEntries, err := regularUserClient.Entries(&miniflux.Filter{GloballyVisible: true})
+
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if len(globallyVisibleEntries.Entries) != 0 {
+		t.Fatalf(`Expected no entries, got %d`, len(globallyVisibleEntries.Entries))
+	}
+}
+
+func TestUpdateEnclosureEndpoint(t *testing.T) {
+	testConfig := newIntegrationTestConfig()
+	if !testConfig.isConfigured() {
+		t.Skip(skipIntegrationTestsMessage)
+	}
+
+	adminClient := miniflux.NewClient(testConfig.testBaseURL, testConfig.testAdminUsername, testConfig.testAdminPassword)
+
+	regularTestUser, err := adminClient.CreateUser(testConfig.genRandomUsername(), testConfig.testRegularPassword, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer adminClient.DeleteUser(regularTestUser.ID)
+
+	regularUserClient := miniflux.NewClient(testConfig.testBaseURL, regularTestUser.Username, testConfig.testRegularPassword)
+
+	feedID, err := regularUserClient.CreateFeed(&miniflux.FeedCreationRequest{
+		FeedURL: testConfig.testFeedURL,
+	})
+
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	result, err := regularUserClient.FeedEntries(feedID, nil)
+	if err != nil {
+		t.Fatalf(`Failed to get entries: %v`, err)
+	}
+
+	var enclosure *miniflux.Enclosure
+	for _, entry := range result.Entries {
+		if len(entry.Enclosures) > 0 {
+			enclosure = entry.Enclosures[0]
+			break
+		}
+	}
+
+	if enclosure == nil {
+		t.Skip(`Skipping test, missing enclosure in feed.`)
+	}
+
+	err = regularUserClient.UpdateEnclosure(enclosure.ID, &miniflux.EnclosureUpdateRequest{
+		MediaProgression: 20,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	updatedEnclosure, err := regularUserClient.Enclosure(enclosure.ID)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if updatedEnclosure.MediaProgression != 20 {
+		t.Fatalf(`Failed to update media_progression, expected %d but got %d`, 20, updatedEnclosure.MediaProgression)
+	}
+}
+
+func TestGetEnclosureEndpoint(t *testing.T) {
+	testConfig := newIntegrationTestConfig()
+	if !testConfig.isConfigured() {
+		t.Skip(skipIntegrationTestsMessage)
+	}
+
+	adminClient := miniflux.NewClient(testConfig.testBaseURL, testConfig.testAdminUsername, testConfig.testAdminPassword)
+
+	regularTestUser, err := adminClient.CreateUser(testConfig.genRandomUsername(), testConfig.testRegularPassword, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer adminClient.DeleteUser(regularTestUser.ID)
+
+	regularUserClient := miniflux.NewClient(testConfig.testBaseURL, regularTestUser.Username, testConfig.testRegularPassword)
+
+	feedID, err := regularUserClient.CreateFeed(&miniflux.FeedCreationRequest{
+		FeedURL: testConfig.testFeedURL,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	result, err := regularUserClient.FeedEntries(feedID, nil)
+	if err != nil {
+		t.Fatalf(`Failed to get entries: %v`, err)
+	}
+
+	var expectedEnclosure *miniflux.Enclosure
+	for _, entry := range result.Entries {
+		if len(entry.Enclosures) > 0 {
+			expectedEnclosure = entry.Enclosures[0]
+			break
+		}
+	}
+
+	if expectedEnclosure == nil {
+		t.Skip(`Skipping test, missing enclosure in feed.`)
+	}
+
+	enclosure, err := regularUserClient.Enclosure(expectedEnclosure.ID)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if enclosure.ID != expectedEnclosure.ID {
+		t.Fatalf(`Invalid enclosureID, got %d while expecting %d`, enclosure.ID, expectedEnclosure.ID)
+	}
+
+	if _, err = regularUserClient.Enclosure(99999); err == nil {
+		t.Fatalf(`Fetching an inexisting enclosure should raise an error`)
+	}
+}
+
 func TestGetEntryEndpoints(t *testing.T) {
 	testConfig := newIntegrationTestConfig()
 	if !testConfig.isConfigured() {
@@ -2228,6 +2483,32 @@ func TestSaveEntryEndpoint(t *testing.T) {
 	}
 }
 
+func TestFetchIntegrationsStatusEndpoint(t *testing.T) {
+	testConfig := newIntegrationTestConfig()
+	if !testConfig.isConfigured() {
+		t.Skip(skipIntegrationTestsMessage)
+	}
+
+	adminClient := miniflux.NewClient(testConfig.testBaseURL, testConfig.testAdminUsername, testConfig.testAdminPassword)
+
+	regularTestUser, err := adminClient.CreateUser(testConfig.genRandomUsername(), testConfig.testRegularPassword, false)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer adminClient.DeleteUser(regularTestUser.ID)
+
+	regularUserClient := miniflux.NewClient(testConfig.testBaseURL, regularTestUser.Username, testConfig.testRegularPassword)
+
+	hasIntegrations, err := regularUserClient.IntegrationsStatus()
+	if err != nil {
+		t.Fatalf("Failed to fetch integrations status: %v", err)
+	}
+
+	if hasIntegrations {
+		t.Fatalf("New user should not have integrations configured")
+	}
+}
+
 func TestFetchContentEndpoint(t *testing.T) {
 	testConfig := newIntegrationTestConfig()
 	if !testConfig.isConfigured() {

internal/api/enclosure.go

@@ -0,0 +1,79 @@
+// SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package api // import "miniflux.app/v2/internal/api"
+
+import (
+	json_parser "encoding/json"
+	"net/http"
+
+	"miniflux.app/v2/internal/http/request"
+	"miniflux.app/v2/internal/http/response/json"
+	"miniflux.app/v2/internal/model"
+	"miniflux.app/v2/internal/validator"
+)
+
+func (h *handler) getEnclosureByID(w http.ResponseWriter, r *http.Request) {
+	enclosureID := request.RouteInt64Param(r, "enclosureID")
+
+	enclosure, err := h.store.GetEnclosure(enclosureID)
+	if err != nil {
+		json.ServerError(w, r, err)
+		return
+	}
+
+	if enclosure == nil {
+		json.NotFound(w, r)
+		return
+	}
+
+	userID := request.UserID(r)
+	if enclosure.UserID != userID {
+		json.NotFound(w, r)
+		return
+	}
+
+	enclosure.ProxifyEnclosureURL(h.router)
+
+	json.OK(w, r, enclosure)
+}
+
+func (h *handler) updateEnclosureByID(w http.ResponseWriter, r *http.Request) {
+	enclosureID := request.RouteInt64Param(r, "enclosureID")
+
+	var enclosureUpdateRequest model.EnclosureUpdateRequest
+	if err := json_parser.NewDecoder(r.Body).Decode(&enclosureUpdateRequest); err != nil {
+		json.BadRequest(w, r, err)
+		return
+	}
+
+	if err := validator.ValidateEnclosureUpdateRequest(&enclosureUpdateRequest); err != nil {
+		json.BadRequest(w, r, err)
+		return
+	}
+
+	enclosure, err := h.store.GetEnclosure(enclosureID)
+	if err != nil {
+		json.ServerError(w, r, err)
+		return
+	}
+
+	if enclosure == nil {
+		json.NotFound(w, r)
+		return
+	}
+
+	userID := request.UserID(r)
+	if enclosure.UserID != userID {
+		json.NotFound(w, r)
+		return
+	}
+
+	enclosure.MediaProgression = enclosureUpdateRequest.MediaProgression
+	if err := h.store.UpdateEnclosure(enclosure); err != nil {
+		json.ServerError(w, r, err)
+		return
+	}
+
+	json.NoContent(w, r)
+}

internal/api/entry.go

@@ -8,10 +8,8 @@ import (
 	"errors"
 	"net/http"
 	"strconv"
-	"strings"
 	"time"
 
-	"miniflux.app/v2/internal/config"
 	"miniflux.app/v2/internal/http/request"
 	"miniflux.app/v2/internal/http/response/json"
 	"miniflux.app/v2/internal/integration"
@@ -20,7 +18,6 @@ import (
 	"miniflux.app/v2/internal/reader/processor"
 	"miniflux.app/v2/internal/reader/readingtime"
 	"miniflux.app/v2/internal/storage"
-	"miniflux.app/v2/internal/urllib"
 	"miniflux.app/v2/internal/validator"
 )
 
@@ -36,19 +33,9 @@ func (h *handler) getEntryFromBuilder(w http.ResponseWriter, r *http.Request, b
 		return
 	}
 
-	entry.Content = mediaproxy.RewriteDocumentWithAbsoluteProxyURL(h.router, r.Host, entry.Content)
-	proxyOption := config.Opts.MediaProxyMode()
+	entry.Content = mediaproxy.RewriteDocumentWithAbsoluteProxyURL(h.router, entry.Content)
 
-	for i := range entry.Enclosures {
-		if proxyOption == "all" || proxyOption != "none" && !urllib.IsHTTPS(entry.Enclosures[i].URL) {
-			for _, mediaType := range config.Opts.MediaProxyResourceTypes() {
-				if strings.HasPrefix(entry.Enclosures[i].MimeType, mediaType+"/") {
-					entry.Enclosures[i].URL = mediaproxy.ProxifyAbsoluteURL(h.router, r.Host, entry.Enclosures[i].URL)
-					break
-				}
-			}
-		}
-	}
+	entry.Enclosures.ProxifyEnclosureURL(h.router)
 
 	json.OK(w, r, entry)
 }
@@ -149,6 +136,15 @@ func (h *handler) findEntries(w http.ResponseWriter, r *http.Request, feedID int
 	builder.WithLimit(limit)
 	builder.WithTags(tags)
 	builder.WithEnclosures()
+
+	if request.HasQueryParam(r, "globally_visible") {
+		globallyVisible := request.QueryBoolParam(r, "globally_visible", true)
+
+		if globallyVisible {
+			builder.WithGloballyVisible()
+		}
+	}
+
 	configureFilters(builder, r)
 
 	entries, err := builder.GetEntries()
@@ -164,7 +160,7 @@ func (h *handler) findEntries(w http.ResponseWriter, r *http.Request, feedID int
 	}
 
 	for i := range entries {
-		entries[i].Content = mediaproxy.RewriteDocumentWithAbsoluteProxyURL(h.router, r.Host, entries[i].Content)
+		entries[i].Content = mediaproxy.RewriteDocumentWithAbsoluteProxyURL(h.router, entries[i].Content)
 	}
 
 	json.OK(w, r, &entriesResponse{Total: count, Entries: entries})

internal/api/feed.go

@@ -121,6 +121,7 @@ func (h *handler) updateFeed(w http.ResponseWriter, r *http.Request) {
 	}
 
 	feedModificationRequest.Patch(originalFeed)
+	originalFeed.ResetErrorCounter()
 	if err := h.store.UpdateFeed(originalFeed); err != nil {
 		json.ServerError(w, r, err)
 		return

internal/api/icon.go

@@ -13,7 +13,7 @@ import (
 func (h *handler) getIconByFeedID(w http.ResponseWriter, r *http.Request) {
 	feedID := request.RouteInt64Param(r, "feedID")
 
-	if !h.store.HasIcon(feedID) {
+	if !h.store.HasFeedIcon(feedID) {
 		json.NotFound(w, r)
 		return
 	}

internal/api/user.go

@@ -7,6 +7,8 @@ import (
 	json_parser "encoding/json"
 	"errors"
 	"net/http"
+	"regexp"
+	"strings"
 
 	"miniflux.app/v2/internal/http/request"
 	"miniflux.app/v2/internal/http/response/json"
@@ -82,6 +84,18 @@ func (h *handler) updateUser(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
+	cleanEnd := regexp.MustCompile(`(?m)\r\n\s*$`)
+	if userModificationRequest.BlockFilterEntryRules != nil {
+		*userModificationRequest.BlockFilterEntryRules = cleanEnd.ReplaceAllLiteralString(*userModificationRequest.BlockFilterEntryRules, "")
+		// Clean carriage returns for Windows environments
+		*userModificationRequest.BlockFilterEntryRules = strings.ReplaceAll(*userModificationRequest.BlockFilterEntryRules, "\r\n", "\n")
+	}
+	if userModificationRequest.KeepFilterEntryRules != nil {
+		*userModificationRequest.KeepFilterEntryRules = cleanEnd.ReplaceAllLiteralString(*userModificationRequest.KeepFilterEntryRules, "")
+		// Clean carriage returns for Windows environments
+		*userModificationRequest.KeepFilterEntryRules = strings.ReplaceAll(*userModificationRequest.KeepFilterEntryRules, "\r\n", "\n")
+	}
+
 	if validationErr := validator.ValidateUserModification(h.store, originalUser.ID, &userModificationRequest); validationErr != nil {
 		json.BadRequest(w, r, validationErr.Error())
 		return
@@ -116,6 +130,25 @@ func (h *handler) markUserAsRead(w http.ResponseWriter, r *http.Request) {
 	json.NoContent(w, r)
 }
 
+func (h *handler) getIntegrationsStatus(w http.ResponseWriter, r *http.Request) {
+	userID := request.UserID(r)
+
+	if _, err := h.store.UserByID(userID); err != nil {
+		json.NotFound(w, r)
+		return
+	}
+
+	hasIntegrations := h.store.HasSaveEntry(userID)
+
+	response := struct {
+		HasIntegrations bool `json:"has_integrations"`
+	}{
+		HasIntegrations: hasIntegrations,
+	}
+
+	json.OK(w, r, response)
+}
+
 func (h *handler) users(w http.ResponseWriter, r *http.Request) {
 	if !request.IsAdminUser(r) {
 		json.Forbidden(w, r)

internal/cli/cli.go

@@ -4,6 +4,7 @@
 package cli // import "miniflux.app/v2/internal/cli"
 
 import (
+	"errors"
 	"flag"
 	"fmt"
 	"io"
@@ -12,7 +13,6 @@ import (
 
 	"miniflux.app/v2/internal/config"
 	"miniflux.app/v2/internal/database"
-	"miniflux.app/v2/internal/locale"
 	"miniflux.app/v2/internal/storage"
 	"miniflux.app/v2/internal/ui/static"
 	"miniflux.app/v2/internal/version"
@@ -88,6 +88,23 @@ func Parse() {
 		printErrorAndExit(err)
 	}
 
+	if oauth2Provider := config.Opts.OAuth2Provider(); oauth2Provider != "" {
+		if oauth2Provider != "oidc" && oauth2Provider != "google" {
+			printErrorAndExit(fmt.Errorf(`unsupported OAuth2 provider: %q (Possible values are "google" or "oidc")`, oauth2Provider))
+		}
+	}
+
+	if config.Opts.DisableLocalAuth() {
+		switch {
+		case config.Opts.OAuth2Provider() == "" && config.Opts.AuthProxyHeader() == "":
+			printErrorAndExit(errors.New("DISABLE_LOCAL_AUTH is enabled but neither OAUTH2_PROVIDER nor AUTH_PROXY_HEADER is not set. Please enable at least one authentication source"))
+		case config.Opts.OAuth2Provider() != "" && !config.Opts.IsOAuth2UserCreationAllowed():
+			printErrorAndExit(errors.New("DISABLE_LOCAL_AUTH is enabled and an OAUTH2_PROVIDER is configured, but OAUTH2_USER_CREATION is not enabled"))
+		case config.Opts.AuthProxyHeader() != "" && !config.Opts.IsAuthProxyUserCreationAllowed():
+			printErrorAndExit(errors.New("DISABLE_LOCAL_AUTH is enabled and an AUTH_PROXY_HEADER is configured, but AUTH_PROXY_USER_CREATION is not enabled"))
+		}
+	}
+
 	if flagConfigDump {
 		fmt.Print(config.Opts)
 		return
@@ -135,10 +152,6 @@ func Parse() {
 		slog.Info("The default value for DATABASE_URL is used")
 	}
 
-	if err := locale.LoadCatalogMessages(); err != nil {
-		printErrorAndExit(fmt.Errorf("unable to load translations: %v", err))
-	}
-
 	if err := static.CalculateBinaryFileChecksums(); err != nil {
 		printErrorAndExit(fmt.Errorf("unable to calculate binary file checksums: %v", err))
 	}

internal/config/config_test.go

@@ -259,6 +259,29 @@ func TestCustomBaseURLWithTrailingSlash(t *testing.T) {
 	}
 }
 
+func TestCustomBaseURLWithCustomPort(t *testing.T) {
+	os.Clearenv()
+	os.Setenv("BASE_URL", "http://example.org:88/folder/")
+
+	parser := NewParser()
+	opts, err := parser.ParseEnvironmentVariables()
+	if err != nil {
+		t.Fatalf(`Parsing failure: %v`, err)
+	}
+
+	if opts.BaseURL() != "http://example.org:88/folder" {
+		t.Fatalf(`Unexpected base URL, got "%s"`, opts.BaseURL())
+	}
+
+	if opts.RootURL() != "http://example.org:88" {
+		t.Fatalf(`Unexpected root URL, got "%s"`, opts.RootURL())
+	}
+
+	if opts.BasePath() != "/folder" {
+		t.Fatalf(`Unexpected base path, got "%s"`, opts.BasePath())
+	}
+}
+
 func TestBaseURLWithoutScheme(t *testing.T) {
 	os.Clearenv()
 	os.Setenv("BASE_URL", "example.org/folder/")
@@ -2021,6 +2044,42 @@ func TestAuthProxyUserCreationAdmin(t *testing.T) {
 	}
 }
 
+func TestFetchBilibiliWatchTime(t *testing.T) {
+	os.Clearenv()
+	os.Setenv("FETCH_BILIBILI_WATCH_TIME", "1")
+
+	parser := NewParser()
+	opts, err := parser.ParseEnvironmentVariables()
+	if err != nil {
+		t.Fatalf(`Parsing failure: %v`, err)
+	}
+
+	expected := true
+	result := opts.FetchBilibiliWatchTime()
+
+	if result != expected {
+		t.Fatalf(`Unexpected FETCH_BILIBILI_WATCH_TIME value, got %v instead of %v`, result, expected)
+	}
+}
+
+func TestFetchNebulaWatchTime(t *testing.T) {
+	os.Clearenv()
+	os.Setenv("FETCH_NEBULA_WATCH_TIME", "1")
+
+	parser := NewParser()
+	opts, err := parser.ParseEnvironmentVariables()
+	if err != nil {
+		t.Fatalf(`Parsing failure: %v`, err)
+	}
+
+	expected := true
+	result := opts.FetchNebulaWatchTime()
+
+	if result != expected {
+		t.Fatalf(`Unexpected FETCH_NEBULA_WATCH_TIME value, got %v instead of %v`, result, expected)
+	}
+}
+
 func TestFetchOdyseeWatchTime(t *testing.T) {
 	os.Clearenv()
 	os.Setenv("FETCH_ODYSEE_WATCH_TIME", "1")
@@ -2057,6 +2116,24 @@ func TestFetchYouTubeWatchTime(t *testing.T) {
 	}
 }
 
+func TestYouTubeApiKey(t *testing.T) {
+	os.Clearenv()
+	os.Setenv("YOUTUBE_API_KEY", "AAAAAAAAAAAAAaaaaaaaaaaaaa0000000000000")
+
+	parser := NewParser()
+	opts, err := parser.ParseEnvironmentVariables()
+	if err != nil {
+		t.Fatalf(`Parsing failure: %v`, err)
+	}
+
+	expected := "AAAAAAAAAAAAAaaaaaaaaaaaaa0000000000000"
+	result := opts.YouTubeApiKey()
+
+	if result != expected {
+		t.Fatalf(`Unexpected YOUTUBE_API_KEY value, got %v instead of %v`, result, expected)
+	}
+}
+
 func TestYouTubeEmbedUrlOverride(t *testing.T) {
 	os.Clearenv()
 	os.Setenv("YOUTUBE_EMBED_URL_OVERRIDE", "https://invidious.custom/embed/")

internal/config/options.go

@@ -56,8 +56,11 @@ const (
 	defaultMediaResourceTypes                 = "image"
 	defaultMediaProxyURL                      = ""
 	defaultFilterEntryMaxAgeDays              = 0
+	defaultFetchBilibiliWatchTime             = false
+	defaultFetchNebulaWatchTime               = false
 	defaultFetchOdyseeWatchTime               = false
 	defaultFetchYouTubeWatchTime              = false
+	defaultYouTubeApiKey                      = ""
 	defaultYouTubeEmbedUrlOverride            = "https://www.youtube-nocookie.com/embed/"
 	defaultCreateAdmin                        = false
 	defaultAdminUsername                      = ""
@@ -67,7 +70,9 @@ const (
 	defaultOAuth2ClientSecret                 = ""
 	defaultOAuth2RedirectURL                  = ""
 	defaultOAuth2OidcDiscoveryEndpoint        = ""
+	defaultOauth2OidcProviderName             = "OpenID Connect"
 	defaultOAuth2Provider                     = ""
+	defaultDisableLocalAuth                   = false
 	defaultPocketConsumerKey                  = ""
 	defaultHTTPClientTimeout                  = 20
 	defaultHTTPClientMaxBodySize              = 15
@@ -140,16 +145,21 @@ type Options struct {
 	mediaProxyMode                     string
 	mediaProxyResourceTypes            []string
 	mediaProxyCustomURL                string
+	fetchBilibiliWatchTime             bool
+	fetchNebulaWatchTime               bool
 	fetchOdyseeWatchTime               bool
 	fetchYouTubeWatchTime              bool
 	filterEntryMaxAgeDays              int
+	youTubeApiKey                      string
 	youTubeEmbedUrlOverride            string
 	oauth2UserCreationAllowed          bool
 	oauth2ClientID                     string
 	oauth2ClientSecret                 string
 	oauth2RedirectURL                  string
 	oidcDiscoveryEndpoint              string
+	oidcProviderName                   string
 	oauth2Provider                     string
+	disableLocalAuth                   bool
 	pocketConsumerKey                  string
 	httpClientTimeout                  int
 	httpClientMaxBodySize              int64
@@ -216,15 +226,20 @@ func NewOptions() *Options {
 		mediaProxyResourceTypes:            []string{defaultMediaResourceTypes},
 		mediaProxyCustomURL:                defaultMediaProxyURL,
 		filterEntryMaxAgeDays:              defaultFilterEntryMaxAgeDays,
+		fetchBilibiliWatchTime:             defaultFetchBilibiliWatchTime,
+		fetchNebulaWatchTime:               defaultFetchNebulaWatchTime,
 		fetchOdyseeWatchTime:               defaultFetchOdyseeWatchTime,
 		fetchYouTubeWatchTime:              defaultFetchYouTubeWatchTime,
+		youTubeApiKey:                      defaultYouTubeApiKey,
 		youTubeEmbedUrlOverride:            defaultYouTubeEmbedUrlOverride,
 		oauth2UserCreationAllowed:          defaultOAuth2UserCreation,
 		oauth2ClientID:                     defaultOAuth2ClientID,
 		oauth2ClientSecret:                 defaultOAuth2ClientSecret,
 		oauth2RedirectURL:                  defaultOAuth2RedirectURL,
 		oidcDiscoveryEndpoint:              defaultOAuth2OidcDiscoveryEndpoint,
+		oidcProviderName:                   defaultOauth2OidcProviderName,
 		oauth2Provider:                     defaultOAuth2Provider,
+		disableLocalAuth:                   defaultDisableLocalAuth,
 		pocketConsumerKey:                  defaultPocketConsumerKey,
 		httpClientTimeout:                  defaultHTTPClientTimeout,
 		httpClientMaxBodySize:              defaultHTTPClientMaxBodySize * 1024 * 1024,
@@ -445,11 +460,21 @@ func (o *Options) OIDCDiscoveryEndpoint() string {
 	return o.oidcDiscoveryEndpoint
 }
 
+// OIDCProviderName returns the OAuth2 OIDC provider's display name
+func (o *Options) OIDCProviderName() string {
+	return o.oidcProviderName
+}
+
 // OAuth2Provider returns the name of the OAuth2 provider configured.
 func (o *Options) OAuth2Provider() string {
 	return o.oauth2Provider
 }
 
+// DisableLocalAUth returns true if the local user database should not be used to authenticate users
+func (o *Options) DisableLocalAuth() bool {
+	return o.disableLocalAuth
+}
+
 // HasHSTS returns true if HTTP Strict Transport Security is enabled.
 func (o *Options) HasHSTS() bool {
 	return o.hsts
@@ -481,17 +506,34 @@ func (o *Options) FetchYouTubeWatchTime() bool {
 	return o.fetchYouTubeWatchTime
 }
 
+// YouTubeApiKey returns the YouTube API key if defined.
+func (o *Options) YouTubeApiKey() string {
+	return o.youTubeApiKey
+}
+
 // YouTubeEmbedUrlOverride returns YouTube URL which will be used for embeds
 func (o *Options) YouTubeEmbedUrlOverride() string {
 	return o.youTubeEmbedUrlOverride
 }
 
+// FetchNebulaWatchTime returns true if the Nebula video duration
+// should be fetched and used as a reading time.
+func (o *Options) FetchNebulaWatchTime() bool {
+	return o.fetchNebulaWatchTime
+}
+
 // FetchOdyseeWatchTime returns true if the Odysee video duration
 // should be fetched and used as a reading time.
 func (o *Options) FetchOdyseeWatchTime() bool {
 	return o.fetchOdyseeWatchTime
 }
 
+// FetchBilibiliWatchTime returns true if the Bilibili video duration
+// should be fetched and used as a reading time.
+func (o *Options) FetchBilibiliWatchTime() bool {
+	return o.fetchBilibiliWatchTime
+}
+
 // MediaProxyMode returns "none" to never proxy, "http-only" to proxy non-HTTPS, "all" to always proxy.
 func (o *Options) MediaProxyMode() string {
 	return o.mediaProxyMode
@@ -647,7 +689,9 @@ func (o *Options) SortedOptions(redactSecret bool) []*Option {
 		"DISABLE_SCHEDULER_SERVICE":              !o.schedulerService,
 		"FILTER_ENTRY_MAX_AGE_DAYS":              o.filterEntryMaxAgeDays,
 		"FETCH_YOUTUBE_WATCH_TIME":               o.fetchYouTubeWatchTime,
+		"FETCH_NEBULA_WATCH_TIME":                o.fetchNebulaWatchTime,
 		"FETCH_ODYSEE_WATCH_TIME":                o.fetchOdyseeWatchTime,
+		"FETCH_BILIBILI_WATCH_TIME":              o.fetchBilibiliWatchTime,
 		"HTTPS":                                  o.HTTPS,
 		"HTTP_CLIENT_MAX_BODY_SIZE":              o.httpClientMaxBodySize,
 		"HTTP_CLIENT_PROXY":                      o.httpClientProxy,
@@ -672,9 +716,11 @@ func (o *Options) SortedOptions(redactSecret bool) []*Option {
 		"OAUTH2_CLIENT_ID":                       o.oauth2ClientID,
 		"OAUTH2_CLIENT_SECRET":                   redactSecretValue(o.oauth2ClientSecret, redactSecret),
 		"OAUTH2_OIDC_DISCOVERY_ENDPOINT":         o.oidcDiscoveryEndpoint,
+		"OAUTH2_OIDC_PROVIDER_NAME":              o.oidcProviderName,
 		"OAUTH2_PROVIDER":                        o.oauth2Provider,
 		"OAUTH2_REDIRECT_URL":                    o.oauth2RedirectURL,
 		"OAUTH2_USER_CREATION":                   o.oauth2UserCreationAllowed,
+		"DISABLE_LOCAL_AUTH":                     o.disableLocalAuth,
 		"POCKET_CONSUMER_KEY":                    redactSecretValue(o.pocketConsumerKey, redactSecret),
 		"POLLING_FREQUENCY":                      o.pollingFrequency,
 		"FORCE_REFRESH_INTERVAL":                 o.forceRefreshInterval,
@@ -695,6 +741,7 @@ func (o *Options) SortedOptions(redactSecret bool) []*Option {
 		"SERVER_TIMING_HEADER":                   o.serverTimingHeader,
 		"WATCHDOG":                               o.watchdog,
 		"WORKER_POOL_SIZE":                       o.workerPoolSize,
+		"YOUTUBE_API_KEY":                        redactSecretValue(o.youTubeApiKey, redactSecret),
 		"YOUTUBE_EMBED_URL_OVERRIDE":             o.youTubeEmbedUrlOverride,
 		"WEBAUTHN":                               o.webAuthn,
 	}

internal/config/parser.go

@@ -225,8 +225,12 @@ func (p *Parser) parseLines(lines []string) (err error) {
 			p.opts.oauth2RedirectURL = parseString(value, defaultOAuth2RedirectURL)
 		case "OAUTH2_OIDC_DISCOVERY_ENDPOINT":
 			p.opts.oidcDiscoveryEndpoint = parseString(value, defaultOAuth2OidcDiscoveryEndpoint)
+		case "OAUTH2_OIDC_PROVIDER_NAME":
+			p.opts.oidcProviderName = parseString(value, defaultOauth2OidcProviderName)
 		case "OAUTH2_PROVIDER":
 			p.opts.oauth2Provider = parseString(value, defaultOAuth2Provider)
+		case "DISABLE_LOCAL_AUTH":
+			p.opts.disableLocalAuth = parseBool(value, defaultDisableLocalAuth)
 		case "HTTP_CLIENT_TIMEOUT":
 			p.opts.httpClientTimeout = parseInt(value, defaultHTTPClientTimeout)
 		case "HTTP_CLIENT_MAX_BODY_SIZE":
@@ -259,10 +263,16 @@ func (p *Parser) parseLines(lines []string) (err error) {
 			p.opts.metricsPassword = parseString(value, defaultMetricsPassword)
 		case "METRICS_PASSWORD_FILE":
 			p.opts.metricsPassword = readSecretFile(value, defaultMetricsPassword)
+		case "FETCH_BILIBILI_WATCH_TIME":
+			p.opts.fetchBilibiliWatchTime = parseBool(value, defaultFetchBilibiliWatchTime)
+		case "FETCH_NEBULA_WATCH_TIME":
+			p.opts.fetchNebulaWatchTime = parseBool(value, defaultFetchNebulaWatchTime)
 		case "FETCH_ODYSEE_WATCH_TIME":
 			p.opts.fetchOdyseeWatchTime = parseBool(value, defaultFetchOdyseeWatchTime)
 		case "FETCH_YOUTUBE_WATCH_TIME":
 			p.opts.fetchYouTubeWatchTime = parseBool(value, defaultFetchYouTubeWatchTime)
+		case "YOUTUBE_API_KEY":
+			p.opts.youTubeApiKey = parseString(value, defaultYouTubeApiKey)
 		case "YOUTUBE_EMBED_URL_OVERRIDE":
 			p.opts.youTubeEmbedUrlOverride = parseString(value, defaultYouTubeEmbedUrlOverride)
 		case "WATCHDOG":

internal/database/database.go

@@ -7,34 +7,18 @@ import (
 	"database/sql"
 	"fmt"
 	"log/slog"
-	"time"
-
-	// Postgresql driver import
-	_ "github.com/lib/pq"
 )
 
-// NewConnectionPool configures the database connection pool.
-func NewConnectionPool(dsn string, minConnections, maxConnections int, connectionLifetime time.Duration) (*sql.DB, error) {
-	db, err := sql.Open("postgres", dsn)
-	if err != nil {
-		return nil, err
-	}
-
-	db.SetMaxOpenConns(maxConnections)
-	db.SetMaxIdleConns(minConnections)
-	db.SetConnMaxLifetime(connectionLifetime)
-
-	return db, nil
-}
-
 // Migrate executes database migrations.
 func Migrate(db *sql.DB) error {
 	var currentVersion int
 	db.QueryRow(`SELECT version FROM schema_version`).Scan(&currentVersion)
 
-	slog.Debug("Running database migrations",
+	driver := getDriverStr()
+	slog.Info("Running database migrations",
 		slog.Int("current_version", currentVersion),
 		slog.Int("latest_version", schemaVersion),
+		slog.String("driver", driver),
 	)
 
 	for version := currentVersion; version < schemaVersion; version++ {
@@ -45,7 +29,7 @@ func Migrate(db *sql.DB) error {
 			return fmt.Errorf("[Migration v%d] %v", newVersion, err)
 		}
 
-		if err := migrations[version](tx); err != nil {
+		if err := migrations[version](tx, driver); err != nil {
 			tx.Rollback()
 			return fmt.Errorf("[Migration v%d] %v", newVersion, err)
 		}

internal/database/migrations.go

@@ -10,8 +10,8 @@ import (
 var schemaVersion = len(migrations)
 
 // Order is important. Add new migrations at the end of the list.
-var migrations = []func(tx *sql.Tx) error{
-	func(tx *sql.Tx) (err error) {
+var migrations = []func(tx *sql.Tx, driver string) error{
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			CREATE TABLE schema_version (
 				version text not null
@@ -120,16 +120,19 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
-		sql := `
+	func(tx *sql.Tx, driver string) (err error) {
+		if driver == "postgresql" {
+			sql := `
 			CREATE EXTENSION IF NOT EXISTS hstore;
 			ALTER TABLE users ADD COLUMN extra hstore;
 			CREATE INDEX users_extra_idx ON users using gin(extra);
-		`
-		_, err = tx.Exec(sql)
-		return err
+			`
+			_, err = tx.Exec(sql)
+			return err
+		}
+		return nil
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			CREATE TABLE tokens (
 				id text not null,
@@ -141,7 +144,7 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			CREATE TYPE entry_sorting_direction AS enum('asc', 'desc');
 			ALTER TABLE users ADD COLUMN entry_direction entry_sorting_direction default 'asc';
@@ -149,7 +152,7 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			CREATE TABLE integrations (
 				user_id int not null,
@@ -170,27 +173,27 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `ALTER TABLE feeds ADD COLUMN scraper_rules text default ''`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `ALTER TABLE feeds ADD COLUMN rewrite_rules text default ''`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `ALTER TABLE feeds ADD COLUMN crawler boolean default 'f'`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `ALTER TABLE sessions rename to user_sessions`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			DROP TABLE tokens;
 
@@ -204,7 +207,7 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE integrations ADD COLUMN wallabag_enabled bool default 'f';
 			ALTER TABLE integrations ADD COLUMN wallabag_url text default '';
@@ -216,12 +219,12 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `ALTER TABLE entries ADD COLUMN starred bool default 'f'`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			CREATE INDEX entries_user_status_idx ON entries(user_id, status);
 			CREATE INDEX feeds_user_category_idx ON feeds(user_id, category_id);
@@ -229,7 +232,7 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE integrations ADD COLUMN nunux_keeper_enabled bool default 'f';
 			ALTER TABLE integrations ADD COLUMN nunux_keeper_url text default '';
@@ -238,17 +241,17 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `ALTER TABLE enclosures ALTER COLUMN size SET DATA TYPE bigint`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `ALTER TABLE entries ADD COLUMN comments_url text default ''`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE integrations ADD COLUMN pocket_enabled bool default 'f';
 			ALTER TABLE integrations ADD COLUMN pocket_access_token text default '';
@@ -257,14 +260,14 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE user_sessions ALTER COLUMN ip SET DATA TYPE inet using ip::inet;
 		`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE feeds ADD COLUMN username text default '';
 			ALTER TABLE feeds ADD COLUMN password text default '';
@@ -272,7 +275,7 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE entries ADD COLUMN document_vectors tsvector;
 			UPDATE entries SET document_vectors = to_tsvector(substring(title || ' ' || coalesce(content, '') for 1000000));
@@ -281,12 +284,12 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `ALTER TABLE feeds ADD COLUMN user_agent text default ''`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			UPDATE
 				entries
@@ -296,17 +299,17 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `ALTER TABLE users ADD COLUMN keyboard_shortcuts boolean default 't'`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `ALTER TABLE feeds ADD COLUMN disabled boolean default 'f';`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE users ALTER COLUMN theme SET DEFAULT 'light_serif';
 			UPDATE users SET theme='light_serif' WHERE theme='default';
@@ -316,7 +319,7 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE entries ADD COLUMN changed_at timestamp with time zone;
 			UPDATE entries SET changed_at = published_at;
@@ -325,7 +328,7 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			CREATE TABLE api_keys (
 				id serial not null,
@@ -341,7 +344,7 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE entries ADD COLUMN share_code text not null default '';
 			CREATE UNIQUE INDEX entries_share_code_idx ON entries USING btree(share_code) WHERE share_code <> '';
@@ -349,12 +352,12 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `CREATE INDEX enclosures_user_entry_url_idx ON enclosures(user_id, entry_id, md5(url))`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE feeds ADD COLUMN next_check_at timestamp with time zone default now();
 			CREATE INDEX entries_user_feed_idx ON entries (user_id, feed_id);
@@ -362,52 +365,52 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `ALTER TABLE feeds ADD COLUMN ignore_http_cache bool default false`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `ALTER TABLE users ADD COLUMN entries_per_page int default 100`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `ALTER TABLE users ADD COLUMN show_reading_time boolean default 't'`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `CREATE INDEX entries_id_user_status_idx ON entries USING btree (id, user_id, status)`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `ALTER TABLE feeds ADD COLUMN fetch_via_proxy bool default false`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `CREATE INDEX entries_feed_id_status_hash_idx ON entries USING btree (feed_id, status, hash)`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `CREATE INDEX entries_user_id_status_starred_idx ON entries (user_id, status, starred)`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `ALTER TABLE users ADD COLUMN entry_swipe boolean default 't'`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `ALTER TABLE integrations DROP COLUMN fever_password`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE feeds
 				ADD COLUMN blocklist_rules text not null default '',
@@ -416,12 +419,12 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `ALTER TABLE entries ADD COLUMN reading_time int not null default 0`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE entries ADD COLUMN created_at timestamp with time zone not null default now();
 			UPDATE entries SET created_at = published_at;
@@ -429,7 +432,7 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, driver string) (err error) {
 		_, err = tx.Exec(`
 			ALTER TABLE users
 				ADD column stylesheet text not null default '',
@@ -440,63 +443,69 @@ var migrations = []func(tx *sql.Tx) error{
 			return err
 		}
 
-		_, err = tx.Exec(`
-			DECLARE my_cursor CURSOR FOR
-			SELECT
-				id,
-				COALESCE(extra->'custom_css', '') as custom_css,
-				COALESCE(extra->'google_id', '') as google_id,
-				COALESCE(extra->'oidc_id', '') as oidc_id
-			FROM users
-			FOR UPDATE
-		`)
-		if err != nil {
-			return err
-		}
-		defer tx.Exec("CLOSE my_cursor")
-
-		for {
-			var (
-				userID           int64
-				customStylesheet string
-				googleID         string
-				oidcID           string
-			)
-
-			if err := tx.QueryRow(`FETCH NEXT FROM my_cursor`).Scan(&userID, &customStylesheet, &googleID, &oidcID); err != nil {
-				if err == sql.ErrNoRows {
-					break
-				}
-				return err
-			}
-
-			_, err := tx.Exec(
-				`UPDATE
-					users
-				SET
-					stylesheet=$2,
-					google_id=$3,
-					openid_connect_id=$4
-				WHERE
-					id=$1
-				`,
-				userID, customStylesheet, googleID, oidcID)
+		if driver == "postgresql" {
+			_, err = tx.Exec(`
+				DECLARE my_cursor CURSOR FOR
+				SELECT
+					id,
+					COALESCE(extra->'custom_css', '') as custom_css,
+					COALESCE(extra->'google_id', '') as google_id,
+					COALESCE(extra->'oidc_id', '') as oidc_id
+				FROM users
+				FOR UPDATE
+			`)
 			if err != nil {
 				return err
 			}
+			defer tx.Exec("CLOSE my_cursor")
+
+			for {
+				var (
+					userID           int64
+					customStylesheet string
+					googleID         string
+					oidcID           string
+				)
+
+				if err := tx.QueryRow(`FETCH NEXT FROM my_cursor`).Scan(&userID, &customStylesheet, &googleID, &oidcID); err != nil {
+					if err == sql.ErrNoRows {
+						break
+					}
+					return err
+				}
+
+				_, err := tx.Exec(
+					`UPDATE
+						users
+					SET
+						stylesheet=$2,
+						google_id=$3,
+						openid_connect_id=$4
+					WHERE
+						id=$1
+					`,
+					userID, customStylesheet, googleID, oidcID)
+				if err != nil {
+					return err
+				}
+			}
 		}
 
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, driver string) (err error) {
+		if driver == "postgresql" {
+			if _, err = tx.Exec(`ALTER TABLE users DROP COLUMN extra;`); err != nil {
+				return err
+			}
+		}
 		_, err = tx.Exec(`
-			ALTER TABLE users DROP COLUMN extra;
 			CREATE UNIQUE INDEX users_google_id_idx ON users(google_id) WHERE google_id <> '';
 			CREATE UNIQUE INDEX users_openid_connect_id_idx ON users(openid_connect_id) WHERE openid_connect_id <> '';
 		`)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		_, err = tx.Exec(`
 			CREATE INDEX entries_feed_url_idx ON entries(feed_id, url);
 			CREATE INDEX entries_user_status_feed_idx ON entries(user_id, status, feed_id);
@@ -504,7 +513,7 @@ var migrations = []func(tx *sql.Tx) error{
 		`)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		_, err = tx.Exec(`
 			CREATE TABLE acme_cache (
 				key varchar(400) not null primary key,
@@ -514,13 +523,13 @@ var migrations = []func(tx *sql.Tx) error{
 		`)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		_, err = tx.Exec(`
 			ALTER TABLE feeds ADD COLUMN allow_self_signed_certificates boolean not null default false
 		`)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			CREATE TYPE webapp_display_mode AS enum('fullscreen', 'standalone', 'minimal-ui', 'browser');
 			ALTER TABLE users ADD COLUMN display_mode webapp_display_mode default 'standalone';
@@ -528,24 +537,24 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `ALTER TABLE feeds ADD COLUMN cookie text default ''`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		_, err = tx.Exec(`
 			ALTER TABLE categories ADD COLUMN hide_globally boolean not null default false
 		`)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		_, err = tx.Exec(`
 			ALTER TABLE feeds ADD COLUMN hide_globally boolean not null default false
 		`)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE integrations ADD COLUMN telegram_bot_enabled bool default 'f';
 			ALTER TABLE integrations ADD COLUMN telegram_bot_token text default '';
@@ -554,7 +563,7 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			CREATE TYPE entry_sorting_order AS enum('published_at', 'created_at');
 			ALTER TABLE users ADD COLUMN entry_order entry_sorting_order default 'published_at';
@@ -562,7 +571,7 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE integrations ADD COLUMN googlereader_enabled bool default 'f';
 			ALTER TABLE integrations ADD COLUMN googlereader_username text default '';
@@ -571,7 +580,7 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE integrations ADD COLUMN espial_enabled bool default 'f';
 			ALTER TABLE integrations ADD COLUMN espial_url text default '';
@@ -581,7 +590,7 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE integrations ADD COLUMN linkding_enabled bool default 'f';
 			ALTER TABLE integrations ADD COLUMN linkding_url text default '';
@@ -590,38 +599,38 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		_, err = tx.Exec(`
 			ALTER TABLE feeds ADD COLUMN url_rewrite_rules text not null default ''
 		`)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		_, err = tx.Exec(`
 			ALTER TABLE users ADD COLUMN default_reading_speed int default 265;
 			ALTER TABLE users ADD COLUMN cjk_reading_speed int default 500;
 		`)
 		return
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		_, err = tx.Exec(`
 			ALTER TABLE users ADD COLUMN default_home_page text default 'unread';
 		`)
 		return
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		_, err = tx.Exec(`
 			ALTER TABLE integrations ADD COLUMN wallabag_only_url bool default 'f';
 		`)
 		return
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		_, err = tx.Exec(`
 			ALTER TABLE users ADD COLUMN categories_sorting_order text not null default 'unread_count';
 		`)
 		return
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE integrations ADD COLUMN matrix_bot_enabled bool default 'f';
 			ALTER TABLE integrations ADD COLUMN matrix_bot_user text default '';
@@ -632,18 +641,18 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `ALTER TABLE users ADD COLUMN double_tap boolean default 't'`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		_, err = tx.Exec(`
 			ALTER TABLE entries ADD COLUMN tags text[] default '{}';
 		`)
 		return
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE users RENAME double_tap TO gesture_nav;
 			ALTER TABLE users ALTER COLUMN gesture_nav SET DATA TYPE text using case when gesture_nav = true then 'tap' when gesture_nav = false then 'none' end;
@@ -652,14 +661,14 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE integrations ADD COLUMN linkding_tags text default '';
 		`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE feeds ADD COLUMN no_media_player boolean default 'f';
 			ALTER TABLE enclosures ADD COLUMN media_progression int default 0;
@@ -667,14 +676,14 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE integrations ADD COLUMN linkding_mark_as_unread bool default 'f';
 		`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		// Delete duplicated rows
 		sql := `
 			DELETE FROM enclosures a USING enclosures b
@@ -702,12 +711,12 @@ var migrations = []func(tx *sql.Tx) error{
 
 		return nil
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `ALTER TABLE users ADD COLUMN mark_read_on_view boolean default 't'`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE integrations ADD COLUMN notion_enabled bool default 'f';
 			ALTER TABLE integrations ADD COLUMN notion_token text default '';
@@ -716,7 +725,7 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE integrations ADD COLUMN readwise_enabled bool default 'f';
 			ALTER TABLE integrations ADD COLUMN readwise_api_key text default '';
@@ -724,7 +733,7 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE integrations ADD COLUMN apprise_enabled bool default 'f';
 			ALTER TABLE integrations ADD COLUMN apprise_url text default '';
@@ -733,7 +742,7 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE integrations ADD COLUMN shiori_enabled bool default 'f';
 			ALTER TABLE integrations ADD COLUMN shiori_url text default '';
@@ -743,7 +752,7 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE integrations ADD COLUMN shaarli_enabled bool default 'f';
 			ALTER TABLE integrations ADD COLUMN shaarli_url text default '';
@@ -752,13 +761,13 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		_, err = tx.Exec(`
 			ALTER TABLE feeds ADD COLUMN apprise_service_urls text default '';
 		`)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE integrations ADD COLUMN webhook_enabled bool default 'f';
 			ALTER TABLE integrations ADD COLUMN webhook_url text default '';
@@ -767,7 +776,7 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE integrations ADD COLUMN telegram_bot_topic_id int;
 			ALTER TABLE integrations ADD COLUMN telegram_bot_disable_web_page_preview bool default 'f';
@@ -776,14 +785,14 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE integrations ADD COLUMN telegram_bot_disable_buttons bool default 'f';
 		`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			-- Speed up has_enclosure
 			CREATE INDEX enclosures_entry_id_idx ON enclosures(entry_id);
@@ -799,7 +808,7 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE integrations ADD COLUMN rssbridge_enabled bool default 'f';
 			ALTER TABLE integrations ADD COLUMN rssbridge_url text default '';
@@ -807,7 +816,7 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		_, err = tx.Exec(`
 			CREATE TABLE webauthn_credentials (
 				handle bytea primary key,
@@ -825,7 +834,7 @@ var migrations = []func(tx *sql.Tx) error{
 		`)
 		return
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE integrations ADD COLUMN omnivore_enabled bool default 'f';
 			ALTER TABLE integrations ADD COLUMN omnivore_api_key text default '';
@@ -834,7 +843,7 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE integrations ADD COLUMN linkace_enabled bool default 'f';
 			ALTER TABLE integrations ADD COLUMN linkace_url text default '';
@@ -846,7 +855,7 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE integrations ADD COLUMN linkwarden_enabled bool default 'f';
 			ALTER TABLE integrations ADD COLUMN linkwarden_url text default '';
@@ -855,7 +864,7 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `
 			ALTER TABLE integrations ADD COLUMN readeck_enabled bool default 'f';
 			ALTER TABLE integrations ADD COLUMN readeck_only_url bool default 'f';
@@ -866,20 +875,137 @@ var migrations = []func(tx *sql.Tx) error{
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `ALTER TABLE feeds ADD COLUMN disable_http2 bool default 'f'`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		sql := `ALTER TABLE users ADD COLUMN media_playback_rate numeric default 1;`
 		_, err = tx.Exec(sql)
 		return err
 	},
-	func(tx *sql.Tx) (err error) {
+	func(tx *sql.Tx, _ string) (err error) {
 		// the WHERE part speed-up the request a lot
 		sql := `UPDATE entries SET tags = array_remove(tags, '') WHERE '' = ANY(tags);`
 		_, err = tx.Exec(sql)
 		return err
 	},
+	func(tx *sql.Tx, _ string) (err error) {
+		// Entry URLs can exceeds btree maximum size
+		// Checking entry existence is now using entries_feed_id_status_hash_idx index
+		_, err = tx.Exec(`DROP INDEX entries_feed_url_idx`)
+		return err
+	},
+	func(tx *sql.Tx, _ string) (err error) {
+		sql := `
+			ALTER TABLE integrations ADD COLUMN raindrop_enabled bool default 'f';
+			ALTER TABLE integrations ADD COLUMN raindrop_token text default '';
+			ALTER TABLE integrations ADD COLUMN raindrop_collection_id text default '';
+			ALTER TABLE integrations ADD COLUMN raindrop_tags text default '';
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx, _ string) (err error) {
+		sql := `ALTER TABLE feeds ADD COLUMN description text default ''`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx, _ string) (err error) {
+		sql := `
+			ALTER TABLE users
+				ADD COLUMN block_filter_entry_rules text not null default '',
+				ADD COLUMN keep_filter_entry_rules text not null default ''
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx, _ string) (err error) {
+		sql := `
+			ALTER TABLE integrations ADD COLUMN betula_url text default '';
+			ALTER TABLE integrations ADD COLUMN betula_token text default '';
+			ALTER TABLE integrations ADD COLUMN betula_enabled bool default 'f';
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx, _ string) (err error) {
+		sql := `
+			ALTER TABLE integrations ADD COLUMN ntfy_enabled bool default 'f';
+			ALTER TABLE integrations ADD COLUMN ntfy_url text default '';
+			ALTER TABLE integrations ADD COLUMN ntfy_topic text default '';
+			ALTER TABLE integrations ADD COLUMN ntfy_api_token text default '';
+			ALTER TABLE integrations ADD COLUMN ntfy_username text default '';
+			ALTER TABLE integrations ADD COLUMN ntfy_password text default '';
+			ALTER TABLE integrations ADD COLUMN ntfy_icon_url text default '';
+
+			ALTER TABLE feeds ADD COLUMN ntfy_enabled bool default 'f';
+			ALTER TABLE feeds ADD COLUMN ntfy_priority int default '3';
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx, _ string) (err error) {
+		sql := `ALTER TABLE users ADD COLUMN mark_read_on_media_player_completion bool default 'f';`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx, _ string) (err error) {
+		sql := `ALTER TABLE users ADD COLUMN custom_js text not null default '';`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx, _ string) (err error) {
+		sql := `ALTER TABLE users ADD COLUMN external_font_hosts text not null default '';`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx, _ string) (err error) {
+		sql := `
+			ALTER TABLE integrations ADD COLUMN cubox_enabled bool default 'f';
+			ALTER TABLE integrations ADD COLUMN cubox_api_link text default '';
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx, _ string) (err error) {
+		sql := `
+			ALTER TABLE integrations ADD COLUMN discord_enabled bool default 'f';
+			ALTER TABLE integrations ADD COLUMN discord_webhook_link text default '';
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx, _ string) (err error) {
+		sql := `ALTER TABLE integrations ADD COLUMN ntfy_internal_links bool default 'f';`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx, _ string) (err error) {
+		sql := `
+			ALTER TABLE integrations ADD COLUMN slack_enabled bool default 'f';
+			ALTER TABLE integrations ADD COLUMN slack_webhook_link text default '';
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
+	func(tx *sql.Tx, _ string) (err error) {
+		_, err = tx.Exec(`ALTER TABLE feeds ADD COLUMN webhook_url text default '';`)
+		return err
+	},
+	func(tx *sql.Tx, _ string) (err error) {
+		sql := `
+			ALTER TABLE integrations ADD COLUMN pushover_enabled bool default 'f';
+			ALTER TABLE integrations ADD COLUMN pushover_user text default '';
+			ALTER TABLE integrations ADD COLUMN pushover_token text default '';
+			ALTER TABLE integrations ADD COLUMN pushover_device text default '';
+			ALTER TABLE integrations ADD COLUMN pushover_prefix text default '';
+
+			ALTER TABLE feeds ADD COLUMN pushover_enabled bool default 'f';
+			ALTER TABLE feeds ADD COLUMN pushover_priority int default '0';
+		`
+		_, err = tx.Exec(sql)
+		return err
+	},
 }

internal/database/postgresql.go

@@ -0,0 +1,31 @@
+//go:build !sqlite
+
+// SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package database // import "miniflux.app/v2/internal/database"
+
+import (
+	"database/sql"
+	"time"
+
+	_ "github.com/lib/pq"
+)
+
+// NewConnectionPool configures the database connection pool.
+func NewConnectionPool(dsn string, minConnections, maxConnections int, connectionLifetime time.Duration) (*sql.DB, error) {
+	db, err := sql.Open("postgres", dsn)
+	if err != nil {
+		return nil, err
+	}
+
+	db.SetMaxOpenConns(maxConnections)
+	db.SetMaxIdleConns(minConnections)
+	db.SetConnMaxLifetime(connectionLifetime)
+
+	return db, nil
+}
+
+func getDriverStr() string {
+	return "postgresql"
+}

internal/database/sqlite.go

@@ -0,0 +1,26 @@
+//go:build sqlite
+
+// SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package database // import "miniflux.app/v2/internal/database"
+
+import (
+	"database/sql"
+	"time"
+
+	_ "github.com/mattn/go-sqlite3"
+)
+
+// NewConnectionPool configures the database connection pool.
+func NewConnectionPool(dsn string, _, _ int, _ time.Duration) (*sql.DB, error) {
+	db, err := sql.Open("sqlite3", dsn)
+	if err != nil {
+		return nil, err
+	}
+	return db, nil
+}
+
+func getDriverStr() string {
+	return "sqlite3"
+}

internal/fever/handler.go

@@ -247,7 +247,6 @@ func (h *handler) handleItems(w http.ResponseWriter, r *http.Request) {
 	builder := h.store.NewEntryQueryBuilder(userID)
 	builder.WithoutStatus(model.EntryStatusRemoved)
 	builder.WithLimit(50)
-	builder.WithSorting("id", model.DefaultSortingDirection)
 
 	switch {
 	case request.HasQueryParam(r, "since_id"):
@@ -258,6 +257,7 @@ func (h *handler) handleItems(w http.ResponseWriter, r *http.Request) {
 				slog.Int64("since_id", sinceID),
 			)
 			builder.AfterEntryID(sinceID)
+			builder.WithSorting("id", "ASC")
 		}
 	case request.HasQueryParam(r, "max_id"):
 		maxID := request.QueryInt64Param(r, "max_id", 0)
@@ -324,7 +324,7 @@ func (h *handler) handleItems(w http.ResponseWriter, r *http.Request) {
 			FeedID:    entry.FeedID,
 			Title:     entry.Title,
 			Author:    entry.Author,
-			HTML:      mediaproxy.RewriteDocumentWithAbsoluteProxyURL(h.router, r.Host, entry.Content),
+			HTML:      mediaproxy.RewriteDocumentWithAbsoluteProxyURL(h.router, entry.Content),
 			URL:       entry.URL,
 			IsSaved:   isSaved,
 			IsRead:    isRead,

internal/googlereader/handler.go

@@ -24,7 +24,6 @@ import (
 	mff "miniflux.app/v2/internal/reader/handler"
 	mfs "miniflux.app/v2/internal/reader/subscription"
 	"miniflux.app/v2/internal/storage"
-	"miniflux.app/v2/internal/urllib"
 	"miniflux.app/v2/internal/validator"
 
 	"github.com/gorilla/mux"
@@ -1003,28 +1002,18 @@ func (h *handler) streamItemContentsHandler(w http.ResponseWriter, r *http.Reque
 			categories = append(categories, userStarred)
 		}
 
-		entry.Content = mediaproxy.RewriteDocumentWithAbsoluteProxyURL(h.router, r.Host, entry.Content)
-		proxyOption := config.Opts.MediaProxyMode()
+		entry.Content = mediaproxy.RewriteDocumentWithAbsoluteProxyURL(h.router, entry.Content)
 
-		for i := range entry.Enclosures {
-			if proxyOption == "all" || proxyOption != "none" && !urllib.IsHTTPS(entry.Enclosures[i].URL) {
-				for _, mediaType := range config.Opts.MediaProxyResourceTypes() {
-					if strings.HasPrefix(entry.Enclosures[i].MimeType, mediaType+"/") {
-						entry.Enclosures[i].URL = mediaproxy.ProxifyAbsoluteURL(h.router, r.Host, entry.Enclosures[i].URL)
-						break
-					}
-				}
-			}
-		}
+		entry.Enclosures.ProxifyEnclosureURL(h.router)
 
 		contentItems[i] = contentItem{
 			ID:            fmt.Sprintf(EntryIDLong, entry.ID),
 			Title:         entry.Title,
 			Author:        entry.Author,
-			TimestampUsec: fmt.Sprintf("%d", entry.Date.UnixNano()/(int64(time.Microsecond)/int64(time.Nanosecond))),
-			CrawlTimeMsec: fmt.Sprintf("%d", entry.Date.UnixNano()/(int64(time.Microsecond)/int64(time.Nanosecond))),
+			TimestampUsec: fmt.Sprintf("%d", entry.Date.UnixMicro()),
+			CrawlTimeMsec: fmt.Sprintf("%d", entry.CreatedAt.UnixMilli()),
 			Published:     entry.Date.Unix(),
-			Updated:       entry.Date.Unix(),
+			Updated:       entry.ChangedAt.Unix(),
 			Categories:    categories,
 			Canonical: []contentHREF{
 				{

internal/http/cookie/cookie.go

@@ -6,15 +6,14 @@ package cookie // import "miniflux.app/v2/internal/http/cookie"
 import (
 	"net/http"
 	"time"
+
+	"miniflux.app/v2/internal/config"
 )
 
 // Cookie names.
 const (
 	CookieAppSessionID  = "MinifluxAppSessionID"
 	CookieUserSessionID = "MinifluxUserSessionID"
-
-	// Cookie duration in days.
-	cookieDuration = 30
 )
 
 // New creates a new cookie.
@@ -25,7 +24,7 @@ func New(name, value string, isHTTPS bool, path string) *http.Cookie {
 		Path:     basePath(path),
 		Secure:   isHTTPS,
 		HttpOnly: true,
-		Expires:  time.Now().Add(cookieDuration * 24 * time.Hour),
+		Expires:  time.Now().Add(time.Duration(config.Opts.CleanupRemoveSessionsDays()) * 24 * time.Hour),
 		SameSite: http.SameSiteLaxMode,
 	}
 }

internal/http/request/cookie.go

@@ -8,7 +8,7 @@ import "net/http"
 // CookieValue returns the cookie value.
 func CookieValue(r *http.Request, name string) string {
 	cookie, err := r.Cookie(name)
-	if err == http.ErrNoCookie {
+	if err != nil {
 		return ""
 	}
 

internal/http/response/builder.go

@@ -12,6 +12,8 @@ import (
 	"net/http"
 	"strings"
 	"time"
+
+	"github.com/andybalholm/brotli"
 )
 
 const compressionThreshold = 1024
@@ -23,7 +25,7 @@ type Builder struct {
 	statusCode        int
 	headers           map[string]string
 	enableCompression bool
-	body              interface{}
+	body              any
 }
 
 // WithStatus uses the given status code to build the response.
@@ -39,7 +41,7 @@ func (b *Builder) WithHeader(key, value string) *Builder {
 }
 
 // WithBody uses the given body to build the response.
-func (b *Builder) WithBody(body interface{}) *Builder {
+func (b *Builder) WithBody(body any) *Builder {
 	b.body = body
 	return b
 }
@@ -110,8 +112,15 @@ func (b *Builder) writeHeaders() {
 func (b *Builder) compress(data []byte) {
 	if b.enableCompression && len(data) > compressionThreshold {
 		acceptEncoding := b.r.Header.Get("Accept-Encoding")
-
 		switch {
+		case strings.Contains(acceptEncoding, "br"):
+			b.headers["Content-Encoding"] = "br"
+			b.writeHeaders()
+
+			brotliWriter := brotli.NewWriterV2(b.w, brotli.DefaultCompression)
+			defer brotliWriter.Close()
+			brotliWriter.Write(data)
+			return
 		case strings.Contains(acceptEncoding, "gzip"):
 			b.headers["Content-Encoding"] = "gzip"
 			b.writeHeaders()

internal/http/response/builder_test.go

@@ -228,7 +228,7 @@ func TestBuildResponseWithCachingAndEtag(t *testing.T) {
 	}
 }
 
-func TestBuildResponseWithGzipCompression(t *testing.T) {
+func TestBuildResponseWithBrotliCompression(t *testing.T) {
 	body := strings.Repeat("a", compressionThreshold+1)
 	r, err := http.NewRequest("GET", "/", nil)
 	r.Header.Set("Accept-Encoding", "gzip, deflate, br")
@@ -245,6 +245,30 @@ func TestBuildResponseWithGzipCompression(t *testing.T) {
 	handler.ServeHTTP(w, r)
 	resp := w.Result()
 
+	expected := "br"
+	actual := resp.Header.Get("Content-Encoding")
+	if actual != expected {
+		t.Fatalf(`Unexpected header value, got %q instead of %q`, actual, expected)
+	}
+}
+
+func TestBuildResponseWithGzipCompression(t *testing.T) {
+	body := strings.Repeat("a", compressionThreshold+1)
+	r, err := http.NewRequest("GET", "/", nil)
+	r.Header.Set("Accept-Encoding", "gzip, deflate")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	w := httptest.NewRecorder()
+
+	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		New(w, r).WithBody(body).Write()
+	})
+
+	handler.ServeHTTP(w, r)
+	resp := w.Result()
+
 	expected := "gzip"
 	actual := resp.Header.Get("Content-Encoding")
 	if actual != expected {

internal/http/response/json/json.go

@@ -16,19 +16,31 @@ import (
 const contentTypeHeader = `application/json`
 
 // OK creates a new JSON response with a 200 status code.
-func OK(w http.ResponseWriter, r *http.Request, body interface{}) {
+func OK(w http.ResponseWriter, r *http.Request, body any) {
+	responseBody, err := json.Marshal(body)
+	if err != nil {
+		ServerError(w, r, err)
+		return
+	}
+
 	builder := response.New(w, r)
 	builder.WithHeader("Content-Type", contentTypeHeader)
-	builder.WithBody(toJSON(body))
+	builder.WithBody(responseBody)
 	builder.Write()
 }
 
 // Created sends a created response to the client.
-func Created(w http.ResponseWriter, r *http.Request, body interface{}) {
+func Created(w http.ResponseWriter, r *http.Request, body any) {
+	responseBody, err := json.Marshal(body)
+	if err != nil {
+		ServerError(w, r, err)
+		return
+	}
+
 	builder := response.New(w, r)
 	builder.WithStatus(http.StatusCreated)
 	builder.WithHeader("Content-Type", contentTypeHeader)
-	builder.WithBody(toJSON(body))
+	builder.WithBody(responseBody)
 	builder.Write()
 }
 
@@ -62,10 +74,17 @@ func ServerError(w http.ResponseWriter, r *http.Request, err error) {
 		),
 	)
 
+	responseBody, jsonErr := generateJSONError(err)
+	if jsonErr != nil {
+		slog.Error("Unable to generate JSON error", slog.Any("error", jsonErr))
+		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+		return
+	}
+
 	builder := response.New(w, r)
 	builder.WithStatus(http.StatusInternalServerError)
 	builder.WithHeader("Content-Type", contentTypeHeader)
-	builder.WithBody(toJSONError(err))
+	builder.WithBody(responseBody)
 	builder.Write()
 }
 
@@ -84,10 +103,17 @@ func BadRequest(w http.ResponseWriter, r *http.Request, err error) {
 		),
 	)
 
+	responseBody, jsonErr := generateJSONError(err)
+	if jsonErr != nil {
+		slog.Error("Unable to generate JSON error", slog.Any("error", jsonErr))
+		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+		return
+	}
+
 	builder := response.New(w, r)
 	builder.WithStatus(http.StatusBadRequest)
 	builder.WithHeader("Content-Type", contentTypeHeader)
-	builder.WithBody(toJSONError(err))
+	builder.WithBody(responseBody)
 	builder.Write()
 }
 
@@ -105,10 +131,17 @@ func Unauthorized(w http.ResponseWriter, r *http.Request) {
 		),
 	)
 
+	responseBody, jsonErr := generateJSONError(errors.New("access unauthorized"))
+	if jsonErr != nil {
+		slog.Error("Unable to generate JSON error", slog.Any("error", jsonErr))
+		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+		return
+	}
+
 	builder := response.New(w, r)
 	builder.WithStatus(http.StatusUnauthorized)
 	builder.WithHeader("Content-Type", contentTypeHeader)
-	builder.WithBody(toJSONError(errors.New("access unauthorized")))
+	builder.WithBody(responseBody)
 	builder.Write()
 }
 
@@ -126,10 +159,17 @@ func Forbidden(w http.ResponseWriter, r *http.Request) {
 		),
 	)
 
+	responseBody, jsonErr := generateJSONError(errors.New("access forbidden"))
+	if jsonErr != nil {
+		slog.Error("Unable to generate JSON error", slog.Any("error", jsonErr))
+		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+		return
+	}
+
 	builder := response.New(w, r)
 	builder.WithStatus(http.StatusForbidden)
 	builder.WithHeader("Content-Type", contentTypeHeader)
-	builder.WithBody(toJSONError(errors.New("access forbidden")))
+	builder.WithBody(responseBody)
 	builder.Write()
 }
 
@@ -147,27 +187,29 @@ func NotFound(w http.ResponseWriter, r *http.Request) {
 		),
 	)
 
+	responseBody, jsonErr := generateJSONError(errors.New("resource not found"))
+	if jsonErr != nil {
+		slog.Error("Unable to generate JSON error", slog.Any("error", jsonErr))
+		http.Error(w, http.StatusText(http.StatusInternalServerError), http.StatusInternalServerError)
+		return
+	}
+
 	builder := response.New(w, r)
 	builder.WithStatus(http.StatusNotFound)
 	builder.WithHeader("Content-Type", contentTypeHeader)
-	builder.WithBody(toJSONError(errors.New("resource not found")))
+	builder.WithBody(responseBody)
 	builder.Write()
 }
 
-func toJSONError(err error) []byte {
+func generateJSONError(err error) ([]byte, error) {
 	type errorMsg struct {
 		ErrorMessage string `json:"error_message"`
 	}
 
-	return toJSON(errorMsg{ErrorMessage: err.Error()})
-}
-
-func toJSON(v interface{}) []byte {
-	b, err := json.Marshal(v)
+	encodedBody, err := json.Marshal(errorMsg{ErrorMessage: err.Error()})
 	if err != nil {
-		slog.Error("Unable to marshal JSON response", slog.Any("error", err))
-		return []byte("")
+		return nil, err
 	}
 
-	return b
+	return encodedBody, nil
 }

internal/http/response/json/json_test.go

@@ -293,12 +293,12 @@ func TestBuildInvalidJSONResponse(t *testing.T) {
 	handler.ServeHTTP(w, r)
 	resp := w.Result()
 
-	expectedStatusCode := http.StatusOK
+	expectedStatusCode := http.StatusInternalServerError
 	if resp.StatusCode != expectedStatusCode {
 		t.Fatalf(`Unexpected status code, got %d instead of %d`, resp.StatusCode, expectedStatusCode)
 	}
 
-	expectedBody := ``
+	expectedBody := `{"error_message":"json: unsupported type: chan int"}`
 	actualBody := w.Body.String()
 	if actualBody != expectedBody {
 		t.Fatalf(`Unexpected body, got %s instead of %s`, actualBody, expectedBody)

internal/integration/apprise/apprise.go

@@ -7,6 +7,7 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"log/slog"
 	"net/http"
 	"time"
 
@@ -26,42 +27,53 @@ func NewClient(serviceURL, baseURL string) *Client {
 	return &Client{serviceURL, baseURL}
 }
 
-func (c *Client) SendNotification(entry *model.Entry) error {
+func (c *Client) SendNotification(feed *model.Feed, entries model.Entries) error {
 	if c.baseURL == "" || c.servicesURL == "" {
 		return fmt.Errorf("apprise: missing base URL or services URL")
 	}
 
-	message := "[" + entry.Title + "]" + "(" + entry.URL + ")" + "\n\n"
-	apiEndpoint, err := urllib.JoinBaseURLAndPath(c.baseURL, "/notify")
-	if err != nil {
-		return fmt.Errorf(`apprise: invalid API endpoint: %v`, err)
-	}
+	for _, entry := range entries {
+		message := "[" + entry.Title + "]" + "(" + entry.URL + ")" + "\n\n"
+		apiEndpoint, err := urllib.JoinBaseURLAndPath(c.baseURL, "/notify")
+		if err != nil {
+			return fmt.Errorf(`apprise: invalid API endpoint: %v`, err)
+		}
 
-	requestBody, err := json.Marshal(map[string]any{
-		"urls": c.servicesURL,
-		"body": message,
-	})
-	if err != nil {
-		return fmt.Errorf("apprise: unable to encode request body: %v", err)
-	}
+		requestBody, err := json.Marshal(map[string]any{
+			"urls":  c.servicesURL,
+			"body":  message,
+			"title": feed.Title,
+		})
+		if err != nil {
+			return fmt.Errorf("apprise: unable to encode request body: %v", err)
+		}
 
-	request, err := http.NewRequest(http.MethodPost, apiEndpoint, bytes.NewReader(requestBody))
-	if err != nil {
-		return fmt.Errorf("apprise: unable to create request: %v", err)
-	}
+		request, err := http.NewRequest(http.MethodPost, apiEndpoint, bytes.NewReader(requestBody))
+		if err != nil {
+			return fmt.Errorf("apprise: unable to create request: %v", err)
+		}
 
-	request.Header.Set("Content-Type", "application/json")
-	request.Header.Set("User-Agent", "Miniflux/"+version.Version)
+		request.Header.Set("Content-Type", "application/json")
+		request.Header.Set("User-Agent", "Miniflux/"+version.Version)
 
-	httpClient := &http.Client{Timeout: defaultClientTimeout}
-	response, err := httpClient.Do(request)
-	if err != nil {
-		return fmt.Errorf("apprise: unable to send request: %v", err)
-	}
-	defer response.Body.Close()
+		slog.Debug("Sending Apprise notification",
+			slog.String("apprise_url", c.baseURL),
+			slog.String("services_url", c.servicesURL),
+			slog.String("title", feed.Title),
+			slog.String("body", message),
+			slog.String("entry_url", entry.URL),
+		)
 
-	if response.StatusCode >= 400 {
-		return fmt.Errorf("apprise: unable to send a notification: url=%s status=%d", apiEndpoint, response.StatusCode)
+		httpClient := &http.Client{Timeout: defaultClientTimeout}
+		response, err := httpClient.Do(request)
+		if err != nil {
+			return fmt.Errorf("apprise: unable to send request: %v", err)
+		}
+		response.Body.Close()
+
+		if response.StatusCode >= 400 {
+			return fmt.Errorf("apprise: unable to send a notification: url=%s status=%d", apiEndpoint, response.StatusCode)
+		}
 	}
 
 	return nil

internal/integration/betula/betula.go

@@ -0,0 +1,57 @@
+package betula
+
+import (
+	"fmt"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+
+	"miniflux.app/v2/internal/urllib"
+	"miniflux.app/v2/internal/version"
+)
+
+const defaultClientTimeout = 10 * time.Second
+
+type Client struct {
+	url   string
+	token string
+}
+
+func NewClient(url, token string) *Client {
+	return &Client{url: url, token: token}
+}
+
+func (c *Client) CreateBookmark(entryURL, entryTitle string, tags []string) error {
+	apiEndpoint, err := urllib.JoinBaseURLAndPath(c.url, "/save-link")
+	if err != nil {
+		return fmt.Errorf("betula: unable to generate save-link endpoint: %v", err)
+	}
+
+	values := url.Values{}
+	values.Add("url", entryURL)
+	values.Add("title", entryTitle)
+	values.Add("tags", strings.Join(tags, ","))
+
+	request, err := http.NewRequest(http.MethodPost, apiEndpoint+"?"+values.Encode(), nil)
+	if err != nil {
+		return fmt.Errorf("betula: unable to create request: %v", err)
+	}
+
+	request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	request.Header.Set("User-Agent", "Miniflux/"+version.Version)
+	request.AddCookie(&http.Cookie{Name: "betula-token", Value: c.token})
+
+	httpClient := &http.Client{Timeout: defaultClientTimeout}
+	response, err := httpClient.Do(request)
+	if err != nil {
+		return fmt.Errorf("betula: unable to send request: %v", err)
+	}
+	defer response.Body.Close()
+
+	if response.StatusCode >= 400 {
+		return fmt.Errorf("betula: unable to create bookmark: url=%s status=%d", apiEndpoint, response.StatusCode)
+	}
+
+	return nil
+}

internal/integration/cubox/cubox.go

@@ -0,0 +1,70 @@
+// SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+// Cubox API documentation: https://help.cubox.cc/save/api/
+
+package cubox // import "miniflux.app/v2/internal/integration/cubox"
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"time"
+
+	"miniflux.app/v2/internal/version"
+)
+
+const defaultClientTimeout = 10 * time.Second
+
+type Client struct {
+	apiLink string
+}
+
+func NewClient(apiLink string) *Client {
+	return &Client{apiLink: apiLink}
+}
+
+func (c *Client) SaveLink(entryURL string) error {
+	if c.apiLink == "" {
+		return errors.New("cubox: missing API link")
+	}
+
+	requestBody, err := json.Marshal(&card{
+		Type:    "url",
+		Content: entryURL,
+	})
+	if err != nil {
+		return fmt.Errorf("cubox: unable to encode request body: %w", err)
+	}
+
+	ctx, cancel := context.WithTimeout(context.Background(), defaultClientTimeout)
+	defer cancel()
+
+	request, err := http.NewRequestWithContext(ctx, http.MethodPost, c.apiLink, bytes.NewReader(requestBody))
+	if err != nil {
+		return fmt.Errorf("cubox: unable to create request: %w", err)
+	}
+
+	request.Header.Set("Content-Type", "application/json")
+	request.Header.Set("User-Agent", "Miniflux/"+version.Version)
+
+	response, err := http.DefaultClient.Do(request)
+	if err != nil {
+		return fmt.Errorf("cubox: unable to send request: %w", err)
+	}
+	defer response.Body.Close()
+
+	if response.StatusCode != 200 {
+		return fmt.Errorf("cubox: unable to save link: status=%d", response.StatusCode)
+	}
+
+	return nil
+}
+
+type card struct {
+	Type    string `json:"type"`
+	Content string `json:"content"`
+}

internal/integration/discord/discord.go

@@ -0,0 +1,109 @@
+// SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+// Discord Webhooks documentation: https://discord.com/developers/docs/resources/webhook
+
+package discord // import "miniflux.app/v2/internal/integration/discord"
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"time"
+
+	"miniflux.app/v2/internal/model"
+	"miniflux.app/v2/internal/urllib"
+	"miniflux.app/v2/internal/version"
+)
+
+const defaultClientTimeout = 10 * time.Second
+const discordMsgColor = 5793266
+
+type Client struct {
+	webhookURL string
+}
+
+func NewClient(webhookURL string) *Client {
+	return &Client{webhookURL: webhookURL}
+}
+
+func (c *Client) SendDiscordMsg(feed *model.Feed, entries model.Entries) error {
+	for _, entry := range entries {
+		requestBody, err := json.Marshal(&discordMessage{
+			Embeds: []discordEmbed{
+				{
+					Title: "RSS feed update from Miniflux",
+					Color: discordMsgColor,
+					Fields: []discordFields{
+						{
+							Name:  "Updated feed",
+							Value: feed.Title,
+						},
+						{
+							Name:  "Article link",
+							Value: "[" + entry.Title + "]" + "(" + entry.URL + ")",
+						},
+						{
+							Name:   "Author",
+							Value:  entry.Author,
+							Inline: true,
+						},
+						{
+							Name:   "Source website",
+							Value:  urllib.RootURL(feed.SiteURL),
+							Inline: true,
+						},
+					},
+				},
+			},
+		})
+		if err != nil {
+			return fmt.Errorf("discord: unable to encode request body: %v", err)
+		}
+
+		request, err := http.NewRequest(http.MethodPost, c.webhookURL, bytes.NewReader(requestBody))
+		if err != nil {
+			return fmt.Errorf("discord: unable to create request: %v", err)
+		}
+
+		request.Header.Set("Content-Type", "application/json")
+		request.Header.Set("User-Agent", "Miniflux/"+version.Version)
+
+		slog.Debug("Sending Discord notification",
+			slog.String("webhookURL", c.webhookURL),
+			slog.String("title", feed.Title),
+			slog.String("entry_url", entry.URL),
+		)
+
+		httpClient := &http.Client{Timeout: defaultClientTimeout}
+		response, err := httpClient.Do(request)
+		if err != nil {
+			return fmt.Errorf("discord: unable to send request: %v", err)
+		}
+		response.Body.Close()
+
+		if response.StatusCode >= 400 {
+			return fmt.Errorf("discord: unable to send a notification: url=%s status=%d", c.webhookURL, response.StatusCode)
+		}
+	}
+
+	return nil
+}
+
+type discordFields struct {
+	Name   string `json:"name"`
+	Value  string `json:"value"`
+	Inline bool   `json:"inline,omitempty"`
+}
+
+type discordEmbed struct {
+	Title  string          `json:"title"`
+	Color  int             `json:"color"`
+	Fields []discordFields `json:"fields"`
+}
+
+type discordMessage struct {
+	Embeds []discordEmbed `json:"embeds"`
+}

internal/integration/integration.go

@@ -8,6 +8,9 @@ import (
 
 	"miniflux.app/v2/internal/config"
 	"miniflux.app/v2/internal/integration/apprise"
+	"miniflux.app/v2/internal/integration/betula"
+	"miniflux.app/v2/internal/integration/cubox"
+	"miniflux.app/v2/internal/integration/discord"
 	"miniflux.app/v2/internal/integration/espial"
 	"miniflux.app/v2/internal/integration/instapaper"
 	"miniflux.app/v2/internal/integration/linkace"
@@ -15,14 +18,18 @@ import (
 	"miniflux.app/v2/internal/integration/linkwarden"
 	"miniflux.app/v2/internal/integration/matrixbot"
 	"miniflux.app/v2/internal/integration/notion"
+	"miniflux.app/v2/internal/integration/ntfy"
 	"miniflux.app/v2/internal/integration/nunuxkeeper"
 	"miniflux.app/v2/internal/integration/omnivore"
 	"miniflux.app/v2/internal/integration/pinboard"
 	"miniflux.app/v2/internal/integration/pocket"
+	"miniflux.app/v2/internal/integration/pushover"
+	"miniflux.app/v2/internal/integration/raindrop"
 	"miniflux.app/v2/internal/integration/readeck"
 	"miniflux.app/v2/internal/integration/readwise"
 	"miniflux.app/v2/internal/integration/shaarli"
 	"miniflux.app/v2/internal/integration/shiori"
+	"miniflux.app/v2/internal/integration/slack"
 	"miniflux.app/v2/internal/integration/telegrambot"
 	"miniflux.app/v2/internal/integration/wallabag"
 	"miniflux.app/v2/internal/integration/webhook"
@@ -31,6 +38,30 @@ import (
 
 // SendEntry sends the entry to third-party providers when the user click on "Save".
 func SendEntry(entry *model.Entry, userIntegrations *model.Integration) {
+	if userIntegrations.BetulaEnabled {
+		slog.Debug("Sending entry to Betula",
+			slog.Int64("user_id", userIntegrations.UserID),
+			slog.Int64("entry_id", entry.ID),
+			slog.String("entry_url", entry.URL),
+		)
+
+		client := betula.NewClient(userIntegrations.BetulaURL, userIntegrations.BetulaToken)
+		err := client.CreateBookmark(
+			entry.URL,
+			entry.Title,
+			entry.Tags,
+		)
+
+		if err != nil {
+			slog.Error("Unable to send entry to Betula",
+				slog.Int64("user_id", userIntegrations.UserID),
+				slog.Int64("entry_id", entry.ID),
+				slog.String("entry_url", entry.URL),
+				slog.Any("error", err),
+			)
+		}
+	}
+
 	if userIntegrations.PinboardEnabled {
 		slog.Debug("Sending entry to Pinboard",
 			slog.Int64("user_id", userIntegrations.UserID),
@@ -295,6 +326,25 @@ func SendEntry(entry *model.Entry, userIntegrations *model.Integration) {
 		}
 	}
 
+	if userIntegrations.CuboxEnabled {
+		slog.Debug("Sending entry to Cubox",
+			slog.Int64("user_id", userIntegrations.UserID),
+			slog.Int64("entry_id", entry.ID),
+			slog.String("entry_url", entry.URL),
+		)
+
+		client := cubox.NewClient(userIntegrations.CuboxAPILink)
+
+		if err := client.SaveLink(entry.URL); err != nil {
+			slog.Error("Unable to send entry to Cubox",
+				slog.Int64("user_id", userIntegrations.UserID),
+				slog.Int64("entry_id", entry.ID),
+				slog.String("entry_url", entry.URL),
+				slog.Any("error", err),
+			)
+		}
+	}
+
 	if userIntegrations.ShioriEnabled {
 		slog.Debug("Sending entry to Shiori",
 			slog.Int64("user_id", userIntegrations.UserID),
@@ -359,6 +409,7 @@ func SendEntry(entry *model.Entry, userIntegrations *model.Integration) {
 			)
 		}
 	}
+
 	if userIntegrations.OmnivoreEnabled {
 		slog.Debug("Sending entry to Omnivore",
 			slog.Int64("user_id", userIntegrations.UserID),
@@ -376,6 +427,24 @@ func SendEntry(entry *model.Entry, userIntegrations *model.Integration) {
 			)
 		}
 	}
+
+	if userIntegrations.RaindropEnabled {
+		slog.Debug("Sending entry to Raindrop",
+			slog.Int64("user_id", userIntegrations.UserID),
+			slog.Int64("entry_id", entry.ID),
+			slog.String("entry_url", entry.URL),
+		)
+
+		client := raindrop.NewClient(userIntegrations.RaindropToken, userIntegrations.RaindropCollectionID, userIntegrations.RaindropTags)
+		if err := client.CreateRaindrop(entry.URL, entry.Title); err != nil {
+			slog.Error("Unable to send entry to Raindrop",
+				slog.Int64("user_id", userIntegrations.UserID),
+				slog.Int64("entry_id", entry.ID),
+				slog.String("entry_url", entry.URL),
+				slog.Any("error", err),
+			)
+		}
+	}
 }
 
 // PushEntries pushes a list of entries to activated third-party providers during feed refreshes.
@@ -406,27 +475,131 @@ func PushEntries(feed *model.Feed, entries model.Entries, userIntegrations *mode
 	}
 
 	if userIntegrations.WebhookEnabled {
+		var webhookURL string
+		if feed.WebhookURL != "" {
+			webhookURL = feed.WebhookURL
+		} else {
+			webhookURL = userIntegrations.WebhookURL
+		}
+
 		slog.Debug("Sending new entries to Webhook",
 			slog.Int64("user_id", userIntegrations.UserID),
 			slog.Int("nb_entries", len(entries)),
 			slog.Int64("feed_id", feed.ID),
-			slog.String("webhook_url", userIntegrations.WebhookURL),
+			slog.String("webhook_url", webhookURL),
 		)
 
-		webhookClient := webhook.NewClient(userIntegrations.WebhookURL, userIntegrations.WebhookSecret)
+		webhookClient := webhook.NewClient(webhookURL, userIntegrations.WebhookSecret)
 		if err := webhookClient.SendNewEntriesWebhookEvent(feed, entries); err != nil {
 			slog.Debug("Unable to send new entries to Webhook",
 				slog.Int64("user_id", userIntegrations.UserID),
 				slog.Int("nb_entries", len(entries)),
 				slog.Int64("feed_id", feed.ID),
-				slog.String("webhook_url", userIntegrations.WebhookURL),
+				slog.String("webhook_url", webhookURL),
 				slog.Any("error", err),
 			)
 		}
 	}
 
+	if userIntegrations.NtfyEnabled && feed.NtfyEnabled {
+		slog.Debug("Sending new entries to Ntfy",
+			slog.Int64("user_id", userIntegrations.UserID),
+			slog.Int("nb_entries", len(entries)),
+			slog.Int64("feed_id", feed.ID),
+		)
+
+		client := ntfy.NewClient(
+			userIntegrations.NtfyURL,
+			userIntegrations.NtfyTopic,
+			userIntegrations.NtfyAPIToken,
+			userIntegrations.NtfyUsername,
+			userIntegrations.NtfyPassword,
+			userIntegrations.NtfyIconURL,
+			userIntegrations.NtfyInternalLinks,
+			feed.NtfyPriority,
+		)
+
+		if err := client.SendMessages(feed, entries); err != nil {
+			slog.Warn("Unable to send new entries to Ntfy", slog.Any("error", err))
+		}
+	}
+
+	if userIntegrations.AppriseEnabled {
+		slog.Debug("Sending new entries to Apprise",
+			slog.Int64("user_id", userIntegrations.UserID),
+			slog.Int("nb_entries", len(entries)),
+			slog.Int64("feed_id", feed.ID),
+		)
+
+		appriseServiceURLs := userIntegrations.AppriseServicesURL
+		if feed.AppriseServiceURLs != "" {
+			appriseServiceURLs = feed.AppriseServiceURLs
+		}
+
+		client := apprise.NewClient(
+			appriseServiceURLs,
+			userIntegrations.AppriseURL,
+		)
+
+		if err := client.SendNotification(feed, entries); err != nil {
+			slog.Warn("Unable to send new entries to Apprise", slog.Any("error", err))
+		}
+	}
+
+	if userIntegrations.DiscordEnabled {
+		slog.Debug("Sending new entries to Discord",
+			slog.Int64("user_id", userIntegrations.UserID),
+			slog.Int("nb_entries", len(entries)),
+			slog.Int64("feed_id", feed.ID),
+		)
+
+		client := discord.NewClient(
+			userIntegrations.DiscordWebhookLink,
+		)
+
+		if err := client.SendDiscordMsg(feed, entries); err != nil {
+			slog.Warn("Unable to send new entries to Discord", slog.Any("error", err))
+		}
+	}
+
+	if userIntegrations.SlackEnabled {
+		slog.Debug("Sending new entries to Slack",
+			slog.Int64("user_id", userIntegrations.UserID),
+			slog.Int("nb_entries", len(entries)),
+			slog.Int64("feed_id", feed.ID),
+		)
+
+		client := slack.NewClient(
+			userIntegrations.SlackWebhookLink,
+		)
+
+		if err := client.SendSlackMsg(feed, entries); err != nil {
+			slog.Warn("Unable to send new entries to Slack", slog.Any("error", err))
+		}
+	}
+
+	if userIntegrations.PushoverEnabled && feed.PushoverEnabled {
+		slog.Debug("Sending new entries to Pushover",
+			slog.Int64("user_id", userIntegrations.UserID),
+			slog.Int("nb_entries", len(entries)),
+			slog.Int64("feed_id", feed.ID),
+		)
+
+		client := pushover.New(
+			userIntegrations.PushoverUser,
+			userIntegrations.PushoverToken,
+			feed.PushoverPriority,
+			userIntegrations.PushoverDevice,
+			userIntegrations.PushoverPrefix,
+		)
+
+		if err := client.SendMessages(feed, entries); err != nil {
+			slog.Warn("Unable to send new entries to Pushover", slog.Any("error", err))
+		}
+	}
+
 	// Integrations that only support sending individual entries
-	if userIntegrations.TelegramBotEnabled || userIntegrations.AppriseEnabled {
+	if userIntegrations.TelegramBotEnabled {
 		for _, entry := range entries {
 			if userIntegrations.TelegramBotEnabled {
 				slog.Debug("Sending a new entry to Telegram",
@@ -453,35 +626,6 @@ func PushEntries(feed *model.Feed, entries model.Entries, userIntegrations *mode
 					)
 				}
 			}
-
-			if userIntegrations.AppriseEnabled {
-				slog.Debug("Sending a new entry to Apprise",
-					slog.Int64("user_id", userIntegrations.UserID),
-					slog.Int64("entry_id", entry.ID),
-					slog.String("entry_url", entry.URL),
-					slog.String("apprise_url", userIntegrations.AppriseURL),
-				)
-
-				appriseServiceURLs := userIntegrations.AppriseServicesURL
-				if feed.AppriseServiceURLs != "" {
-					appriseServiceURLs = feed.AppriseServiceURLs
-				}
-
-				client := apprise.NewClient(
-					appriseServiceURLs,
-					userIntegrations.AppriseURL,
-				)
-
-				if err := client.SendNotification(entry); err != nil {
-					slog.Error("Unable to send entry to Apprise",
-						slog.Int64("user_id", userIntegrations.UserID),
-						slog.Int64("entry_id", entry.ID),
-						slog.String("entry_url", entry.URL),
-						slog.String("apprise_url", userIntegrations.AppriseURL),
-						slog.Any("error", err),
-					)
-				}
-			}
 		}
 	}
 }

internal/integration/linkace/linkace.go

@@ -35,7 +35,7 @@ func (c *Client) AddURL(entryURL, entryTitle string) error {
 		return c == ',' || c == ' '
 	}
 
-	apiEndpoint, err := urllib.JoinBaseURLAndPath(c.baseURL, "/api/v1/links")
+	apiEndpoint, err := urllib.JoinBaseURLAndPath(c.baseURL, "/api/v2/links")
 	if err != nil {
 		return fmt.Errorf("linkace: invalid API endpoint: %v", err)
 	}

internal/integration/matrixbot/matrixbot.go

@@ -10,7 +10,7 @@ import (
 	"miniflux.app/v2/internal/model"
 )
 
-// PushEntry pushes entries to matrix chat using integration settings provided
+// PushEntries pushes entries to matrix chat using integration settings provided
 func PushEntries(feed *model.Feed, entries model.Entries, matrixBaseURL, matrixUsername, matrixPassword, matrixRoomID string) error {
 	client := NewClient(matrixBaseURL)
 	discovery, err := client.DiscoverEndpoints()

internal/integration/ntfy/ntfy.go

@@ -0,0 +1,132 @@
+// SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package ntfy // import "miniflux.app/v2/internal/integration/ntfy"
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"net/url"
+	"time"
+
+	"miniflux.app/v2/internal/config"
+	"miniflux.app/v2/internal/model"
+	"miniflux.app/v2/internal/version"
+)
+
+const (
+	defaultClientTimeout = 10 * time.Second
+	defaultNtfyURL       = "https://ntfy.sh"
+)
+
+type Client struct {
+	ntfyURL, ntfyTopic, ntfyApiToken, ntfyUsername, ntfyPassword, ntfyIconURL string
+	ntfyInternalLinks                                                         bool
+	ntfyPriority                                                              int
+}
+
+func NewClient(ntfyURL, ntfyTopic, ntfyApiToken, ntfyUsername, ntfyPassword, ntfyIconURL string, ntfyInternalLinks bool, ntfyPriority int) *Client {
+	if ntfyURL == "" {
+		ntfyURL = defaultNtfyURL
+	}
+	return &Client{ntfyURL, ntfyTopic, ntfyApiToken, ntfyUsername, ntfyPassword, ntfyIconURL, ntfyInternalLinks, ntfyPriority}
+}
+
+func (c *Client) SendMessages(feed *model.Feed, entries model.Entries) error {
+	for _, entry := range entries {
+		ntfyMessage := &ntfyMessage{
+			Topic:    c.ntfyTopic,
+			Message:  entry.Title,
+			Title:    feed.Title,
+			Priority: c.ntfyPriority,
+			Click:    entry.URL,
+		}
+
+		if c.ntfyIconURL != "" {
+			ntfyMessage.Icon = c.ntfyIconURL
+		}
+
+		if c.ntfyInternalLinks {
+			url, err := url.Parse(config.Opts.BaseURL())
+			if err != nil {
+				slog.Error("Unable to parse base URL", slog.Any("error", err))
+			} else {
+				ntfyMessage.Click = fmt.Sprintf("%s%s%d", url, "/unread/entry/", entry.ID)
+			}
+		}
+
+		slog.Debug("Sending Ntfy message",
+			slog.String("url", c.ntfyURL),
+			slog.String("topic", c.ntfyTopic),
+			slog.Int("priority", ntfyMessage.Priority),
+			slog.String("message", ntfyMessage.Message),
+			slog.String("entry_url", ntfyMessage.Click),
+		)
+
+		if err := c.makeRequest(ntfyMessage); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (c *Client) makeRequest(payload any) error {
+	requestBody, err := json.Marshal(payload)
+	if err != nil {
+		return fmt.Errorf("ntfy: unable to encode request body: %v", err)
+	}
+
+	request, err := http.NewRequest(http.MethodPost, c.ntfyURL, bytes.NewReader(requestBody))
+	if err != nil {
+		return fmt.Errorf("ntfy: unable to create request: %v", err)
+	}
+
+	request.Header.Set("Content-Type", "application/json")
+	request.Header.Set("User-Agent", "Miniflux/"+version.Version)
+
+	// See https://docs.ntfy.sh/publish/#access-tokens
+	if c.ntfyApiToken != "" {
+		request.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.ntfyApiToken))
+	}
+
+	// See https://docs.ntfy.sh/publish/#username-password
+	if c.ntfyUsername != "" && c.ntfyPassword != "" {
+		request.SetBasicAuth(c.ntfyUsername, c.ntfyPassword)
+	}
+
+	httpClient := &http.Client{Timeout: defaultClientTimeout}
+	response, err := httpClient.Do(request)
+	if err != nil {
+		return fmt.Errorf("ntfy: unable to send request: %v", err)
+	}
+	defer response.Body.Close()
+
+	if response.StatusCode >= 400 {
+		return fmt.Errorf("ntfy: incorrect response status code %d for url %s", response.StatusCode, c.ntfyURL)
+	}
+
+	return nil
+}
+
+// See https://docs.ntfy.sh/publish/#publish-as-json
+type ntfyMessage struct {
+	Topic    string       `json:"topic"`
+	Message  string       `json:"message"`
+	Title    string       `json:"title"`
+	Tags     []string     `json:"tags,omitempty"`
+	Priority int          `json:"priority,omitempty"`
+	Icon     string       `json:"icon,omitempty"` // https://docs.ntfy.sh/publish/#icons
+	Click    string       `json:"click,omitempty"`
+	Actions  []ntfyAction `json:"actions,omitempty"`
+}
+
+// See https://docs.ntfy.sh/publish/#action-buttons
+type ntfyAction struct {
+	Action string `json:"action"`
+	Label  string `json:"label"`
+	URL    string `json:"url"`
+}

internal/integration/pinboard/pinboard.go

@@ -4,6 +4,8 @@
 package pinboard // import "miniflux.app/v2/internal/integration/pinboard"
 
 import (
+	"encoding/xml"
+	"errors"
 	"fmt"
 	"net/http"
 	"net/url"
@@ -12,6 +14,9 @@ import (
 	"miniflux.app/v2/internal/version"
 )
 
+var errPostNotFound = fmt.Errorf("pinboard: post not found")
+var errMissingCredentials = fmt.Errorf("pinboard: missing auth token")
+
 const defaultClientTimeout = 10 * time.Second
 
 type Client struct {
@@ -24,20 +29,27 @@ func NewClient(authToken string) *Client {
 
 func (c *Client) CreateBookmark(entryURL, entryTitle, pinboardTags string, markAsUnread bool) error {
 	if c.authToken == "" {
-		return fmt.Errorf("pinboard: missing auth token")
+		return errMissingCredentials
 	}
 
-	toRead := "no"
+	// We check if the url is already bookmarked to avoid overriding existing data.
+	post, err := c.getBookmark(entryURL)
+
+	if err != nil && errors.Is(err, errPostNotFound) {
+		post = NewPost(entryURL, entryTitle)
+	} else if err != nil {
+		// In case of any other error, we return immediately to avoid overriding existing data.
+		return err
+	}
+
+	post.addTag(pinboardTags)
 	if markAsUnread {
-		toRead = "yes"
+		post.SetToread()
 	}
 
 	values := url.Values{}
 	values.Add("auth_token", c.authToken)
-	values.Add("url", entryURL)
-	values.Add("description", entryTitle)
-	values.Add("tags", pinboardTags)
-	values.Add("toread", toRead)
+	post.AddValues(values)
 
 	apiEndpoint := "https://api.pinboard.in/v1/posts/add?" + values.Encode()
 	request, err := http.NewRequest(http.MethodGet, apiEndpoint, nil)
@@ -61,3 +73,46 @@ func (c *Client) CreateBookmark(entryURL, entryTitle, pinboardTags string, markA
 
 	return nil
 }
+
+// getBookmark fetches a bookmark from Pinboard. https://www.pinboard.in/api/#posts_get
+func (c *Client) getBookmark(entryURL string) (*Post, error) {
+	if c.authToken == "" {
+		return nil, errMissingCredentials
+	}
+
+	values := url.Values{}
+	values.Add("auth_token", c.authToken)
+	values.Add("url", entryURL)
+
+	apiEndpoint := "https://api.pinboard.in/v1/posts/get?" + values.Encode()
+	request, err := http.NewRequest(http.MethodGet, apiEndpoint, nil)
+	if err != nil {
+		return nil, fmt.Errorf("pinboard: unable to create request: %v", err)
+	}
+
+	request.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	request.Header.Set("User-Agent", "Miniflux/"+version.Version)
+
+	httpClient := &http.Client{Timeout: defaultClientTimeout}
+	response, err := httpClient.Do(request)
+	if err != nil {
+		return nil, fmt.Errorf("pinboard: unable fetch bookmark: %v", err)
+	}
+	defer response.Body.Close()
+
+	if response.StatusCode >= 400 {
+		return nil, fmt.Errorf("pinboard: unable to fetch bookmark, status=%d", response.StatusCode)
+	}
+
+	var results posts
+	err = xml.NewDecoder(response.Body).Decode(&results)
+	if err != nil {
+		return nil, fmt.Errorf("pinboard: unable to decode XML: %v", err)
+	}
+
+	if len(results.Posts) == 0 {
+		return nil, errPostNotFound
+	}
+
+	return &results.Posts[0], nil
+}

internal/integration/pinboard/post.go

@@ -0,0 +1,62 @@
+// SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package pinboard // import "miniflux.app/v2/internal/integration/pinboard"
+
+import (
+	"encoding/xml"
+	"net/url"
+	"strings"
+	"time"
+)
+
+// Post a Pinboard bookmark.  "inspiration" from https://github.com/drags/pinboard/blob/master/posts.go#L32-L42
+type Post struct {
+	XMLName     xml.Name  `xml:"post"`
+	Url         string    `xml:"href,attr"`
+	Description string    `xml:"description,attr"`
+	Tags        string    `xml:"tag,attr"`
+	Extended    string    `xml:"extended,attr"`
+	Date        time.Time `xml:"time,attr"`
+	Shared      string    `xml:"shared,attr"`
+	Toread      string    `xml:"toread,attr"`
+}
+
+// Posts A result of a Pinboard API call
+type posts struct {
+	XMLName xml.Name `xml:"posts"`
+	Posts   []Post   `xml:"post"`
+}
+
+func NewPost(url string, description string) *Post {
+	return &Post{
+		Url:         url,
+		Description: description,
+		Date:        time.Now(),
+		Toread:      "no",
+	}
+}
+
+func (p *Post) addTag(tag string) {
+	if !strings.Contains(p.Tags, tag) {
+		p.Tags += " " + tag
+	}
+}
+
+func (p *Post) SetToread() {
+	p.Toread = "yes"
+}
+
+func (p *Post) AddValues(values url.Values) {
+	values.Add("url", p.Url)
+	values.Add("description", p.Description)
+	values.Add("tags", p.Tags)
+	if p.Toread != "" {
+		values.Add("toread", p.Toread)
+	}
+	if p.Shared != "" {
+		values.Add("shared", p.Shared)
+	}
+	values.Add("dt", p.Date.Format(time.RFC3339))
+	values.Add("extended", p.Extended)
+}

internal/integration/pushover/pushover.go

@@ -0,0 +1,138 @@
+// SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package pushover // import "miniflux.app/v2/internal/integration/pushover"
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"strings"
+	"time"
+
+	"miniflux.app/v2/internal/model"
+	"miniflux.app/v2/internal/version"
+)
+
+const (
+	defaultClientTimeout = 10 * time.Second
+	defaultPushoverURL   = "https://api.pushover.net"
+)
+
+type Client struct {
+	prefix string
+
+	token  string
+	user   string
+	device string
+
+	priority int
+}
+
+type Message struct {
+	Token string `json:"token"`
+	User  string `json:"user"`
+
+	Title    string `json:"title"`
+	Message  string `json:"message"`
+	Priority int    `json:"priority"`
+
+	URL      string `json:"url"`
+	URLTitle string `json:"url_title"`
+	Device   string `json:"device,omitempty"`
+}
+
+type ErrorResponse struct {
+	User    string   `json:"user"`
+	Errors  []string `json:"errors"`
+	Status  int      `json:"status"`
+	Request string   `json:"request"`
+}
+
+func New(user, token string, priority int, device, urlPrefix string) *Client {
+	if urlPrefix == "" {
+		urlPrefix = defaultPushoverURL
+	}
+	if priority < -2 {
+		priority = -2
+	}
+	if priority > 2 {
+		priority = 2
+	}
+
+	return &Client{
+		user:     user,
+		token:    token,
+		device:   device,
+		prefix:   urlPrefix,
+		priority: priority,
+	}
+}
+
+func (c *Client) SendMessages(feed *model.Feed, entries model.Entries) error {
+	if c.token == "" || c.user == "" {
+		return fmt.Errorf("pushover token and user are required")
+	}
+	for _, entry := range entries {
+		msg := &Message{
+			User:   c.user,
+			Token:  c.token,
+			Device: c.device,
+
+			Message:  entry.Title,
+			Title:    feed.Title,
+			Priority: c.priority,
+			URL:      entry.URL,
+		}
+
+		slog.Debug("Sending Pushover message",
+			slog.Int("priority", msg.Priority),
+			slog.String("message", msg.Message),
+			slog.String("entry_url", msg.URL),
+		)
+
+		if err := c.makeRequest(msg); err != nil {
+			return fmt.Errorf("c.makeRequest: %w", err)
+		}
+	}
+
+	return nil
+}
+
+func (c *Client) makeRequest(payload *Message) error {
+	jsonData, err := json.Marshal(payload)
+	if err != nil {
+		return fmt.Errorf("json.Marshal: %w", err)
+	}
+	url := c.prefix + "/1/messages.json"
+	req, err := http.NewRequest(http.MethodPost, url, bytes.NewBuffer(jsonData))
+	if err != nil {
+		return fmt.Errorf("http.NewRequest: %w", err)
+	}
+
+	req.Header.Add("Content-Type", "application/json")
+	req.Header.Set("User-Agent", "Miniflux/"+version.Version)
+
+	httpClient := &http.Client{Timeout: defaultClientTimeout}
+	resp, err := httpClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("httpClient.Do: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode >= http.StatusBadRequest {
+		errorMessage := resp.Status
+
+		var errResp ErrorResponse
+		if err := json.NewDecoder(resp.Body).Decode(&errResp); err != nil {
+			if len(errResp.Errors) > 0 {
+				errorMessage = strings.Join(errResp.Errors, ",")
+			}
+		}
+
+		return fmt.Errorf("pushover API error (%d): %s", resp.StatusCode, errorMessage)
+	}
+
+	return nil
+}

internal/integration/raindrop/raindrop.go

@@ -0,0 +1,78 @@
+// SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package raindrop // import "miniflux.app/v2/internal/integration/raindrop"
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"miniflux.app/v2/internal/version"
+)
+
+const defaultClientTimeout = 10 * time.Second
+
+type Client struct {
+	token        string
+	collectionID string
+	tags         []string
+}
+
+func NewClient(token, collectionID, tags string) *Client {
+	return &Client{token: token, collectionID: collectionID, tags: strings.Split(tags, ",")}
+}
+
+// https://developer.raindrop.io/v1/raindrops/single#create-raindrop
+func (c *Client) CreateRaindrop(entryURL, entryTitle string) error {
+	if c.token == "" {
+		return fmt.Errorf("raindrop: missing token")
+	}
+
+	var request *http.Request
+	requestBodyJson, err := json.Marshal(&raindrop{
+		Link:       entryURL,
+		Title:      entryTitle,
+		Collection: collection{Id: c.collectionID},
+		Tags:       c.tags,
+	})
+	if err != nil {
+		return fmt.Errorf("raindrop: unable to encode request body: %v", err)
+	}
+
+	request, err = http.NewRequest(http.MethodPost, "https://api.raindrop.io/rest/v1/raindrop", bytes.NewReader(requestBodyJson))
+	if err != nil {
+		return fmt.Errorf("raindrop: unable to create request: %v", err)
+	}
+	request.Header.Set("Content-Type", "application/json")
+
+	request.Header.Set("User-Agent", "Miniflux/"+version.Version)
+	request.Header.Set("Authorization", "Bearer "+c.token)
+
+	httpClient := &http.Client{Timeout: defaultClientTimeout}
+	response, err := httpClient.Do(request)
+	if err != nil {
+		return fmt.Errorf("raindrop: unable to send request: %v", err)
+	}
+	defer response.Body.Close()
+
+	if response.StatusCode >= 400 {
+		return fmt.Errorf("raindrop: unable to create bookmark: status=%d", response.StatusCode)
+	}
+
+	return nil
+}
+
+type raindrop struct {
+	Link       string     `json:"link"`
+	Title      string     `json:"title"`
+	Collection collection `json:"collection,omitempty"`
+	Tags       []string   `json:"tags"`
+}
+
+type collection struct {
+	Id string `json:"$id"`
+}

internal/integration/readeck/readeck.go

@@ -91,7 +91,7 @@ func (c *Client) CreateBookmark(entryURL, entryTitle string, entryContent string
 
 		contentBodyHeader, err := json.Marshal(&partContentHeader{
 			Url:           entryURL,
-			ContentHeader: contentHeader{ContentType: "text/html"},
+			ContentHeader: contentHeader{ContentType: "text/html; charset=utf-8"},
 		})
 		if err != nil {
 			return fmt.Errorf("readeck: unable to encode request body (entry content header): %v", err)

internal/integration/shiori/shiori.go

@@ -31,7 +31,7 @@ func (c *Client) CreateBookmark(entryURL, entryTitle string) error {
 		return fmt.Errorf("shiori: missing base URL, username or password")
 	}
 
-	sessionID, err := c.authenticate()
+	token, err := c.authenticate()
 	if err != nil {
 		return fmt.Errorf("shiori: unable to authenticate: %v", err)
 	}
@@ -44,7 +44,11 @@ func (c *Client) CreateBookmark(entryURL, entryTitle string) error {
 	requestBody, err := json.Marshal(&addBookmarkRequest{
 		URL:           entryURL,
 		Title:         entryTitle,
+		Excerpt:       "",
 		CreateArchive: true,
+		CreateEbook:   false,
+		Public:        0,
+		Tags:          make([]string, 0),
 	})
 
 	if err != nil {
@@ -58,7 +62,7 @@ func (c *Client) CreateBookmark(entryURL, entryTitle string) error {
 
 	request.Header.Set("Content-Type", "application/json")
 	request.Header.Set("User-Agent", "Miniflux/"+version.Version)
-	request.Header.Set("X-Session-Id", sessionID)
+	request.Header.Set("Authorization", "Bearer "+token)
 
 	httpClient := &http.Client{Timeout: defaultClientTimeout}
 
@@ -75,13 +79,13 @@ func (c *Client) CreateBookmark(entryURL, entryTitle string) error {
 	return nil
 }
 
-func (c *Client) authenticate() (sessionID string, err error) {
-	apiEndpoint, err := urllib.JoinBaseURLAndPath(c.baseURL, "/api/login")
+func (c *Client) authenticate() (token string, err error) {
+	apiEndpoint, err := urllib.JoinBaseURLAndPath(c.baseURL, "/api/v1/auth/login")
 	if err != nil {
 		return "", fmt.Errorf("shiori: invalid API endpoint: %v", err)
 	}
 
-	requestBody, err := json.Marshal(&authRequest{Username: c.username, Password: c.password})
+	requestBody, err := json.Marshal(&authRequest{Username: c.username, Password: c.password, RememberMe: false})
 	if err != nil {
 		return "", fmt.Errorf("shiori: unable to encode request body: %v", err)
 	}
@@ -111,21 +115,31 @@ func (c *Client) authenticate() (sessionID string, err error) {
 	if err := json.NewDecoder(response.Body).Decode(&authResponse); err != nil {
 		return "", fmt.Errorf("shiori: unable to decode response: %v", err)
 	}
-
-	return authResponse.SessionID, nil
+	return authResponse.Message.Token, nil
 }
 
 type authRequest struct {
-	Username string `json:"username"`
-	Password string `json:"password"`
+	Username   string `json:"username"`
+	Password   string `json:"password"`
+	RememberMe bool   `json:"remember_me"`
 }
 
 type authResponse struct {
+	OK      bool                `json:"ok"`
+	Message authResponseMessage `json:"message"`
+}
+
+type authResponseMessage struct {
 	SessionID string `json:"session"`
+	Token     string `json:"token"`
 }
 
 type addBookmarkRequest struct {
-	URL           string `json:"url"`
-	Title         string `json:"title"`
-	CreateArchive bool   `json:"createArchive"`
+	URL           string   `json:"url"`
+	Title         string   `json:"title"`
+	CreateArchive bool     `json:"create_archive"`
+	CreateEbook   bool     `json:"create_ebook"`
+	Public        int      `json:"public"`
+	Excerpt       string   `json:"excerpt"`
+	Tags          []string `json:"tags"`
 }

internal/integration/slack/slack.go

@@ -0,0 +1,113 @@
+// SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+// Slack Webhooks documentation: https://api.slack.com/messaging/webhooks
+
+package slack // import "miniflux.app/v2/internal/integration/slack"
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"log/slog"
+	"net/http"
+	"time"
+
+	"miniflux.app/v2/internal/model"
+	"miniflux.app/v2/internal/urllib"
+	"miniflux.app/v2/internal/version"
+)
+
+const defaultClientTimeout = 10 * time.Second
+const slackMsgColor = "#5865F2"
+
+type Client struct {
+	webhookURL string
+}
+
+func NewClient(webhookURL string) *Client {
+	return &Client{webhookURL: webhookURL}
+}
+
+func (c *Client) SendSlackMsg(feed *model.Feed, entries model.Entries) error {
+	for _, entry := range entries {
+		requestBody, err := json.Marshal(&slackMessage{
+			Attachments: []slackAttachments{
+				{
+					Title: "RSS feed update from Miniflux",
+					Color: slackMsgColor,
+					Fields: []slackFields{
+						{
+							Title: "Updated feed",
+							Value: feed.Title,
+						},
+						{
+							Title: "Article title",
+							Value: entry.Title,
+						},
+						{
+							Title: "Article link",
+							Value: entry.URL,
+						},
+						{
+							Title: "Author",
+							Value: entry.Author,
+							Short: true,
+						},
+						{
+							Title: "Source website",
+							Value: urllib.RootURL(feed.SiteURL),
+							Short: true,
+						},
+					},
+				},
+			},
+		})
+		if err != nil {
+			return fmt.Errorf("slack: unable to encode request body: %v", err)
+		}
+
+		request, err := http.NewRequest(http.MethodPost, c.webhookURL, bytes.NewReader(requestBody))
+		if err != nil {
+			return fmt.Errorf("slack: unable to create request: %v", err)
+		}
+
+		request.Header.Set("Content-Type", "application/json")
+		request.Header.Set("User-Agent", "Miniflux/"+version.Version)
+
+		slog.Debug("Sending Slack notification",
+			slog.String("webhookURL", c.webhookURL),
+			slog.String("title", feed.Title),
+			slog.String("entry_url", entry.URL),
+		)
+
+		httpClient := &http.Client{Timeout: defaultClientTimeout}
+		response, err := httpClient.Do(request)
+		if err != nil {
+			return fmt.Errorf("slack: unable to send request: %v", err)
+		}
+		response.Body.Close()
+
+		if response.StatusCode >= 400 {
+			return fmt.Errorf("slack: unable to send a notification: url=%s status=%d", c.webhookURL, response.StatusCode)
+		}
+	}
+
+	return nil
+}
+
+type slackFields struct {
+	Title string `json:"title"`
+	Value string `json:"value"`
+	Short bool   `json:"short,omitempty"`
+}
+
+type slackAttachments struct {
+	Title  string        `json:"title"`
+	Color  string        `json:"color"`
+	Fields []slackFields `json:"fields"`
+}
+
+type slackMessage struct {
+	Attachments []slackAttachments `json:"attachments"`
+}

internal/integration/telegrambot/telegrambot.go

@@ -11,7 +11,8 @@ import (
 
 func PushEntry(feed *model.Feed, entry *model.Entry, botToken, chatID string, topicID *int64, disableWebPagePreview, disableNotification bool, disableButtons bool) error {
 	formattedText := fmt.Sprintf(
-		`<a href=%q>%s</a>`,
+		`<b>%s</b> - <a href=%q>%s</a>`,
+		feed.Title,
 		entry.URL,
 		entry.Title,
 	)

internal/locale/catalog.go

@@ -12,17 +12,26 @@ import (
 type translationDict map[string]interface{}
 type catalog map[string]translationDict
 
-var defaultCatalog catalog
+var defaultCatalog = make(catalog, len(AvailableLanguages))
 
 //go:embed translations/*.json
 var translationFiles embed.FS
 
+func GetTranslationDict(language string) (translationDict, error) {
+	if _, ok := defaultCatalog[language]; !ok {
+		var err error
+		if defaultCatalog[language], err = loadTranslationFile(language); err != nil {
+			return nil, err
+		}
+	}
+	return defaultCatalog[language], nil
+}
+
 // LoadCatalogMessages loads and parses all translations encoded in JSON.
 func LoadCatalogMessages() error {
 	var err error
-	defaultCatalog = make(catalog, len(AvailableLanguages()))
 
-	for language := range AvailableLanguages() {
+	for language := range AvailableLanguages {
 		defaultCatalog[language], err = loadTranslationFile(language)
 		if err != nil {
 			return err

internal/locale/catalog_test.go

@@ -39,7 +39,7 @@ func TestLoadCatalog(t *testing.T) {
 }
 
 func TestAllKeysHaveValue(t *testing.T) {
-	for language := range AvailableLanguages() {
+	for language := range AvailableLanguages {
 		messages, err := loadTranslationFile(language)
 		if err != nil {
 			t.Fatalf(`Unable to load translation messages for language %q`, language)
@@ -71,7 +71,7 @@ func TestMissingTranslations(t *testing.T) {
 		t.Fatal(`Unable to parse reference language`)
 	}
 
-	for language := range AvailableLanguages() {
+	for language := range AvailableLanguages {
 		if language == refLang {
 			continue
 		}
@@ -90,7 +90,28 @@ func TestMissingTranslations(t *testing.T) {
 }
 
 func TestTranslationFilePluralForms(t *testing.T) {
-	for language := range AvailableLanguages() {
+	var numberOfPluralFormsPerLanguage = map[string]int{
+		"en_US":            2,
+		"es_ES":            2,
+		"fr_FR":            2,
+		"de_DE":            2,
+		"pl_PL":            3,
+		"pt_BR":            2,
+		"zh_CN":            1,
+		"zh_TW":            1,
+		"nan_Latn_pehoeji": 1,
+		"nl_NL":            2,
+		"ru_RU":            3,
+		"it_IT":            2,
+		"ja_JP":            1,
+		"tr_TR":            2,
+		"el_EL":            2,
+		"fi_FI":            2,
+		"hi_IN":            2,
+		"uk_UA":            3,
+		"id_ID":            1,
+	}
+	for language := range AvailableLanguages {
 		messages, err := loadTranslationFile(language)
 		if err != nil {
 			t.Fatalf(`Unable to load translation messages for language %q`, language)

internal/locale/locale.go

@@ -3,47 +3,25 @@
 
 package locale // import "miniflux.app/v2/internal/locale"
 
-var numberOfPluralFormsPerLanguage = map[string]int{
-	"en_US": 2,
-	"es_ES": 2,
-	"fr_FR": 2,
-	"de_DE": 2,
-	"pl_PL": 3,
-	"pt_BR": 2,
-	"zh_CN": 1,
-	"zh_TW": 1,
-	"nl_NL": 2,
-	"ru_RU": 3,
-	"it_IT": 2,
-	"ja_JP": 1,
-	"tr_TR": 2,
-	"el_EL": 2,
-	"fi_FI": 2,
-	"hi_IN": 2,
-	"uk_UA": 3,
-	"id_ID": 1,
-}
-
-// AvailableLanguages returns the list of available languages.
-func AvailableLanguages() map[string]string {
-	return map[string]string{
-		"en_US": "English",
-		"es_ES": "Español",
-		"fr_FR": "Français",
-		"de_DE": "Deutsch",
-		"pl_PL": "Polski",
-		"pt_BR": "Português Brasileiro",
-		"zh_CN": "简体中文",
-		"zh_TW": "繁體中文",
-		"nl_NL": "Nederlands",
-		"ru_RU": "Русский",
-		"it_IT": "Italiano",
-		"ja_JP": "日本語",
-		"tr_TR": "Türkçe",
-		"el_EL": "Ελληνικά",
-		"fi_FI": "Suomi",
-		"hi_IN": "हिन्दी",
-		"uk_UA": "Українська",
-		"id_ID": "Bahasa Indonesia",
-	}
+// AvailableLanguages is the list of available languages.
+var AvailableLanguages = map[string]string{
+	"en_US":            "English",
+	"es_ES":            "Español",
+	"fr_FR":            "Français",
+	"de_DE":            "Deutsch",
+	"pl_PL":            "Polski",
+	"pt_BR":            "Português Brasileiro",
+	"zh_CN":            "简体中文",
+	"zh_TW":            "繁體中文",
+	"nan_Latn_pehoeji": "Pe̍h-ōe-jī",
+	"nl_NL":            "Nederlands",
+	"ru_RU":            "Русский",
+	"it_IT":            "Italiano",
+	"ja_JP":            "日本語",
+	"tr_TR":            "Türkçe",
+	"el_EL":            "Ελληνικά",
+	"fi_FI":            "Suomi",
+	"hi_IN":            "हिन्दी",
+	"uk_UA":            "Українська",
+	"id_ID":            "Bahasa Indonesia",
 }

internal/locale/locale_test.go

@@ -6,7 +6,7 @@ package locale // import "miniflux.app/v2/internal/locale"
 import "testing"
 
 func TestAvailableLanguages(t *testing.T) {
-	results := AvailableLanguages()
+	results := AvailableLanguages
 	for k, v := range results {
 		if k == "" {
 			t.Errorf(`Empty language key detected`)

internal/locale/plural.go

@@ -5,7 +5,7 @@ package locale // import "miniflux.app/v2/internal/locale"
 
 // See https://localization-guide.readthedocs.io/en/latest/l10n/pluralforms.html
 // And http://www.unicode.org/cldr/charts/29/supplemental/language_plural_rules.html
-var pluralForms = map[string](func(n int) int){
+var pluralForms = map[string]func(n int) int{
 	// nplurals=2; plural=(n != 1);
 	"default": func(n int) int {
 		if n != 1 {
@@ -88,6 +88,9 @@ var pluralForms = map[string](func(n int) int){
 	"zh_TW": func(n int) int {
 		return 0
 	},
+	"nan_Latn_pehoeji": func(n int) int {
+		return 0
+	},
 }
 
 // nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);

internal/locale/plural_test.go

@@ -77,6 +77,10 @@ func TestPluralRules(t *testing.T) {
 			1: 0,
 			5: 0,
 		},
+		"nan_Latn_pehoeji": {
+			1: 0,
+			5: 0,
+		},
 	}
 
 	for rule, values := range scenarios {

internal/locale/printer.go

@@ -11,9 +11,11 @@ type Printer struct {
 }
 
 func (p *Printer) Print(key string) string {
-	if str, ok := defaultCatalog[p.language][key]; ok {
-		if translation, ok := str.(string); ok {
-			return translation
+	if dict, err := GetTranslationDict(p.language); err == nil {
+		if str, ok := dict[key]; ok {
+			if translation, ok := str.(string); ok {
+				return translation
+			}
 		}
 	}
 	return key
@@ -21,16 +23,16 @@ func (p *Printer) Print(key string) string {
 
 // Printf is like fmt.Printf, but using language-specific formatting.
 func (p *Printer) Printf(key string, args ...interface{}) string {
-	var translation string
+	translation := key
 
-	str, found := defaultCatalog[p.language][key]
-	if !found {
-		translation = key
-	} else {
-		var valid bool
-		translation, valid = str.(string)
-		if !valid {
-			translation = key
+	if dict, err := GetTranslationDict(p.language); err == nil {
+		str, found := dict[key]
+		if found {
+			var valid bool
+			translation, valid = str.(string)
+			if !valid {
+				translation = key
+			}
 		}
 	}
 
@@ -39,9 +41,12 @@ func (p *Printer) Printf(key string, args ...interface{}) string {
 
 // Plural returns the translation of the given key by using the language plural form.
 func (p *Printer) Plural(key string, n int, args ...interface{}) string {
-	choices, found := defaultCatalog[p.language][key]
+	dict, err := GetTranslationDict(p.language)
+	if err != nil {
+		return key
+	}
 
-	if found {
+	if choices, found := dict[key]; found {
 		var plurals []string
 
 		switch v := choices.(type) {

internal/locale/translations/nan_Latn_pehoeji.json

@@ -0,0 +1,587 @@
+{
+    "action.cancel": "Chhú-siau",
+    "action.download": "Lia̍h----loh-lâi",
+    "action.edit": "Pian-chi̍p",
+    "action.home_screen": "Chng tī chú ōe-bīn",
+    "action.import": "Hōe--li̍p",
+    "action.login": "Teng-lo̍k",
+    "action.or": "ah-sī",
+    "action.remove": "Thâi tiāu",
+    "action.remove_feed": "Thâi tiāu chit ê siau-sit lâi-goân",
+    "action.save": "Pó-chûn",
+    "action.subscribe": "Tēng",
+    "action.update": "Ōaⁿ-sin",
+    "alert.account_linked": "Í-keng kah lí ê gōa-pō͘ kháu-chō kiat chòe-hé--ah!",
+    "alert.account_unlinked": "Kah lí ê gōa-pō͘ kháu-chō ê kiat í-keng phah khui--ah!",
+    "alert.background_feed_refresh": "Tng leh pōe-āu ōaⁿ-sin só͘-ū siau-sit lâi-goân, lí ē-sái kè-sio̍k sú-iōng Miniflux。",
+    "alert.feed_error": "Chit ê siau-sit lâi-goân ū būn-tôe",
+    "alert.no_bookmark": "Chit-má ah bô siu-chông",
+    "alert.no_category": "Chit-má ah bô lūi-pia̍t",
+    "alert.no_category_entry": "Chit ê lūi-pah ah bô siau-sit",
+    "alert.no_feed": "Chit-má ah bô siau-sit lâi-goân",
+    "alert.no_feed_entry": "Chit ê siau-sit lâi-goân lāi bô siau-sit",
+    "alert.no_feed_in_category": "Bô chit ê lūi-pia̍t ê siau-sit lâi-goân",
+    "alert.no_history": "Chit-má ah bô kì-lo̍k",
+    "alert.no_search_result": "Bô hû-ha̍p ê chhiau-chhē kiat-kó",
+    "alert.no_shared_entry": "Chit-má ah bô hun-hióng ê siau-sit",
+    "alert.no_tag_entry": "Bô kah chit ê khan-á ū hû-ha̍p ê siau-sit",
+    "alert.no_unread_entry": "Chit-má ah-bô tha̍k kè ê siau-sit",
+    "alert.no_user": "Lí sī ûi-it ê sú-iōng-lâng",
+    "alert.pocket_linked": "Í-keng kā lí ê Pocket kháu-chō kiat chòe-hé--ah!",
+    "alert.prefs_saved": "Siat-tēng í-keng pó-chûn--ah!",
+    "alert.too_many_feeds_refresh": [
+        "Lí í-keng ín-khí siuⁿ chōe pái siau-sit lâi-goân ōaⁿ-sin, chhiáⁿ tán-hāu %d hun-cheng āu koh chhì-khòaⁿ-māi."
+    ],
+    "confirm.loading": "Tng leh chip-hêng…",
+    "confirm.no": "Hóⁿ",
+    "confirm.question": "Kám ū khak-tēng?",
+    "confirm.question.refresh": "Kám beh kiông-chè têng lia̍h?",
+    "confirm.yes": "Sī",
+    "enclosure_media_controls.seek": "sóa-ūi:",
+    "enclosure_media_controls.seek.title": "sóa %s bió",
+    "enclosure_media_controls.speed": "Sok-tō͘",
+    "enclosure_media_controls.speed.faster": "Cheng-ka sok-tō͘",
+    "enclosure_media_controls.speed.faster.title": "Cheng-ka sok-tō͘ %sx",
+    "enclosure_media_controls.speed.reset": "Têng siat-tēng",
+    "enclosure_media_controls.speed.reset.title": "Têng siat-tēng pàng ê sok-tō͘ chòe 1x",
+    "enclosure_media_controls.speed.slower": "Pàng bān",
+    "enclosure_media_controls.speed.slower.title": "Pàng bān %sx",
+    "entry.bookmark.toast.off": "Chhú-siau siu-chông chòe soah",
+    "entry.bookmark.toast.on": "Sin cheng-ka siu-chông chòe soah",
+    "entry.bookmark.toggle.off": "Chhú-siau siu-chông",
+    "entry.bookmark.toggle.on": "Siu-chông khí-lâi",
+    "entry.comments.label": "Hôe-èng",
+    "entry.comments.title": "Khòaⁿ hôe-èng",
+    "entry.estimated_reading_time": [
+        "Ài %d hun-cheng lâi tha̍k"
+    ],
+    "entry.external_link.label": "Gōa-pō͘ liân-kiat",
+    "entry.save.completed": "Pó-chûn chò soah",
+    "entry.save.label": "Pó-chûn",
+    "entry.save.title": "Pó-chûn chit ê siau-sit",
+    "entry.save.toast.completed": "Pó-chûn chò soah",
+    "entry.scraper.completed": "Lia̍h soah--ah",
+    "entry.scraper.label": "Lia̍h--lo̍h-lâi",
+    "entry.scraper.title": "Lia̍h goân-tóe lōe-iông",
+    "entry.share.label": "Hun-hióng",
+    "entry.share.title": "Hun-hióng chit ê siau-sit",
+    "entry.shared_entry.label": "Hun-hióng",
+    "entry.shared_entry.title": "Phah khui kong-khai ê liân-kiat",
+    "entry.state.loading": "Tng leh chip-hêng…",
+    "entry.state.saving": "Tng leh pó-chûn…",
+    "entry.status.read": "Chù chòe tha̍k--kè",
+    "entry.status.title": "Kái chōng-thài",
+    "entry.status.toast.read": "Chù chòe tha̍k kè chòe soah",
+    "entry.status.toast.unread": "Chù chòe ah-bōe tha̍k chòe soah",
+    "entry.status.unread": "Chù chòe ah-bōe tha̍k",
+    "entry.tags.label": "Khan-á：",
+    "entry.unshare.label": "Chhú-siau hun-hióng",
+    "error.api_key_already_exists": "Chit ê API só-sî í-keng chûn-chāi",
+    "error.bad_credentials": "M̄-tio̍h ê kháu-chō miâ ah-sī bi̍t-bé.",
+    "error.category_already_exists": "Lūi-pia̍t í-keng chûn-chāi.",
+    "error.category_not_found": "Chit ê lūi-pia̍t bô chûn-chāi ah-sī bô sio̍k-tī lí.",
+    "error.database_error": "Chu-liāu khò͘ ū m̄-tiō: %v.",
+    "error.different_passwords": "Su-li̍p ê bi̍t-bé chit nn̄g pái bô kâng.",
+    "error.duplicate_fever_username": "Fever ê kháu-chō miâ í-keng hō͘ lâng iōng khì--ah!",
+    "error.duplicate_googlereader_username": "Google Reader ê kháu-chō miâ í-keng hō͘ lâng iōng khì--ah!",
+    "error.duplicate_linked_account": "Chit ê beh kiat chòe-hé--ê í-keng seng hō͘ lâng kiat khì--ah!",
+    "error.duplicated_feed": "Chit ê siau-sit lâi-goân í-keng chûn-chāi.",
+    "error.empty_file": "Chit ê tóng-àn sī khang--ê.",
+    "error.entries_per_page_invalid": "Ta̍k ia̍h ê siau-sit sò͘ ū būn-tôe.",
+    "error.feed_already_exists": "Chit ê siau-sit lâi-goân í-keng chûn-chāi.",
+    "error.feed_category_not_found": "Bô chit ê lūi-pia̍t ah-sī kóng bô sio̍k-tī chit ê sú-iōng-lâng.",
+    "error.feed_format_not_detected": "Bōe līn chit ê siau-sit lâi-goân ê keh-sek: %v.",
+    "error.feed_invalid_blocklist_rule": "Hong-só kui-chek bô-hāu.",
+    "error.feed_invalid_keeplist_rule": "Pó-liû kui-chek bô-hāu.",
+    "error.feed_mandatory_fields": "Tio̍h-ài su-lip bāng-chí kah lūi-pia̍t.",
+    "error.feed_not_found": "Chhē bô chit ê siau-sit lâi-goân ah-sī bô sio̍k-tī lí",
+    "error.feed_title_not_empty": "Beh tēng ê siau-sit lâi-goân ê piau-tôe bōe-sái sī khang--ê.",
+    "error.feed_url_not_empty": "Beh tēng ê siau-sit lâi-goân bāng-chí bōe-sái sī khang--ê.",
+    "error.fields_mandatory": "Tio̍h-ài kā chu-liāu lóng siá chê.",
+    "error.http_bad_gateway": "Chit ê bāng-chām chit-má in-ūi gateway ū būn-tôe bô-hoat-tō͘ iōng, m̄ sī Miniflux chia ê būn-tôe, chhiáⁿ tán--chi̍t-ē chiah koh chhì-khòaⁿ-māi.",
+    "error.http_body_read": "Bô-hoat-tō͘ tha̍k HTTP body lōe-iông: %v。",
+    "error.http_client_error": "HTTP kheh-hō͘ thâu ū m̄-tio̍h: %v.",
+    "error.http_empty_response": "HTTP hôe-èng lōe-iông sī khang--ê, ū khó-lêng sī hit ê bāng-chām ū pó-hō͘ ki-chè.",
+    "error.http_empty_response_body": "HTTP hôe-èng body sī khang--ê.",
+    "error.http_forbidden": "Hō͘ kū-choa̍t chûn-chhú chit ê bāng-chām, ū khó-lêng chit ê bāng-chām ū pó-hō͘ ki-chè.",
+    "error.http_gateway_timeout": "Tán chit ê bāng-chām ê hôe-èng í-keng chhiau-kè sî-kan, m̄ sī Miniflux chia ê būn-tôe, chhiáⁿ tán--chi̍t-ē chiah koh chhì-khòaⁿ-māi.",
+    "error.http_internal_server_error": "Chit ê bāng-chām ê su-hāu-khì in ka-kī ū būn-tôe, m̄ sī Miniflux chia ê būn-tôe, chhiáⁿ tán--chi̍t-ē chiah koh chhì-khòaⁿ-māi.",
+    "error.http_not_authorized": "Bô khoân chûn-chhú chit ê bāng-chām, chhiáⁿ kiám-cha kháu-chō miâ kah bi̍t-bé。",
+    "error.http_resource_not_found": "Chhē bô chit ê liân-kiat, chhiáⁿ khak-līn bāng-chí kám ū chèng-khak.",
+    "error.http_response_too_large": "HTTP hôe-èng siuⁿ tōa. Lí ē-sái tī choân-he̍k siat-tēng lāi kā siōng koân hān-tō͘ kái khah koân (ài têng khui su-hāu-khì)。",
+    "error.http_service_unavailable": "Chit ê bāng-chām in-ūi in ka-kī lāi-pō͘ ū būn-tôe，m̄ sī Miniflux chia ê būn-tôe, chhiáⁿ tán--chi̍t-ē chiah koh chhì-khòaⁿ-māi.",
+    "error.http_too_many_requests": "Miniflux tùi chit ê bāng-chām ê chhéng-kiû siuⁿ kè chōe, chhiáⁿ têng chhì-khòaⁿ-māi ah-sī tiâu-chéng thêng-sek siat-tēng.",
+    "error.http_unexpected_status_code": "Chit ê bāng-chām chòe liáu chi̍t ê liāu-bōe-tio̍h ê HTTP chōng-thài bé: %d, chhiáⁿ tán--chi̍t-ē chiah koh chhì-khòaⁿ-māi.",
+    "error.invalid_default_home_page": "Ū-siat chú-ia̍h ū būn-tôe!",
+    "error.invalid_display_mode": "Ū būn-tôe ê su-li̍p bô͘-sek.",
+    "error.invalid_entry_direction": "Ū būn-tôe ê su-li̍p hong-hiòng.",
+    "error.invalid_feed_url": "Beh tēng ê siau-sit lâi-goân ê bāng-chí ū būn-tôe.",
+    "error.invalid_gesture_nav": "Chhiú-sè tō-lám ū būn-tôe.",
+    "error.invalid_language": "Ū būn-tôe ê gú-giân.",
+    "error.invalid_site_url": "Siau-sit lâi-goân ê bāng-chām ê bāng-chí ū būn-tôe.",
+    "error.invalid_theme": "Ū būn-tôe ê chú-tôe.",
+    "error.invalid_timezone": "Ū būn-tôe ê sî-khu.",
+    "error.network_operation": "Miniflux bô-hoat-tō͘ liân kàu chit ê bāng-chām, ū khó-lêng sī bāng-lō͘ būn-tôe: %v.",
+    "error.network_timeout": "Chit ê bāng-chām ê hôe-èng siuⁿ bān, chhéng-kiû chhiau-kè sî-kan: %v.",
+    "error.password_min_length": "Chhiáⁿ chì-chió ài su-li̍p la̍k ê lī goân.",
+    "error.pocket_access_token": "Bô-hoat-tō͘ ùi Pocket thê tio̍h access token",
+    "error.pocket_request_token": "Bô-hoat-tō͘ ùi Pocket thê tio̍h request token",
+    "error.settings_block_rule_fieldname_invalid": "Bô-hāu ê hong-só kui-chek: kui-chek #%d khiàm ū-hāu ê lân-ūi miâ (e-sai ê soán-hāng: %s)",
+    "error.settings_block_rule_invalid_regex": "Bô-hāu ê hong-só kui-chek: kui-chek #%d ê bô͘-sek m̄ sī ha̍p-hoat ê chiàⁿ-kui piáu-ta̍t sek",
+    "error.settings_block_rule_regex_required": "Bô-hāu ê hong-só kui-chek: kui-chek #%d bô thê-kiong chiàⁿ-kui piáu-ta̍t sek",
+    "error.settings_block_rule_separator_required": "Bô-hāu ê hong-só kui-chek: kui-chek #%d ê bô͘-sek tio̍h-ài iōng '=' keh khui.",
+    "error.settings_invalid_domain_list": "Bāng-he̍k chheng-toaⁿ ū būn-tôe, chhiáⁿ iōng khang-keh keh khui bô kâng ê bāng-he̍k.",
+    "error.settings_keep_rule_fieldname_invalid": "Bô-hāu ê pó-liû kui-chek: kui-chek #%d khiàm ū-hāu ê lân-ūi miâ (e-sai ê soán-hāng: %s)",
+    "error.settings_keep_rule_invalid_regex": "Bô-hāu ê pó-liû kui-chek: kui-chek #%d d ê bô͘-sek m̄ sī ha̍p-hoat ê chiàⁿ-kui piáu-ta̍t sek",
+    "error.settings_keep_rule_regex_required": "Bô-hāu ê pó-liû kui-chek: kui-chek #%d bô thê-kiong chiàⁿ-kui piáu-ta̍t sek",
+    "error.settings_keep_rule_separator_required": "Bô-hāu ê pó-liû kui-chek: kui-chek #%d ê bô͘-sek tio̍h-ài iōng '=' keh khui.",
+    "error.settings_mandatory_fields": "Tio̍h-ài su-li̍p kháu-chō miâ, chú-tôe, gú-giân, sî-khu.",
+    "error.settings_media_playback_rate_range": "Pàng ê sok-tō͘ chhiau-kè hoān-ûi",
+    "error.settings_reading_speed_is_positive": "Tha̍k ê sok-tō͘ tio̍h-ài sī chiaⁿ chéng-sò͘",
+    "error.site_url_not_empty": "Siau-sit lâi-goân ê bāng-chām ê bāng-chí bōe-sái sī khang--ê.",
+    "error.subscription_not_found": "Chhē bōe tio̍h līm-hô tēng ê siau-sit lâi-goân",
+    "error.title_required": "Tio̍h-ài su-li̍p piau-tôe.",
+    "error.tls_error": "TLS m̄-tio̍h: %q。Nā-sī beh pàng-ba̍k TSL chèng-bêng, ē-sái tī siau-sit lâi-goân siat-tēng lāi thêng-tiong.",
+    "error.unable_to_create_api_key": "Bô-hoat-tō͘ sin cheng-ka chit ê  API só-sî.",
+    "error.unable_to_create_category": "Bô-hoat-tō͘ sin cheng-ka chit ê lūi-pia̍t",
+    "error.unable_to_create_user": "Bô-hoat-tō͘ sin cheng-ka chit ê sú-iōng-lâng",
+    "error.unable_to_detect_rssbridge": "Sú-iōng RSS-Bridge sî chhē bô līm-hô siau-sit lâi-goân: %v.",
+    "error.unable_to_parse_feed": "Bô-hoat-tō͘ kái-sek chit ê siau-sit lâi-goân: %v.",
+    "error.unable_to_update_category": "Bô-hoat-tō͘ ōaⁿ-sin chit ê lūi-pia̍t",
+    "error.unable_to_update_feed": "Bô-hoat-tō͘ ōaⁿ-sin chit ê siau-sit lâi-goân",
+    "error.unable_to_update_user": "Bô-hoat-tō͘ ōaⁿ-sin chit ê sú-iōng-lâng",
+    "error.unlink_account_without_password": "Lí it-tēng ài siat-tēng bi̍t-bé, bô lí ē bô-hoat-tō͘ koh teng-lo̍k.",
+    "error.user_already_exists": "Chit ê sú-iōng-lâng í-keng chûn-chāi.",
+    "error.user_mandatory_fields": "Tio̍h-ài su-li̍p kháu-chō miâ",
+    "form.api_key.label.description": "API só-sîkhan-á",
+    "form.category.hide_globally": "Mài hián-sī siau-sit tī choân-he̍k ah-bōe tha̍k lia̍t-pió lāi",
+    "form.category.label.title": "Piau-tôe",
+    "form.feed.fieldset.general": "Thong-iōng",
+    "form.feed.fieldset.integration": "Tē-saⁿ hong ho̍k-bū",
+    "form.feed.fieldset.network_settings": "Bāng-lō͘ siat-tēng",
+    "form.feed.fieldset.rules": "Kui-chek",
+    "form.feed.label.allow_self_signed_certificates": "ún-chún chū chhiam ah-sī bô-hāu ê pîn-chèng",
+    "form.feed.label.apprise_service_urls": "Sú-iōng tō͘-tiám keh khui ê Apprise ho̍k-bū bāng-chí lia̍t-pió",
+    "form.feed.label.blocklist_rules": "Hong-só kui-chek",
+    "form.feed.label.category": "lūi-pia̍t",
+    "form.feed.label.cookie": "Siat-tēng Cookies",
+    "form.feed.label.crawler": "Lia̍h goân-tóe lōe-iông",
+    "form.feed.label.description": "Biâu-su̍t",
+    "form.feed.label.disable_http2": "Thêng iōng HTTP/2 pī-bián chéng-thâu-á-hûn tui-chong",
+    "form.feed.label.disabled": "Mài tha̍k chit ê siau-sit lâi-goân ê sin siau-sit",
+    "form.feed.label.feed_password": "Siau-sit lâi-goân bi̍t-bé",
+    "form.feed.label.feed_url": "Siau-sit lâi-goân bāng-chí",
+    "form.feed.label.feed_username": "Siau-sit lâi-goân kháu-chō miâ",
+    "form.feed.label.fetch_via_proxy": "Thàu-kè tāi-lí lia̍h",
+    "form.feed.label.hide_globally": "Tī choân-he̍k ah-bōe tha̍k--ê lia̍t-pió am-khàm siau-sit",
+    "form.feed.label.ignore_http_cache": "Pàng-ba̍k HTTP cache",
+    "form.feed.label.keeplist_rules": "Pó-liû kui-chek",
+    "form.feed.label.no_media_player": "Bô mûi-thé hòng-sàng khì (im-sìn, sī-sìn)",
+    "form.feed.label.ntfy_activate": "Thui-sàng siau-sit khì ntfy",
+    "form.feed.label.ntfy_default_priority": "Ntfy ū-siat iu-sian sūn-sū",
+    "form.feed.label.ntfy_high_priority": "Ntfy koân iu-sian sūn-sū",
+    "form.feed.label.ntfy_low_priority": "Ntfy kē iu-sian sūn-sū",
+    "form.feed.label.ntfy_max_priority": "Ntfy siōng koân iu-sian sūn-sū",
+    "form.feed.label.ntfy_min_priority": "Ntfy siōng kē iu-sian sūn-sū",
+    "form.feed.label.ntfy_priority": "Ntfy iu-sian sūn-sū",
+    "form.feed.label.pushover_activate": "Push entries to Pushover",
+    "form.feed.label.pushover_default_priority": "Default priority",
+    "form.feed.label.pushover_high_priority": "High priority",
+    "form.feed.label.pushover_low_priority": "Low priority",
+    "form.feed.label.pushover_max_priority": "Max priority",
+    "form.feed.label.pushover_min_priority": "Minimal priority",
+    "form.feed.label.pushover_priority": "Pushover message priority",
+    "form.feed.label.rewrite_rules": "Têng siá kui-chek",
+    "form.feed.label.scraper_rules": "Lia̍h ê kui-chek",
+    "form.feed.label.site_url": "Bāng-chām bāng-chí",
+    "form.feed.label.title": "Piau-tôe",
+    "form.feed.label.urlrewrite_rules": "Bāng-chí têng siá kui-chek",
+    "form.feed.label.user_agent": "Ngī kái sú-iōng-lâng tāi-lí",
+    "form.feed.label.webhook_url": "Ngī kái webhook bāng-chí",
+    "form.import.label.file": "OPML tóng-àn",
+    "form.import.label.url": "URL",
+    "form.integration.apprise_activate": "Thui sàng siau-sit khì Apprise",
+    "form.integration.apprise_services_url": "Iōng tō͘-tiám keh khui ê Apprise ho̍k-bū bāng-chí lia̍t-pió",
+    "form.integration.apprise_url": "Apprise API bāng-chí",
+    "form.integration.betula_activate": "Pó-chûn siau-sit kàu Betula",
+    "form.integration.betula_token": "Betula Token",
+    "form.integration.betula_url": "Betula su-hāu-khì bāng-chí",
+    "form.integration.cubox_activate": "Pó-chûn siau-sit khì Cubox",
+    "form.integration.cubox_api_link": "Cubox API liân-kiat",
+    "form.integration.discord_activate": "Thui-sàng siau-sit kàu Discord",
+    "form.integration.discord_webhook_link": "Discord Webhook liân-kiat",
+    "form.integration.espial_activate": "Pó-chûn siau-sit kàu Espial",
+    "form.integration.espial_api_key": "Espial API só-sî",
+    "form.integration.espial_endpoint": "Espial API thâu",
+    "form.integration.espial_tags": "Espial khan-á",
+    "form.integration.fever_activate": "Khai-sí iōng Fever API",
+    "form.integration.fever_endpoint": "Fever API thâu",
+    "form.integration.fever_password": "Fever bi̍t-bé",
+    "form.integration.fever_username": "Fever kháu-chō miâ",
+    "form.integration.googlereader_activate": "Khai-sí iōng Google Reader API",
+    "form.integration.googlereader_endpoint": "Google Reader API thâu：",
+    "form.integration.googlereader_password": "Google Reader bi̍t-bé",
+    "form.integration.googlereader_username": "Google Reader Kháu-chō miâ",
+    "form.integration.instapaper_activate": "Pó-chûn siau-sit kàu Instapaper",
+    "form.integration.instapaper_password": "Instapaper bi̍t-bé",
+    "form.integration.instapaper_username": "Instapaper Kháu-chō miâ",
+    "form.integration.linkace_activate": "Pó-chûn siau-sit kàu LinkAce",
+    "form.integration.linkace_api_key": "LinkAce API só-sî",
+    "form.integration.linkace_check_disabled": "Thêng iōng liân-kiat kiám-cha",
+    "form.integration.linkace_endpoint": "LinkAce API thâu",
+    "form.integration.linkace_is_private": "Chù chòe su-lîn ê liân-kiat",
+    "form.integration.linkace_tags": "LinkAce khan-á",
+    "form.integration.linkding_activate": "Pó-chûn siau-sit kàu Linkding",
+    "form.integration.linkding_api_key": "Linkding API só-sî",
+    "form.integration.linkding_bookmark": "Chù chòe ah-bōe tha̍k",
+    "form.integration.linkding_endpoint": "Linkding API thâu",
+    "form.integration.linkding_tags": "Linkding khan-á",
+    "form.integration.linkwarden_activate": "Pó-chûn siau-sit kàu Linkwarden",
+    "form.integration.linkwarden_api_key": "Linkwarden API só-sî",
+    "form.integration.linkwarden_endpoint": "Linkwarden API thâu",
+    "form.integration.matrix_bot_activate": "Thui-sàng siau-sit kàu Matrix",
+    "form.integration.matrix_bot_chat_id": "Matrix pâng-keng ID",
+    "form.integration.matrix_bot_password": "Matrix bi̍t-bé",
+    "form.integration.matrix_bot_url": "Matrix su-hāu-khìbāng-chí",
+    "form.integration.matrix_bot_user": "Matrix kháu-chō miâ",
+    "form.integration.notion_activate": "Pó-chûn siau-sit kàu Notion",
+    "form.integration.notion_page_id": "Notion Page ID",
+    "form.integration.notion_token": "Notion Secret Token",
+    "form.integration.ntfy_activate": "Thui-sàng siau-sit kàu Ntfy",
+    "form.integration.ntfy_api_token": "Ntfy API só-sî (soán thiⁿ)",
+    "form.integration.ntfy_icon_url": "Ntfy Icon bāng-chí (soán thiⁿ)",
+    "form.integration.ntfy_internal_links": "Tiám ê sî-chūn iōng lāi-pō͘ liân-kiat (soán thiⁿ)",
+    "form.integration.ntfy_password": "Ntfy bi̍t-bé (soán thiⁿ)",
+    "form.integration.ntfy_topic": "Ntfy topic",
+    "form.integration.ntfy_url": "Ntfy bāng-chí (soán thiⁿ, ū-siat sī ntfy.sh)",
+    "form.integration.ntfy_username": "Ntfy kháu-chō miâ (soán thiⁿ)",
+    "form.integration.nunux_keeper_activate": "Pó-chûn siau-sit kàu Nunux Keeper",
+    "form.integration.nunux_keeper_api_key": "Nunux Keeper API só-sî",
+    "form.integration.nunux_keeper_endpoint": "Nunux Keeper API thâu",
+    "form.integration.omnivore_activate": "Pó-chûn siau-sit kàu Omnivore",
+    "form.integration.omnivore_api_key": "Omnivore API só-sî",
+    "form.integration.omnivore_url": "Omnivore API thâu",
+    "form.integration.pinboard_activate": "Pó-chûn siau-sit kàu Pinboard",
+    "form.integration.pinboard_bookmark": "Chù chòe ah-bōe tha̍k",
+    "form.integration.pinboard_tags": "Pinboard khan-á",
+    "form.integration.pinboard_token": "Pinboard API Token",
+    "form.integration.pocket_access_token": "Pocket token",
+    "form.integration.pocket_activate": "Pó-chûn siau-sit kàu Pocket",
+    "form.integration.pocket_connect_link": "Kah Pocket kháu-chō kiat chòe-hé",
+    "form.integration.pocket_consumer_key": "Pocket sú-iōng-lâng só-sî",
+    "form.integration.pushover_activate": "Push entries to Pushover",
+    "form.integration.pushover_device": "Pushover device (optional)",
+    "form.integration.pushover_prefix": "Pushover URL prefix (optional)",
+    "form.integration.pushover_token": "Pushover application API token",
+    "form.integration.pushover_user": "Pushover user key",
+    "form.integration.raindrop_activate": "Pó-chûn siau-sit kàu Raindrop",
+    "form.integration.raindrop_collection_id": "Collection ID",
+    "form.integration.raindrop_tags": "khan-á (iōng tō͘-tiám keh khui)",
+    "form.integration.raindrop_token": "Raindrop Acess Token",
+    "form.integration.readeck_activate": "Pó-chûn siau-sit kàu Readeck",
+    "form.integration.readeck_api_key": "Readeck API só-sî",
+    "form.integration.readeck_endpoint": "Readeck API thâu",
+    "form.integration.readeck_labels": "Readeck Labels",
+    "form.integration.readeck_only_url": "Kan-na thoân bāng-chí (m̄ sī oân-chéng ê lōe-iông)",
+    "form.integration.readwise_activate": "Pó-chûn siau-sit kàu Readwise Reader",
+    "form.integration.readwise_api_key": "Readwise Reader Acess Token",
+    "form.integration.readwise_api_key_link": "Chhú-tek lí ê Readwise Acess Token",
+    "form.integration.rssbridge_activate": "Sin cheng-ka siau-sit lâi-goân ê sî tio̍h RSS-Bridge",
+    "form.integration.rssbridge_url": "RSS-Bridge su-hāu-khì的bāng-chí",
+    "form.integration.shaarli_activate": "Pó-chûn siau-sit kàu Shaarli",
+    "form.integration.shaarli_api_secret": "Shaarli API só-sî",
+    "form.integration.shaarli_endpoint": "Shaarli bāng-chí",
+    "form.integration.shiori_activate": "Pó-chûn siau-sit kàu Shiori",
+    "form.integration.shiori_endpoint": "Shiori API thâu",
+    "form.integration.shiori_password": "Shiori bi̍t-bé",
+    "form.integration.shiori_username": "Shiori kháu-chō miâ",
+    "form.integration.slack_activate": "Thui-sàng siau-sit kàu Slack",
+    "form.integration.slack_webhook_link": "Slack Webhook liân-kiat",
+    "form.integration.telegram_bot_activate": "Thui-sàng siau-sit kàu Telegram",
+    "form.integration.telegram_bot_disable_buttons": "Mài hián-sī khai-koan",
+    "form.integration.telegram_bot_disable_notification": "Têng iōng thong-ti",
+    "form.integration.telegram_bot_disable_web_page_preview": "Thêng iōng bāng-ia̍h ū-lám",
+    "form.integration.telegram_bot_token": "Bot Token",
+    "form.integration.telegram_chat_id": "Chat ID",
+    "form.integration.telegram_topic_id": "Topic ID",
+    "form.integration.wallabag_activate": "Pó-chûn siau-sit kàu Wallabag",
+    "form.integration.wallabag_client_id": "Wallabag kheh-hō͘ thâu ID",
+    "form.integration.wallabag_client_secret": "Wallabag kheh-hō͘ thâu só-sî",
+    "form.integration.wallabag_endpoint": "Wallabag Base URL",
+    "form.integration.wallabag_only_url": "Kan-na thoân bāng-chí (m̄ sī oân-chéng ê lōe-iông)",
+    "form.integration.wallabag_password": "Wallabag bi̍t-bé",
+    "form.integration.wallabag_username": "Wallabag kháu-chō miâ",
+    "form.integration.webhook_activate": "Khai-sí iōng Webhooks",
+    "form.integration.webhook_secret": "Webhooks Secret",
+    "form.integration.webhook_url": "Default Webhook bāng-chí",
+    "form.prefs.fieldset.application_settings": "Èng-iōng thêng-sek siat-tēng",
+    "form.prefs.fieldset.authentication_settings": "Sú-iōng-lâng giām-chèng siat-tēng",
+    "form.prefs.fieldset.global_feed_settings": "Choân-he̍k siau-sit lâi-goân siat-tēng",
+    "form.prefs.fieldset.reader_settings": "Ia̍t-tha̍k khì siat-tēng",
+    "form.prefs.help.external_font_hosts": "Iōng khang-keh keh khui ún-chún ê gōa-pō͘ lī-hêng lâi-goân. Phì-lû \"fonts.gstatic.com fonts.googleapis.com\"",
+    "form.prefs.label.categories_sorting_order": "Lūi-pia̍t hián-sī sūn-sū",
+    "form.prefs.label.cjk_reading_speed": "Tiong-bûn, Hân-bûn, Li̍t-bûn tha̍k ê sok-tō͘ (múi hun-cheng ē-sái tha̍k kúi ê lī-goân)",
+    "form.prefs.label.custom_css": "Chū tēng ê CSS",
+    "form.prefs.label.custom_js": "Chū tēng ê JavaScript",
+    "form.prefs.label.default_home_page": "Ū-siat chú-ia̍h",
+    "form.prefs.label.default_reading_speed": "Kî-thaⁿ gú-giân tha̍k ê sok-tō͘ (múi hun-cheng ē-sái tha̍k kúi ê lī)",
+    "form.prefs.label.display_mode": "Chiām-chìn sek bāng-lō͘ èng-iōng theng-sek (PWA) ê hián-sī bô͘-sek",
+    "form.prefs.label.entries_per_page": "Ta̍k ia̍h siau-sit sò͘",
+    "form.prefs.label.entry_order": "Siau-sit hián-sī sūn-sū ê i-kù",
+    "form.prefs.label.entry_sorting": "Siau-sit sūn-sū",
+    "form.prefs.label.entry_swipe": "Ē-sái tī chhiok-khòng sek êng-bō͘ ùi siau-sit iōng thoa tāng chhau-chok",
+    "form.prefs.label.external_font_hosts": "Gōa-pō͘ lī-hêng lâi-goân",
+    "form.prefs.label.gesture_nav": "Tī siau-sit kan sóa-ūi ê chhiú-sè",
+    "form.prefs.label.keyboard_shortcuts": "Ē-sái iōng khí-pôaⁿ khoài-sok khí",
+    "form.prefs.label.language": "Gú-giân",
+    "form.prefs.label.mark_read_manually": "Ka-kī chhau-chok kám beh chù chòe tha̍k kè",
+    "form.prefs.label.mark_read_on_media_completion": "Kan-na tī im-sìn, sī-sìn hòng-sàng kàu 90%% ê si-chun chù chòe tha̍k kè",
+    "form.prefs.label.mark_read_on_view": "Phah khui ê sî-chūn sūn-sòa kā siau-sit chù chòe tha̍k kè",
+    "form.prefs.label.mark_read_on_view_or_media_completion": "Phah khui ê sî-chūn sūn-sòa kā siau-sit chù chòe tha̍k kè, m̄-koh nā-sī im-sìn, sī-sìn tio̍h tī hòng-sàng kàu 90%% ê si-chun chiah lâi chù",
+    "form.prefs.label.media_playback_rate": "Im-sìn, sī-sìn pàng ê sok-tō͘",
+    "form.prefs.label.show_reading_time": "Hián-sī siau-sit àn-sǹg ài gōa-kú lâi tha̍k",
+    "form.prefs.label.theme": "Chú-tôe",
+    "form.prefs.label.timezone": "Sî-khu",
+    "form.prefs.select.alphabetical": "Chiàu lī-bú pâi",
+    "form.prefs.select.browser": "Tī iû-lám khì phah khui",
+    "form.prefs.select.created_time": "Siau-sit kiàn-li̍p sî-kan",
+    "form.prefs.select.fullscreen": "Choân êng-bō͘",
+    "form.prefs.select.minimal_ui": "Siōng iông-chhun--ê",
+    "form.prefs.select.none": "Bô",
+    "form.prefs.select.older_first": "Ùi kū--ê khai-sí pâi",
+    "form.prefs.select.publish_time": "Siau-sit hoat-pò͘ sî-kan",
+    "form.prefs.select.recent_first": "Ùi sin--ê khai-sí pâi",
+    "form.prefs.select.standalone": "To̍k-li̍p--ê",
+    "form.prefs.select.swipe": "Iōng thoa--ê",
+    "form.prefs.select.tap": "Tiám nn̄g pái",
+    "form.prefs.select.unread_count": "Ah-bōe tha̍k ê sò͘-liōng",
+    "form.submit.loading": "Tng leh chip-hêng…",
+    "form.submit.saving": "Tng leh pó-chûn…",
+    "form.user.label.admin": "Koán-lí-lâng",
+    "form.user.label.confirmation": "Koh su-li̍p chi̍t pái bi̍t-bé",
+    "form.user.label.password": "Bi̍t-bé",
+    "form.user.label.username": "Kháu-chō miâ",
+    "menu.about": "Iú-koan",
+    "menu.add_feed": "Sin cheng-ka siau-sit lâi-goân",
+    "menu.add_user": "Sin cheng-ka sú-iōng-lâng",
+    "menu.api_keys": "API só-sî",
+    "menu.categories": "Lūi-pia̍t",
+    "menu.create_api_key": "Sin cheng-ka chi̍t ê API só-sî",
+    "menu.create_category": "Sin cheng-ka lūi-pia̍t",
+    "menu.edit_category": "Pian-chi̍p",
+    "menu.edit_feed": "Pian-chi̍p",
+    "menu.export": "Hōe--chhut",
+    "menu.feed_entries": "Bûn-chiong",
+    "menu.feeds": "Siau-sit lâi-goân",
+    "menu.flush_history": "Hìⁿ-sak kì-lo̍k",
+    "menu.history": "Kì-lo̍k",
+    "menu.home_page": "Siú ia̍h",
+    "menu.import": "Hōe--li̍p",
+    "menu.integrations": "Chéng-ha̍p",
+    "menu.logout": "Teng-chhut",
+    "menu.mark_all_as_read": "Choân-pō͘ chù chòe tha̍k kè",
+    "menu.mark_page_as_read": "Kā chit ia̍h--ê lóng chù chòe tha̍k kè",
+    "menu.preferences": "Siat-tēng",
+    "menu.refresh_all_feeds": "Tī pōe-āu têng lia̍h só͘-ū ê siau-sit lâi-goân",
+    "menu.refresh_feed": "Têng lia̍h",
+    "menu.search": "Chhiau-chhē",
+    "menu.sessions": "Ū teng-lo̍k--ê",
+    "menu.settings": "Siat-tēng",
+    "menu.shared_entries": "Hun-hióng kè ê siau-sit",
+    "menu.show_all_entries": "Hián-sī só͘-ū ê siau-sit",
+    "menu.show_only_starred_entries": "Kan-na hián-sī siu-chông ê siau-sit",
+    "menu.show_only_unread_entries": "Kan-na hián-sī ah-bōe tha̍k kè ê siau-sit",
+    "menu.starred": "Siu-chông",
+    "menu.title": "Tō-lám",
+    "menu.unread": "Ah-bōe tha̍k",
+    "menu.users": "Sú-iōng-lâng",
+    "page.about.author": "Chok-chiá: ",
+    "page.about.build_date": "Kiàn-tì li̍t-kî:",
+    "page.about.credits": "Pán-koân",
+    "page.about.global_config_options": "Choân-he̍k siat-tēng soán-hāng",
+    "page.about.go_version": "Go pán-pún:",
+    "page.about.license": "Pàng-koân:",
+    "page.about.postgres_version": "Postgres pán-pún:",
+    "page.about.title": "Iú-koan",
+    "page.about.version": "Pán-pún:",
+    "page.add_feed.choose_feed": "Soán-te̍k chi̍t ê Siau-sit lâi-goân",
+    "page.add_feed.label.url": "Bāng-chí",
+    "page.add_feed.legend.advanced_options": "Chìn-kai soán-hāng",
+    "page.add_feed.no_category": "Ah bô lūi-pia̍t, chì-chió ài ū chi̍t ê",
+    "page.add_feed.submit": "Chhē Siau-sit lâi-goân",
+    "page.add_feed.title": "Sin cheng-ka Siau-sit lâi-goân",
+    "page.api_keys.never_used": "Bô iōng kè",
+    "page.api_keys.table.actions": "Chhau-chok",
+    "page.api_keys.table.created_at": "Kiàn-tì li̍t-kî",
+    "page.api_keys.table.description": "Biâu-su̍t",
+    "page.api_keys.table.last_used_at": "Siōng-bóe pái sú-iōng",
+    "page.api_keys.table.token": "Só-sî",
+    "page.api_keys.title": "API só-sî",
+    "page.categories_count": [
+        "%d ê lūi-pia̍t"
+    ],
+    "page.categories.entries": "Siau-sit",
+    "page.categories.feed_count": [
+        "Ū %d ê Siau-sit lâi-goân"
+    ],
+    "page.categories.feeds": "Siau-sit lâi-goân",
+    "page.categories.no_feed": "Ah-bô siau-sit lâi-goân",
+    "page.categories.title": "Lūi-pia̍t",
+    "page.category_label": "Lūi-pia̍t: %s",
+    "page.edit_category.title": "Pian-chi̍p lūi-pia̍t: %s",
+    "page.edit_feed.etag_header": "ETag piau-thâu:",
+    "page.edit_feed.last_check": "Siōng-bóe pái kiám-cha sî-kan",
+    "page.edit_feed.last_modified_header": "Siōng-bóe pái siu-kái piau-thâu:",
+    "page.edit_feed.last_parsing_error": "Siōng-bóe pái kái-sek m̄-tio̍h",
+    "page.edit_feed.no_header": "Bô",
+    "page.edit_feed.title": "Pian-chi̍p Siau-sit lâi-goân: %s",
+    "page.edit_user.title": "pian-chi̍p sú-iōng-lâng: %s",
+    "page.entry.attachments": "Hù-kiāⁿ",
+    "page.feeds.error_count": [
+        "%d ê m̄-tio̍h"
+    ],
+    "page.feeds.last_check": "Siōng-bóe kiám-cha sî-kan:",
+    "page.feeds.next_check": "Āu-pái kiám-cha sî-kan:",
+    "page.feeds.read_counter": "Tha̍k kè--ê siau-sit sò͘",
+    "page.feeds.title": "Siau-sit lâi-goân",
+    "page.history.title": "Kì-lo̍k",
+    "page.import.title": "Hōe-li̍p",
+    "page.integration.bookmarklet": "Chheh-chhiam ke-si",
+    "page.integration.bookmarklet.help": "Lí ē-sái iōng chit ê te̍k-pia̍t ê chheh-chhiam ti̍t-chiap tēng bāng-ia̍h ê siau-sit",
+    "page.integration.bookmarklet.instructions": "Kā chit ê liân-kiat thoa khì iû-lám khì ê chheh-chhiam lân",
+    "page.integration.bookmarklet.name": "Siu-chông Miniflux",
+    "page.integration.miniflux_api": "Miniflux API",
+    "page.integration.miniflux_api_endpoint": "API thâu",
+    "page.integration.miniflux_api_password": "Bi̍t-bé",
+    "page.integration.miniflux_api_password_value": "Lí ê kháu-chō ê bi̍t-bé",
+    "page.integration.miniflux_api_username": "Kháu-chō miâ",
+    "page.integrations.title": "Chéng-ha̍p",
+    "page.keyboard_shortcuts.close_modal": "Kìm tiāu tùi-ōe thang",
+    "page.keyboard_shortcuts.download_content": "Liah goân-tóe ê siau-sit lōe-iông",
+    "page.keyboard_shortcuts.go_to_bottom_item": "Sóa khì thōng ē-kha ê siau-sit",
+    "page.keyboard_shortcuts.go_to_categories": "Phah khui lūi-pia̍t ia̍h",
+    "page.keyboard_shortcuts.go_to_feed": "Khì siau-sit lâi-goân",
+    "page.keyboard_shortcuts.go_to_feeds": "Phah khui siau-sit lâi-goân ia̍h",
+    "page.keyboard_shortcuts.go_to_history": "Phah khui kì-lo̍k ia̍h",
+    "page.keyboard_shortcuts.go_to_next_item": "Āu-chi̍t ê siau-sit",
+    "page.keyboard_shortcuts.go_to_next_page": "Āu-chi̍t ia̍h",
+    "page.keyboard_shortcuts.go_to_previous_item": "Téng-chi̍t ê siau-sit",
+    "page.keyboard_shortcuts.go_to_previous_page": "Téng-chi̍t ia̍h",
+    "page.keyboard_shortcuts.go_to_search": "Phah khui chhiau-chhē ia̍h",
+    "page.keyboard_shortcuts.go_to_settings": "Phah khui siat-tēng ia̍h",
+    "page.keyboard_shortcuts.go_to_starred": "Phah khui siu-chông--ê ia̍h",
+    "page.keyboard_shortcuts.go_to_top_item": "Sóa khì thōng téng-koân ê siau-sit",
+    "page.keyboard_shortcuts.go_to_unread": "Phah khui ah-bōe tha̍k--ê ia̍h",
+    "page.keyboard_shortcuts.mark_page_as_read": "Kā chit ia̍h--ê lóng chù chòe tha̍k--kè",
+    "page.keyboard_shortcuts.open_comments": "Phah khui hôe-èng liân-kiat",
+    "page.keyboard_shortcuts.open_comments_same_window": "Tī chit-má ê hun-ia̍h phah khui hôe-èng liân-kiat",
+    "page.keyboard_shortcuts.open_item": "Phah khui soán-te̍k ê siau-sit",
+    "page.keyboard_shortcuts.open_original": "Phah khui siau-sit goân-tóe ê liân-kiat",
+    "page.keyboard_shortcuts.open_original_same_window": "Tī chit-má ê hun-ia̍h phah khui siau-sit goân-tóe ê liân-kiat",
+    "page.keyboard_shortcuts.refresh_all_feeds": "Tī pōe-āu ōaⁿ-sin siau-sit lâi-goân",
+    "page.keyboard_shortcuts.remove_feed": "Thâi tiāu siau-sit lâi-goân",
+    "page.keyboard_shortcuts.save_article": "Pó-chûn siau-sit",
+    "page.keyboard_shortcuts.scroll_item_to_top": "Sóa khì bāng-ia̍h siōng téng-koân",
+    "page.keyboard_shortcuts.show_keyboard_shortcuts": "Hián-sī khoài-sok khí",
+    "page.keyboard_shortcuts.subtitle.actions": "Chhau-chok",
+    "page.keyboard_shortcuts.subtitle.items": "Bûn-chiong tō-lám",
+    "page.keyboard_shortcuts.subtitle.pages": "Ia̍h bīn tō-lám",
+    "page.keyboard_shortcuts.subtitle.sections": "Hun lân tō-lám",
+    "page.keyboard_shortcuts.title": "Khoài-sok khí",
+    "page.keyboard_shortcuts.toggle_bookmark_status": "Chhet-li̍p siu-chông chōng-thài",
+    "page.keyboard_shortcuts.toggle_entry_attachments": "Chhet-li̍p thián khui kah siu-ha̍p siau-sit hù-kiāⁿ ê chōng-thài",
+    "page.keyboard_shortcuts.toggle_read_status_next": "Chhet-li̍p tha̍k--kè, ah-bōe tha̍k ê chōng-thài, koh chiau-tiám tī āu-chi̍t--ê",
+    "page.keyboard_shortcuts.toggle_read_status_prev": "Chhet-li̍p tha̍k--kè, ah-bōe tha̍k ê chōng-thài, koh chiau-tiám tī téng-chi̍t--ê",
+    "page.login.google_signin": "Sú-iōng Google teng-lo̍k",
+    "page.login.oidc_signin": "Sú-iōng %s teng-lo̍k",
+    "page.login.title": "teng-lo̍k",
+    "page.login.webauthn_login": "Sú-iōng bi̍t-bé teng-lo̍k",
+    "page.login.webauthn_login.error": "Bô-hoat-tō͘ iōng bi̍t-bé teng-lo̍k",
+    "page.login.webauthn_login.help": "Sú-iōng an-choân só-sî teng-lo̍k ê sî-chūn, chhiáⁿ su-li̍p kháu-chō miâ. Nā-sī iōng thang chhiau-chhē ê Passkey (discoverable credentials) tio̍h bián.",
+    "page.new_api_key.title": "Sin ê API só-sî",
+    "page.new_category.title": "Sin lūi-pia̍t",
+    "page.new_user.title": "Sin sú-iōng-lâng",
+    "page.offline.message": "Lí í-keng lî-sòaⁿ",
+    "page.offline.refresh_page": "Chhì-khòaⁿ-māi têng tha̍k bāng-ia̍h",
+    "page.offline.title": "Lî-sòaⁿ bô͘-sek",
+    "page.read_entry_count": [
+        "%d ê tha̍k kè ê siau-sit"
+    ],
+    "page.search.title": "Chhiau-chhē kiat-kó",
+    "page.sessions.table.actions": "Chhau-chok",
+    "page.sessions.table.current_session": "Chit-má teng-lo̍k--ê",
+    "page.sessions.table.date": "Li̍t-kî",
+    "page.sessions.table.ip": "IP tōe-chí",
+    "page.sessions.table.user_agent": "Sú-iōng-lâng tāi-lí",
+    "page.sessions.title": "Ū teng-lo̍k--ê",
+    "page.settings.link_google_account": "Kah góa ê  Google kháu-chō kiat chòe-hé",
+    "page.settings.link_oidc_account": "Kah góa ê %s kháu-chō kiat chòe-hé",
+    "page.settings.title": "Siat-tēng",
+    "page.settings.unlink_google_account": "Phah khui kah góa ê Google kháu-chō ê kiat",
+    "page.settings.unlink_oidc_account": "Phah khui kah góa ê %s kháu-chō ê kiat",
+    "page.settings.webauthn.actions": "Chhau-chok",
+    "page.settings.webauthn.added_on": "Sin cheng-ka ê sî-kan",
+    "page.settings.webauthn.delete": [
+        "Thâi tiāu %d ê Passkey"
+    ],
+    "page.settings.webauthn.last_seen_on": "Siōng-bóe pái sú-iōng sî-kan",
+    "page.settings.webauthn.passkey_name": "Passkey miâ",
+    "page.settings.webauthn.passkeys": "Passkeys",
+    "page.settings.webauthn.register": "Chù-chheh Passkey",
+    "page.settings.webauthn.register.error": "Bô-hoat-tō͘ chù-chheh Passkey",
+    "page.shared_entries_count": [
+        "Í-keng hun-hióng %d ê siau-sit"
+    ],
+    "page.shared_entries.title": "Hun-hióng kè ê siau-sit",
+    "page.starred_entry_count": [
+        "%d ê siu-chông ê siau-sit"
+    ],
+    "page.starred.title": "Siu-chông",
+    "page.total_entry_count": [
+        "Lóng-chóng %d ê siau-sit"
+    ],
+    "page.unread_entry_count": [
+        "%d ê siau-sit ah-bōe tha̍k"
+    ],
+    "page.unread.title": "Ah-bōe tha̍k",
+    "page.users.actions": "chhau-chok",
+    "page.users.admin.no": "Hóⁿ",
+    "page.users.admin.yes": "Sī",
+    "page.users.is_admin": "Koán-lí-lâng",
+    "page.users.last_login": "Siōng-bóe pái teng-lo̍k",
+    "page.users.never_logged": "Chū-lâi bô teng-lo̍k kè",
+    "page.users.title": "Sú-iōng-lâng",
+    "page.users.username": "Sú-iōng-lâng miâ",
+    "page.webauthn_rename.title": "Tiông-sin hō͘ miâ Passkey",
+    "pagination.first": "Thâu-chi̍t ia̍h",
+    "pagination.last": "Siōng-bóe ia̍h",
+    "pagination.next": "Āu-chi̍t ia̍h",
+    "pagination.previous": "Téng-chi̍t ia̍h",
+    "search.label": "Chhiau-chhē",
+    "search.placeholder": "Chhiau-chhē...",
+    "search.submit": "Chhiau-chhē",
+    "skip_to_content": "Sóa kah chú-iàu ê lōe-iông",
+    "time_elapsed.days": [
+        "%d kang chêng"
+    ],
+    "time_elapsed.hours": [
+        "%d tiám-cheng chêng"
+    ],
+    "time_elapsed.minutes": [
+        "%d hun-cheng chêng"
+    ],
+    "time_elapsed.months": [
+        "%d kò ge̍h chêng"
+    ],
+    "time_elapsed.not_yet": "ah-bōe",
+    "time_elapsed.now": "tú-chiah",
+    "time_elapsed.weeks": [
+        "%d lé-pài chêng"
+    ],
+    "time_elapsed.years": [
+        "%d nî chêng"
+    ],
+    "time_elapsed.yesterday": "cha-hng",
+    "tooltip.keyboard_shortcuts": "Khoài-sok khí：%s",
+    "tooltip.logged_user": "Chit-má teng-lo̍k--ê:  %s"
+}

internal/mediaproxy/media_proxy_test.go

@@ -174,7 +174,7 @@ func TestAbsoluteProxyFilterWithHttpsAlways(t *testing.T) {
 	r.HandleFunc("/proxy/{encodedDigest}/{encodedURL}", func(w http.ResponseWriter, r *http.Request) {}).Name("proxy")
 
 	input := `<p><img src="https://website/folder/image.png" alt="Test"/></p>`
-	output := RewriteDocumentWithAbsoluteProxyURL(r, "localhost", input)
+	output := RewriteDocumentWithAbsoluteProxyURL(r, input)
 	expected := `<p><img src="http://localhost/proxy/LdPNR1GBDigeeNp2ArUQRyZsVqT_PWLfHGjYFrrWWIY=/aHR0cHM6Ly93ZWJzaXRlL2ZvbGRlci9pbWFnZS5wbmc=" alt="Test"/></p>`
 
 	if expected != output {
@@ -182,12 +182,10 @@ func TestAbsoluteProxyFilterWithHttpsAlways(t *testing.T) {
 	}
 }
 
-func TestAbsoluteProxyFilterWithHttpsScheme(t *testing.T) {
+func TestAbsoluteProxyFilterWithCustomPortAndSubfolderInBaseURL(t *testing.T) {
 	os.Clearenv()
-	os.Setenv("PROXY_OPTION", "all")
-	os.Setenv("PROXY_MEDIA_TYPES", "image")
-	os.Setenv("PROXY_PRIVATE_KEY", "test")
-	os.Setenv("HTTPS", "1")
+	os.Setenv("BASE_URL", "http://example.org:88/folder/")
+	os.Setenv("MEDIA_PROXY_PRIVATE_KEY", "test")
 
 	var err error
 	parser := config.NewParser()
@@ -196,12 +194,25 @@ func TestAbsoluteProxyFilterWithHttpsScheme(t *testing.T) {
 		t.Fatalf(`Parsing failure: %v`, err)
 	}
 
-	r := mux.NewRouter()
-	r.HandleFunc("/proxy/{encodedDigest}/{encodedURL}", func(w http.ResponseWriter, r *http.Request) {}).Name("proxy")
+	if config.Opts.BaseURL() != "http://example.org:88/folder" {
+		t.Fatalf(`Unexpected base URL, got "%s"`, config.Opts.BaseURL())
+	}
 
-	input := `<p><img src="https://website/folder/image.png" alt="Test"/></p>`
-	output := RewriteDocumentWithAbsoluteProxyURL(r, "localhost", input)
-	expected := `<p><img src="https://localhost/proxy/LdPNR1GBDigeeNp2ArUQRyZsVqT_PWLfHGjYFrrWWIY=/aHR0cHM6Ly93ZWJzaXRlL2ZvbGRlci9pbWFnZS5wbmc=" alt="Test"/></p>`
+	if config.Opts.RootURL() != "http://example.org:88" {
+		t.Fatalf(`Unexpected root URL, got "%s"`, config.Opts.RootURL())
+	}
+
+	router := mux.NewRouter()
+
+	if config.Opts.BasePath() != "" {
+		router = router.PathPrefix(config.Opts.BasePath()).Subrouter()
+	}
+
+	router.HandleFunc("/proxy/{encodedDigest}/{encodedURL}", func(w http.ResponseWriter, r *http.Request) {}).Name("proxy")
+
+	input := `<p><img src="http://website/folder/image.png" alt="Test"/></p>`
+	output := RewriteDocumentWithAbsoluteProxyURL(router, input)
+	expected := `<p><img src="http://example.org:88/folder/proxy/okK5PsdNY8F082UMQEAbLPeUFfbe2WnNfInNmR9T4WA=/aHR0cDovL3dlYnNpdGUvZm9sZGVyL2ltYWdlLnBuZw==" alt="Test"/></p>`
 
 	if expected != output {
 		t.Errorf(`Not expected output: got %q instead of %q`, output, expected)
@@ -225,7 +236,7 @@ func TestAbsoluteProxyFilterWithHttpsAlwaysAndAudioTag(t *testing.T) {
 	r.HandleFunc("/proxy/{encodedDigest}/{encodedURL}", func(w http.ResponseWriter, r *http.Request) {}).Name("proxy")
 
 	input := `<audio src="https://website/folder/audio.mp3"></audio>`
-	output := RewriteDocumentWithAbsoluteProxyURL(r, "localhost", input)
+	output := RewriteDocumentWithAbsoluteProxyURL(r, input)
 	expected := `<audio src="http://localhost/proxy/EmBTvmU5B17wGuONkeknkptYopW_Tl6Y6_W8oYbN_Xs=/aHR0cHM6Ly93ZWJzaXRlL2ZvbGRlci9hdWRpby5tcDM="></audio>`
 
 	if expected != output {
@@ -300,7 +311,7 @@ func TestAbsoluteProxyFilterWithHttpsAlwaysAndCustomProxyServer(t *testing.T) {
 	r.HandleFunc("/proxy/{encodedDigest}/{encodedURL}", func(w http.ResponseWriter, r *http.Request) {}).Name("proxy")
 
 	input := `<p><img src="https://website/folder/image.png" alt="Test"/></p>`
-	output := RewriteDocumentWithAbsoluteProxyURL(r, "localhost", input)
+	output := RewriteDocumentWithAbsoluteProxyURL(r, input)
 	expected := `<p><img src="https://proxy-example/proxy/aHR0cHM6Ly93ZWJzaXRlL2ZvbGRlci9pbWFnZS5wbmc=" alt="Test"/></p>`
 
 	if expected != output {
@@ -553,3 +564,28 @@ func TestProxyFilterVideoPoster(t *testing.T) {
 		t.Errorf(`Not expected output: got %s`, output)
 	}
 }
+
+func TestProxyFilterVideoPosterOnce(t *testing.T) {
+	os.Clearenv()
+	os.Setenv("PROXY_OPTION", "all")
+	os.Setenv("PROXY_MEDIA_TYPES", "image,video")
+	os.Setenv("PROXY_PRIVATE_KEY", "test")
+
+	var err error
+	parser := config.NewParser()
+	config.Opts, err = parser.ParseEnvironmentVariables()
+	if err != nil {
+		t.Fatalf(`Parsing failure: %v`, err)
+	}
+
+	r := mux.NewRouter()
+	r.HandleFunc("/proxy/{encodedDigest}/{encodedURL}", func(w http.ResponseWriter, r *http.Request) {}).Name("proxy")
+
+	input := `<video poster="https://example.com/img.png" src="https://example.com/video.mp4"></video>`
+	expected := `<video poster="/proxy/aDFfroYL57q5XsojIzATT6OYUCkuVSPXYJQAVrotnLw=/aHR0cHM6Ly9leGFtcGxlLmNvbS9pbWcucG5n" src="/proxy/0y3LR8zlx8S8qJkj1qWFOO6x3a-5yf2gLWjGIJV5yyc=/aHR0cHM6Ly9leGFtcGxlLmNvbS92aWRlby5tcDQ="></video>`
+	output := RewriteDocumentWithRelativeProxyURL(r, input)
+
+	if expected != output {
+		t.Errorf(`Not expected output: got %s`, output)
+	}
+}

internal/mediaproxy/rewriter.go

@@ -4,6 +4,7 @@
 package mediaproxy // import "miniflux.app/v2/internal/mediaproxy"
 
 import (
+	"slices"
 	"strings"
 
 	"miniflux.app/v2/internal/config"
@@ -20,11 +21,8 @@ func RewriteDocumentWithRelativeProxyURL(router *mux.Router, htmlDocument string
 	return genericProxyRewriter(router, ProxifyRelativeURL, htmlDocument)
 }
 
-func RewriteDocumentWithAbsoluteProxyURL(router *mux.Router, host, htmlDocument string) string {
-	proxifyFunction := func(router *mux.Router, url string) string {
-		return ProxifyAbsoluteURL(router, host, url)
-	}
-	return genericProxyRewriter(router, proxifyFunction, htmlDocument)
+func RewriteDocumentWithAbsoluteProxyURL(router *mux.Router, htmlDocument string) string {
+	return genericProxyRewriter(router, ProxifyAbsoluteURL, htmlDocument)
 }
 
 func genericProxyRewriter(router *mux.Router, proxifyFunction urlProxyRewriter, htmlDocument string) string {
@@ -53,13 +51,15 @@ func genericProxyRewriter(router *mux.Router, proxifyFunction urlProxyRewriter,
 				}
 			})
 
-			doc.Find("video").Each(func(i int, video *goquery.Selection) {
-				if posterAttrValue, ok := video.Attr("poster"); ok {
-					if shouldProxy(posterAttrValue, proxyOption) {
-						video.SetAttr("poster", proxifyFunction(router, posterAttrValue))
+			if !slices.Contains(config.Opts.MediaProxyResourceTypes(), "video") {
+				doc.Find("video").Each(func(i int, video *goquery.Selection) {
+					if posterAttrValue, ok := video.Attr("poster"); ok {
+						if shouldProxy(posterAttrValue, proxyOption) {
+							video.SetAttr("poster", proxifyFunction(router, posterAttrValue))
+						}
 					}
-				}
-			})
+				})
+			}
 
 		case "audio":
 			doc.Find("audio, audio source").Each(func(i int, audio *goquery.Selection) {
@@ -87,7 +87,7 @@ func genericProxyRewriter(router *mux.Router, proxifyFunction urlProxyRewriter,
 		}
 	}
 
-	output, err := doc.Find("body").First().Html()
+	output, err := doc.FindMatcher(goquery.Single("body")).Html()
 	if err != nil {
 		return htmlDocument
 	}

internal/mediaproxy/url.go

@@ -9,13 +9,11 @@ import (
 	"encoding/base64"
 	"log/slog"
 	"net/url"
-	"path"
-
-	"miniflux.app/v2/internal/http/route"
 
 	"github.com/gorilla/mux"
 
 	"miniflux.app/v2/internal/config"
+	"miniflux.app/v2/internal/http/route"
 )
 
 func ProxifyRelativeURL(router *mux.Router, mediaURL string) string {
@@ -33,7 +31,7 @@ func ProxifyRelativeURL(router *mux.Router, mediaURL string) string {
 	return route.Path(router, "proxy", "encodedDigest", base64.URLEncoding.EncodeToString(digest), "encodedURL", base64.URLEncoding.EncodeToString([]byte(mediaURL)))
 }
 
-func ProxifyAbsoluteURL(router *mux.Router, host, mediaURL string) string {
+func ProxifyAbsoluteURL(router *mux.Router, mediaURL string) string {
 	if mediaURL == "" {
 		return ""
 	}
@@ -42,13 +40,14 @@ func ProxifyAbsoluteURL(router *mux.Router, host, mediaURL string) string {
 		return proxifyURLWithCustomProxy(mediaURL, customProxyURL)
 	}
 
+	// Note that the proxyified URL is relative to the root URL.
 	proxifiedUrl := ProxifyRelativeURL(router, mediaURL)
-	scheme := "http"
-	if config.Opts.HTTPS {
-		scheme = "https"
+	absoluteURL, err := url.JoinPath(config.Opts.RootURL(), proxifiedUrl)
+	if err != nil {
+		return mediaURL
 	}
 
-	return scheme + "://" + host + proxifiedUrl
+	return absoluteURL
 }
 
 func proxifyURLWithCustomProxy(mediaURL, customProxyURL string) string {
@@ -56,7 +55,7 @@ func proxifyURLWithCustomProxy(mediaURL, customProxyURL string) string {
 		return mediaURL
 	}
 
-	proxyUrl, err := url.Parse(customProxyURL)
+	absoluteURL, err := url.JoinPath(customProxyURL, base64.URLEncoding.EncodeToString([]byte(mediaURL)))
 	if err != nil {
 		slog.Error("Incorrect custom media proxy URL",
 			slog.String("custom_proxy_url", customProxyURL),
@@ -65,6 +64,5 @@ func proxifyURLWithCustomProxy(mediaURL, customProxyURL string) string {
 		return mediaURL
 	}
 
-	proxyUrl.Path = path.Join(proxyUrl.Path, base64.URLEncoding.EncodeToString([]byte(mediaURL)))
-	return proxyUrl.String()
+	return absoluteURL
 }

internal/model/app_session.go

@@ -24,7 +24,7 @@ type SessionData struct {
 	WebAuthnSessionData WebAuthnSession `json:"webauthn_session_data"`
 }
 
-func (s SessionData) String() string {
+func (s *SessionData) String() string {
 	return fmt.Sprintf(`CSRF=%q, OAuth2State=%q, OAuth2CodeVerifier=%q, FlashMsg=%q, FlashErrMsg=%q, Lang=%q, Theme=%q, PocketTkn=%q, LastForceRefresh=%s, WebAuthnSession=%q`,
 		s.CSRF,
 		s.OAuth2State,
@@ -40,7 +40,7 @@ func (s SessionData) String() string {
 }
 
 // Value converts the session data to JSON.
-func (s SessionData) Value() (driver.Value, error) {
+func (s *SessionData) Value() (driver.Value, error) {
 	j, err := json.Marshal(s)
 	return j, err
 }

internal/model/enclosure.go

@@ -3,6 +3,15 @@
 
 package model // import "miniflux.app/v2/internal/model"
 
+import (
+	"strings"
+
+	"github.com/gorilla/mux"
+	"miniflux.app/v2/internal/config"
+	"miniflux.app/v2/internal/mediaproxy"
+	"miniflux.app/v2/internal/urllib"
+)
+
 // Enclosure represents an attachment.
 type Enclosure struct {
 	ID               int64  `json:"id"`
@@ -14,13 +23,81 @@ type Enclosure struct {
 	MediaProgression int64  `json:"media_progression"`
 }
 
+type EnclosureUpdateRequest struct {
+	MediaProgression int64 `json:"media_progression"`
+}
+
 // Html5MimeType will modify the actual MimeType to allow direct playback from HTML5 player for some kind of MimeType
-func (e Enclosure) Html5MimeType() string {
+func (e *Enclosure) Html5MimeType() string {
 	if e.MimeType == "video/m4v" {
 		return "video/x-m4v"
 	}
 	return e.MimeType
 }
 
+func (e *Enclosure) IsAudio() bool {
+	return strings.HasPrefix(strings.ToLower(e.MimeType), "audio/")
+}
+
+func (e *Enclosure) IsVideo() bool {
+	return strings.HasPrefix(strings.ToLower(e.MimeType), "video/")
+}
+
+func (e *Enclosure) IsImage() bool {
+	mimeType := strings.ToLower(e.MimeType)
+	mediaURL := strings.ToLower(e.URL)
+	return strings.HasPrefix(mimeType, "image/") || strings.HasSuffix(mediaURL, ".jpg") || strings.HasSuffix(mediaURL, ".jpeg") || strings.HasSuffix(mediaURL, ".png") || strings.HasSuffix(mediaURL, ".gif")
+}
+
 // EnclosureList represents a list of attachments.
 type EnclosureList []*Enclosure
+
+// FindMediaPlayerEnclosure returns the first enclosure that can be played by a media player.
+func (el EnclosureList) FindMediaPlayerEnclosure() *Enclosure {
+	for _, enclosure := range el {
+		if enclosure.URL != "" && strings.Contains(enclosure.MimeType, "audio/") || strings.Contains(enclosure.MimeType, "video/") {
+			return enclosure
+		}
+	}
+
+	return nil
+}
+
+func (el EnclosureList) ContainsAudioOrVideo() bool {
+	for _, enclosure := range el {
+		if strings.Contains(enclosure.MimeType, "audio/") || strings.Contains(enclosure.MimeType, "video/") {
+			return true
+		}
+	}
+	return false
+}
+
+func (el EnclosureList) ProxifyEnclosureURL(router *mux.Router) {
+	proxyOption := config.Opts.MediaProxyMode()
+
+	if proxyOption != "none" {
+		for i := range el {
+			if urllib.IsHTTPS(el[i].URL) {
+				for _, mediaType := range config.Opts.MediaProxyResourceTypes() {
+					if strings.HasPrefix(el[i].MimeType, mediaType+"/") {
+						el[i].URL = mediaproxy.ProxifyAbsoluteURL(router, el[i].URL)
+						break
+					}
+				}
+			}
+		}
+	}
+}
+
+func (e *Enclosure) ProxifyEnclosureURL(router *mux.Router) {
+	proxyOption := config.Opts.MediaProxyMode()
+
+	if proxyOption == "all" || proxyOption != "none" && !urllib.IsHTTPS(e.URL) {
+		for _, mediaType := range config.Opts.MediaProxyResourceTypes() {
+			if strings.HasPrefix(e.MimeType, mediaType+"/") {
+				e.URL = mediaproxy.ProxifyAbsoluteURL(router, e.URL)
+				break
+			}
+		}
+	}
+}

internal/model/entry.go

@@ -50,6 +50,22 @@ func NewEntry() *Entry {
 	}
 }
 
+// ShouldMarkAsReadOnView Return whether the entry should be marked as viewed considering all user settings and entry state.
+func (e *Entry) ShouldMarkAsReadOnView(user *User) bool {
+	// Already read, no need to mark as read again. Removed entries are not marked as read
+	if e.Status != EntryStatusUnread {
+		return false
+	}
+
+	// There is an enclosure, markAsRead will happen at enclosure completion time, no need to mark as read on view
+	if user.MarkReadOnMediaPlayerCompletion && e.Enclosures.ContainsAudioOrVideo() {
+		return false
+	}
+
+	// The user wants to mark as read on view
+	return user.MarkReadOnView
+}
+
 // Entries represents a list of entries.
 type Entries []*Entry
 

internal/model/feed.go

@@ -28,6 +28,7 @@ type Feed struct {
 	FeedURL                     string    `json:"feed_url"`
 	SiteURL                     string    `json:"site_url"`
 	Title                       string    `json:"title"`
+	Description                 string    `json:"description"`
 	CheckedAt                   time.Time `json:"checked_at"`
 	NextCheckAt                 time.Time `json:"next_check_at"`
 	EtagHeader                  string    `json:"etag_header"`
@@ -50,14 +51,20 @@ type Feed struct {
 	AllowSelfSignedCertificates bool      `json:"allow_self_signed_certificates"`
 	FetchViaProxy               bool      `json:"fetch_via_proxy"`
 	HideGlobally                bool      `json:"hide_globally"`
-	AppriseServiceURLs          string    `json:"apprise_service_urls"`
 	DisableHTTP2                bool      `json:"disable_http2"`
+	AppriseServiceURLs          string    `json:"apprise_service_urls"`
+	WebhookURL                  string    `json:"webhook_url"`
+	NtfyEnabled                 bool      `json:"ntfy_enabled"`
+	NtfyPriority                int       `json:"ntfy_priority"`
+	PushoverEnabled             bool      `json:"pushover_enabled,omitempty"`
+	PushoverPriority            int       `json:"pushover_priority,omitempty"`
 
-	// Non persisted attributes
+	// Non-persisted attributes
 	Category *Category `json:"category,omitempty"`
 	Icon     *FeedIcon `json:"icon"`
 	Entries  Entries   `json:"entries,omitempty"`
 
+	// Internal attributes (not exposed in the API and not persisted in the database)
 	TTL                    int    `json:"-"`
 	IconURL                string `json:"-"`
 	UnreadCount            int    `json:"-"`
@@ -108,26 +115,27 @@ func (f *Feed) CheckedNow() {
 }
 
 // ScheduleNextCheck set "next_check_at" of a feed based on the scheduler selected from the configuration.
-func (f *Feed) ScheduleNextCheck(weeklyCount int, newTTL int) {
-	f.TTL = newTTL
+func (f *Feed) ScheduleNextCheck(weeklyCount int, refreshDelayInMinutes int) {
+	f.TTL = refreshDelayInMinutes
+
 	// Default to the global config Polling Frequency.
-	var intervalMinutes int
-	switch config.Opts.PollingScheduler() {
-	case SchedulerEntryFrequency:
+	intervalMinutes := config.Opts.SchedulerRoundRobinMinInterval()
+
+	if config.Opts.PollingScheduler() == SchedulerEntryFrequency {
 		if weeklyCount <= 0 {
 			intervalMinutes = config.Opts.SchedulerEntryFrequencyMaxInterval()
 		} else {
 			intervalMinutes = int(math.Round(float64(7*24*60) / float64(weeklyCount*config.Opts.SchedulerEntryFrequencyFactor())))
-			intervalMinutes = int(math.Min(float64(intervalMinutes), float64(config.Opts.SchedulerEntryFrequencyMaxInterval())))
-			intervalMinutes = int(math.Max(float64(intervalMinutes), float64(config.Opts.SchedulerEntryFrequencyMinInterval())))
+			intervalMinutes = min(intervalMinutes, config.Opts.SchedulerEntryFrequencyMaxInterval())
+			intervalMinutes = max(intervalMinutes, config.Opts.SchedulerEntryFrequencyMinInterval())
 		}
-	default:
-		intervalMinutes = config.Opts.SchedulerRoundRobinMinInterval()
 	}
-	// If the feed has a TTL defined, we use it to make sure we don't check it too often.
-	if newTTL > intervalMinutes && newTTL > 0 {
-		intervalMinutes = newTTL
+
+	// If the feed has a TTL or a Retry-After defined, we use it to make sure we don't check it too often.
+	if refreshDelayInMinutes > 0 && refreshDelayInMinutes > intervalMinutes {
+		intervalMinutes = refreshDelayInMinutes
 	}
+
 	f.NextCheckAt = time.Now().Add(time.Minute * time.Duration(intervalMinutes))
 }
 
@@ -167,6 +175,7 @@ type FeedModificationRequest struct {
 	FeedURL                     *string `json:"feed_url"`
 	SiteURL                     *string `json:"site_url"`
 	Title                       *string `json:"title"`
+	Description                 *string `json:"description"`
 	ScraperRules                *string `json:"scraper_rules"`
 	RewriteRules                *string `json:"rewrite_rules"`
 	BlocklistRules              *string `json:"blocklist_rules"`
@@ -201,6 +210,10 @@ func (f *FeedModificationRequest) Patch(feed *Feed) {
 		feed.Title = *f.Title
 	}
 
+	if f.Description != nil && *f.Description != "" {
+		feed.Description = *f.Description
+	}
+
 	if f.ScraperRules != nil {
 		feed.ScraperRules = *f.ScraperRules
 	}

internal/model/feed_test.go

@@ -14,7 +14,7 @@ import (
 
 const (
 	largeWeeklyCount = 10080
-	noNewTTL         = 0
+	noRefreshDelay   = 0
 )
 
 func TestFeedCategorySetter(t *testing.T) {
@@ -76,7 +76,7 @@ func checkTargetInterval(t *testing.T, feed *Feed, targetInterval int, timeBefor
 	}
 }
 
-func TestFeedScheduleNextCheckDefault(t *testing.T) {
+func TestFeedScheduleNextCheckRoundRobinDefault(t *testing.T) {
 	os.Clearenv()
 
 	var err error
@@ -88,15 +88,60 @@ func TestFeedScheduleNextCheckDefault(t *testing.T) {
 
 	timeBefore := time.Now()
 	feed := &Feed{}
-	weeklyCount := 10
-	feed.ScheduleNextCheck(weeklyCount, noNewTTL)
+	feed.ScheduleNextCheck(0, noRefreshDelay)
 
 	if feed.NextCheckAt.IsZero() {
 		t.Error(`The next_check_at must be set`)
 	}
 
 	targetInterval := config.Opts.SchedulerRoundRobinMinInterval()
-	checkTargetInterval(t, feed, targetInterval, timeBefore, "default SchedulerRoundRobinMinInterval")
+	checkTargetInterval(t, feed, targetInterval, timeBefore, "TestFeedScheduleNextCheckRoundRobinDefault")
+}
+
+func TestFeedScheduleNextCheckRoundRobinWithRefreshDelayAboveMinInterval(t *testing.T) {
+	os.Clearenv()
+
+	var err error
+	parser := config.NewParser()
+	config.Opts, err = parser.ParseEnvironmentVariables()
+	if err != nil {
+		t.Fatalf(`Parsing failure: %v`, err)
+	}
+
+	timeBefore := time.Now()
+	feed := &Feed{}
+
+	feed.ScheduleNextCheck(0, config.Opts.SchedulerRoundRobinMinInterval()+30)
+
+	if feed.NextCheckAt.IsZero() {
+		t.Error(`The next_check_at must be set`)
+	}
+
+	expectedInterval := config.Opts.SchedulerRoundRobinMinInterval() + 30
+	checkTargetInterval(t, feed, expectedInterval, timeBefore, "TestFeedScheduleNextCheckRoundRobinWithRefreshDelayAboveMinInterval")
+}
+
+func TestFeedScheduleNextCheckRoundRobinWithRefreshDelayBelowMinInterval(t *testing.T) {
+	os.Clearenv()
+
+	var err error
+	parser := config.NewParser()
+	config.Opts, err = parser.ParseEnvironmentVariables()
+	if err != nil {
+		t.Fatalf(`Parsing failure: %v`, err)
+	}
+
+	timeBefore := time.Now()
+	feed := &Feed{}
+
+	feed.ScheduleNextCheck(0, config.Opts.SchedulerRoundRobinMinInterval()-30)
+
+	if feed.NextCheckAt.IsZero() {
+		t.Error(`The next_check_at must be set`)
+	}
+
+	expectedInterval := config.Opts.SchedulerRoundRobinMinInterval()
+	checkTargetInterval(t, feed, expectedInterval, timeBefore, "TestFeedScheduleNextCheckRoundRobinWithRefreshDelayBelowMinInterval")
 }
 
 func TestFeedScheduleNextCheckRoundRobinMinInterval(t *testing.T) {
@@ -114,15 +159,14 @@ func TestFeedScheduleNextCheckRoundRobinMinInterval(t *testing.T) {
 
 	timeBefore := time.Now()
 	feed := &Feed{}
-	weeklyCount := 100
-	feed.ScheduleNextCheck(weeklyCount, noNewTTL)
+	feed.ScheduleNextCheck(0, noRefreshDelay)
 
 	if feed.NextCheckAt.IsZero() {
 		t.Error(`The next_check_at must be set`)
 	}
 
-	targetInterval := minInterval
-	checkTargetInterval(t, feed, targetInterval, timeBefore, "round robin min interval")
+	expectedInterval := minInterval
+	checkTargetInterval(t, feed, expectedInterval, timeBefore, "TestFeedScheduleNextCheckRoundRobinMinInterval")
 }
 
 func TestFeedScheduleNextCheckEntryFrequencyMaxInterval(t *testing.T) {
@@ -144,7 +188,7 @@ func TestFeedScheduleNextCheckEntryFrequencyMaxInterval(t *testing.T) {
 	feed := &Feed{}
 	// Use a very small weekly count to trigger the max interval
 	weeklyCount := 1
-	feed.ScheduleNextCheck(weeklyCount, noNewTTL)
+	feed.ScheduleNextCheck(weeklyCount, noRefreshDelay)
 
 	if feed.NextCheckAt.IsZero() {
 		t.Error(`The next_check_at must be set`)
@@ -173,7 +217,7 @@ func TestFeedScheduleNextCheckEntryFrequencyMaxIntervalZeroWeeklyCount(t *testin
 	feed := &Feed{}
 	// Use a very small weekly count to trigger the max interval
 	weeklyCount := 0
-	feed.ScheduleNextCheck(weeklyCount, noNewTTL)
+	feed.ScheduleNextCheck(weeklyCount, noRefreshDelay)
 
 	if feed.NextCheckAt.IsZero() {
 		t.Error(`The next_check_at must be set`)
@@ -202,7 +246,7 @@ func TestFeedScheduleNextCheckEntryFrequencyMinInterval(t *testing.T) {
 	feed := &Feed{}
 	// Use a very large weekly count to trigger the min interval
 	weeklyCount := largeWeeklyCount
-	feed.ScheduleNextCheck(weeklyCount, noNewTTL)
+	feed.ScheduleNextCheck(weeklyCount, noRefreshDelay)
 
 	if feed.NextCheckAt.IsZero() {
 		t.Error(`The next_check_at must be set`)
@@ -228,7 +272,7 @@ func TestFeedScheduleNextCheckEntryFrequencyFactor(t *testing.T) {
 	timeBefore := time.Now()
 	feed := &Feed{}
 	weeklyCount := 7
-	feed.ScheduleNextCheck(weeklyCount, noNewTTL)
+	feed.ScheduleNextCheck(weeklyCount, noRefreshDelay)
 
 	if feed.NextCheckAt.IsZero() {
 		t.Error(`The next_check_at must be set`)

internal/model/integration.go

@@ -6,6 +6,9 @@ package model // import "miniflux.app/v2/internal/model"
 // Integration represents user integration settings.
 type Integration struct {
 	UserID                           int64
+	BetulaEnabled                    bool
+	BetulaURL                        string
+	BetulaToken                      string
 	PinboardEnabled                  bool
 	PinboardToken                    string
 	PinboardTags                     string
@@ -90,4 +93,27 @@ type Integration struct {
 	OmnivoreEnabled                  bool
 	OmnivoreAPIKey                   string
 	OmnivoreURL                      string
+	RaindropEnabled                  bool
+	RaindropToken                    string
+	RaindropCollectionID             string
+	RaindropTags                     string
+	NtfyEnabled                      bool
+	NtfyTopic                        string
+	NtfyURL                          string
+	NtfyAPIToken                     string
+	NtfyUsername                     string
+	NtfyPassword                     string
+	NtfyIconURL                      string
+	NtfyInternalLinks                bool
+	CuboxEnabled                     bool
+	CuboxAPILink                     string
+	DiscordEnabled                   bool
+	DiscordWebhookLink               string
+	SlackEnabled                     bool
+	SlackWebhookLink                 string
+	PushoverEnabled                  bool
+	PushoverUser                     string
+	PushoverToken                    string
+	PushoverDevice                   string
+	PushoverPrefix                   string
 }

internal/model/user.go

@@ -11,31 +11,36 @@ import (
 
 // User represents a user in the system.
 type User struct {
-	ID                     int64      `json:"id"`
-	Username               string     `json:"username"`
-	Password               string     `json:"-"`
-	IsAdmin                bool       `json:"is_admin"`
-	Theme                  string     `json:"theme"`
-	Language               string     `json:"language"`
-	Timezone               string     `json:"timezone"`
-	EntryDirection         string     `json:"entry_sorting_direction"`
-	EntryOrder             string     `json:"entry_sorting_order"`
-	Stylesheet             string     `json:"stylesheet"`
-	GoogleID               string     `json:"google_id"`
-	OpenIDConnectID        string     `json:"openid_connect_id"`
-	EntriesPerPage         int        `json:"entries_per_page"`
-	KeyboardShortcuts      bool       `json:"keyboard_shortcuts"`
-	ShowReadingTime        bool       `json:"show_reading_time"`
-	EntrySwipe             bool       `json:"entry_swipe"`
-	GestureNav             string     `json:"gesture_nav"`
-	LastLoginAt            *time.Time `json:"last_login_at"`
-	DisplayMode            string     `json:"display_mode"`
-	DefaultReadingSpeed    int        `json:"default_reading_speed"`
-	CJKReadingSpeed        int        `json:"cjk_reading_speed"`
-	DefaultHomePage        string     `json:"default_home_page"`
-	CategoriesSortingOrder string     `json:"categories_sorting_order"`
-	MarkReadOnView         bool       `json:"mark_read_on_view"`
-	MediaPlaybackRate      float64    `json:"media_playback_rate"`
+	ID                              int64      `json:"id"`
+	Username                        string     `json:"username"`
+	Password                        string     `json:"-"`
+	IsAdmin                         bool       `json:"is_admin"`
+	Theme                           string     `json:"theme"`
+	Language                        string     `json:"language"`
+	Timezone                        string     `json:"timezone"`
+	EntryDirection                  string     `json:"entry_sorting_direction"`
+	EntryOrder                      string     `json:"entry_sorting_order"`
+	Stylesheet                      string     `json:"stylesheet"`
+	CustomJS                        string     `json:"custom_js"`
+	ExternalFontHosts               string     `json:"external_font_hosts"`
+	GoogleID                        string     `json:"google_id"`
+	OpenIDConnectID                 string     `json:"openid_connect_id"`
+	EntriesPerPage                  int        `json:"entries_per_page"`
+	KeyboardShortcuts               bool       `json:"keyboard_shortcuts"`
+	ShowReadingTime                 bool       `json:"show_reading_time"`
+	EntrySwipe                      bool       `json:"entry_swipe"`
+	GestureNav                      string     `json:"gesture_nav"`
+	LastLoginAt                     *time.Time `json:"last_login_at"`
+	DisplayMode                     string     `json:"display_mode"`
+	DefaultReadingSpeed             int        `json:"default_reading_speed"`
+	CJKReadingSpeed                 int        `json:"cjk_reading_speed"`
+	DefaultHomePage                 string     `json:"default_home_page"`
+	CategoriesSortingOrder          string     `json:"categories_sorting_order"`
+	MarkReadOnView                  bool       `json:"mark_read_on_view"`
+	MarkReadOnMediaPlayerCompletion bool       `json:"mark_read_on_media_player_completion"`
+	MediaPlaybackRate               float64    `json:"media_playback_rate"`
+	BlockFilterEntryRules           string     `json:"block_filter_entry_rules"`
+	KeepFilterEntryRules            string     `json:"keep_filter_entry_rules"`
 }
 
 // UserCreationRequest represents the request to create a user.
@@ -49,29 +54,34 @@ type UserCreationRequest struct {
 
 // UserModificationRequest represents the request to update a user.
 type UserModificationRequest struct {
-	Username               *string  `json:"username"`
-	Password               *string  `json:"password"`
-	Theme                  *string  `json:"theme"`
-	Language               *string  `json:"language"`
-	Timezone               *string  `json:"timezone"`
-	EntryDirection         *string  `json:"entry_sorting_direction"`
-	EntryOrder             *string  `json:"entry_sorting_order"`
-	Stylesheet             *string  `json:"stylesheet"`
-	GoogleID               *string  `json:"google_id"`
-	OpenIDConnectID        *string  `json:"openid_connect_id"`
-	EntriesPerPage         *int     `json:"entries_per_page"`
-	IsAdmin                *bool    `json:"is_admin"`
-	KeyboardShortcuts      *bool    `json:"keyboard_shortcuts"`
-	ShowReadingTime        *bool    `json:"show_reading_time"`
-	EntrySwipe             *bool    `json:"entry_swipe"`
-	GestureNav             *string  `json:"gesture_nav"`
-	DisplayMode            *string  `json:"display_mode"`
-	DefaultReadingSpeed    *int     `json:"default_reading_speed"`
-	CJKReadingSpeed        *int     `json:"cjk_reading_speed"`
-	DefaultHomePage        *string  `json:"default_home_page"`
-	CategoriesSortingOrder *string  `json:"categories_sorting_order"`
-	MarkReadOnView         *bool    `json:"mark_read_on_view"`
-	MediaPlaybackRate      *float64 `json:"media_playback_rate"`
+	Username                        *string  `json:"username"`
+	Password                        *string  `json:"password"`
+	Theme                           *string  `json:"theme"`
+	Language                        *string  `json:"language"`
+	Timezone                        *string  `json:"timezone"`
+	EntryDirection                  *string  `json:"entry_sorting_direction"`
+	EntryOrder                      *string  `json:"entry_sorting_order"`
+	Stylesheet                      *string  `json:"stylesheet"`
+	CustomJS                        *string  `json:"custom_js"`
+	ExternalFontHosts               *string  `json:"external_font_hosts"`
+	GoogleID                        *string  `json:"google_id"`
+	OpenIDConnectID                 *string  `json:"openid_connect_id"`
+	EntriesPerPage                  *int     `json:"entries_per_page"`
+	IsAdmin                         *bool    `json:"is_admin"`
+	KeyboardShortcuts               *bool    `json:"keyboard_shortcuts"`
+	ShowReadingTime                 *bool    `json:"show_reading_time"`
+	EntrySwipe                      *bool    `json:"entry_swipe"`
+	GestureNav                      *string  `json:"gesture_nav"`
+	DisplayMode                     *string  `json:"display_mode"`
+	DefaultReadingSpeed             *int     `json:"default_reading_speed"`
+	CJKReadingSpeed                 *int     `json:"cjk_reading_speed"`
+	DefaultHomePage                 *string  `json:"default_home_page"`
+	CategoriesSortingOrder          *string  `json:"categories_sorting_order"`
+	MarkReadOnView                  *bool    `json:"mark_read_on_view"`
+	MarkReadOnMediaPlayerCompletion *bool    `json:"mark_read_on_media_player_completion"`
+	MediaPlaybackRate               *float64 `json:"media_playback_rate"`
+	BlockFilterEntryRules           *string  `json:"block_filter_entry_rules"`
+	KeepFilterEntryRules            *string  `json:"keep_filter_entry_rules"`
 }
 
 // Patch updates the User object with the modification request.
@@ -112,6 +122,14 @@ func (u *UserModificationRequest) Patch(user *User) {
 		user.Stylesheet = *u.Stylesheet
 	}
 
+	if u.CustomJS != nil {
+		user.CustomJS = *u.CustomJS
+	}
+
+	if u.ExternalFontHosts != nil {
+		user.ExternalFontHosts = *u.ExternalFontHosts
+	}
+
 	if u.GoogleID != nil {
 		user.GoogleID = *u.GoogleID
 	}
@@ -164,9 +182,21 @@ func (u *UserModificationRequest) Patch(user *User) {
 		user.MarkReadOnView = *u.MarkReadOnView
 	}
 
+	if u.MarkReadOnMediaPlayerCompletion != nil {
+		user.MarkReadOnMediaPlayerCompletion = *u.MarkReadOnMediaPlayerCompletion
+	}
+
 	if u.MediaPlaybackRate != nil {
 		user.MediaPlaybackRate = *u.MediaPlaybackRate
 	}
+
+	if u.BlockFilterEntryRules != nil {
+		user.BlockFilterEntryRules = *u.BlockFilterEntryRules
+	}
+
+	if u.KeepFilterEntryRules != nil {
+		user.KeepFilterEntryRules = *u.KeepFilterEntryRules
+	}
 }
 
 // UseTimezone converts last login date to the given timezone.

internal/oauth2/authorization.go

@@ -6,7 +6,6 @@ package oauth2 // import "miniflux.app/v2/internal/oauth2"
 import (
 	"crypto/sha256"
 	"encoding/base64"
-	"io"
 
 	"golang.org/x/oauth2"
 
@@ -33,17 +32,14 @@ func (u *Authorization) CodeVerifier() string {
 
 func GenerateAuthorization(config *oauth2.Config) *Authorization {
 	codeVerifier := crypto.GenerateRandomStringHex(32)
-
-	sha2 := sha256.New()
-	io.WriteString(sha2, codeVerifier)
-	codeChallenge := base64.RawURLEncoding.EncodeToString(sha2.Sum(nil))
+	sum := sha256.Sum256([]byte(codeVerifier))
 
 	state := crypto.GenerateRandomStringHex(24)
 
 	authUrl := config.AuthCodeURL(
 		state,
 		oauth2.SetAuthURLParam("code_challenge_method", "S256"),
-		oauth2.SetAuthURLParam("code_challenge", codeChallenge),
+		oauth2.SetAuthURLParam("code_challenge", base64.RawURLEncoding.EncodeToString(sum[:])),
 	)
 
 	return &Authorization{

internal/reader/atom/atom_10.go

@@ -9,7 +9,6 @@ import (
 	"strings"
 
 	"miniflux.app/v2/internal/reader/media"
-	"miniflux.app/v2/internal/reader/sanitizer"
 )
 
 // The "atom:feed" element is the document (i.e., top-level) element of
@@ -188,7 +187,6 @@ func (a *Atom10Text) Title() string {
 		content = a.CharData
 	}
 
-	content = sanitizer.StripTags(content)
 	return strings.TrimSpace(content)
 }
 

internal/reader/atom/atom_10_test.go

@@ -492,6 +492,10 @@ func TestParseEntryWithHTMLTitle(t *testing.T) {
 		</title>
 		<link href="http://example.org/c"/>
 	  </entry>
+	  <entry>
+		<title type="html"><![CDATA[Test with self-closing &lt;tag&gt;]]></title>
+		<link href="http://example.org/d"/>
+	  </entry>
 	</feed>`
 
 	feed, err := Parse("https://example.org/", bytes.NewReader([]byte(data)), "10")
@@ -499,7 +503,11 @@ func TestParseEntryWithHTMLTitle(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if feed.Entries[0].Title != "Code Test" {
+	if len(feed.Entries) != 4 {
+		t.Fatalf("Incorrect number of entries, got: %d", len(feed.Entries))
+	}
+
+	if feed.Entries[0].Title != "<code>Code</code> Test" {
 		t.Errorf("Incorrect entry title, got: %q", feed.Entries[0].Title)
 	}
 
@@ -510,6 +518,10 @@ func TestParseEntryWithHTMLTitle(t *testing.T) {
 	if feed.Entries[2].Title != "Entry title with space around CDATA" {
 		t.Errorf("Incorrect entry title, got: %q", feed.Entries[2].Title)
 	}
+
+	if feed.Entries[3].Title != "Test with self-closing <tag>" {
+		t.Errorf("Incorrect entry title, got: %q", feed.Entries[3].Title)
+	}
 }
 
 func TestParseEntryWithXHTMLTitle(t *testing.T) {
@@ -537,7 +549,7 @@ func TestParseEntryWithXHTMLTitle(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if feed.Entries[0].Title != `This is XHTML content.` {
+	if feed.Entries[0].Title != `This is <b>XHTML</b> content.` {
 		t.Errorf("Incorrect entry title, got: %q", feed.Entries[0].Title)
 	}
 }
@@ -643,7 +655,7 @@ func TestParseEntryWithDoubleEncodedEntitiesTitle(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if feed.Entries[0].Title != `'AT&T'` {
+	if feed.Entries[0].Title != `&#39;AT&amp;T&#39;` {
 		t.Errorf("Incorrect entry title, got: %q", feed.Entries[0].Title)
 	}
 }

internal/reader/date/parser.go

@@ -354,9 +354,7 @@ func parseLocalTimeDates(layout, ds string) (t time.Time, err error) {
 	// Workaround for dates that don't use GMT.
 	if strings.HasSuffix(ds, "PST") || strings.HasSuffix(ds, "PDT") {
 		loc, _ = time.LoadLocation("America/Los_Angeles")
-	}
-
-	if strings.HasSuffix(ds, "EST") || strings.HasSuffix(ds, "EDT") {
+	} else if strings.HasSuffix(ds, "EST") || strings.HasSuffix(ds, "EDT") {
 		loc, _ = time.LoadLocation("America/New_York")
 	}
 

internal/reader/encoding/encoding.go

@@ -5,6 +5,7 @@ package encoding // import "miniflux.app/v2/internal/reader/encoding"
 
 import (
 	"bytes"
+	"fmt"
 	"io"
 	"unicode/utf8"
 
@@ -23,7 +24,11 @@ import (
 // - Feeds with encoding specified only in XML document and not in HTTP header
 // - Feeds with wrong encoding defined and already in UTF-8
 func CharsetReader(charsetLabel string, input io.Reader) (io.Reader, error) {
-	buffer, _ := io.ReadAll(input)
+	buffer, err := io.ReadAll(input)
+	if err != nil {
+		return nil, fmt.Errorf(`encoding: unable to read input: %w`, err)
+	}
+
 	r := bytes.NewReader(buffer)
 
 	// The document is already UTF-8, do not do anything (avoid double-encoding).
@@ -35,3 +40,24 @@ func CharsetReader(charsetLabel string, input io.Reader) (io.Reader, error) {
 	// Transform document to UTF-8 from the specified encoding in XML prolog.
 	return charset.NewReaderLabel(charsetLabel, r)
 }
+
+// NewCharsetReader returns an io.Reader that converts the content of r to UTF-8.
+func NewCharsetReader(r io.Reader, contentType string) (io.Reader, error) {
+	buffer, err := io.ReadAll(r)
+	if err != nil {
+		return nil, fmt.Errorf(`encoding: unable to read input: %w`, err)
+	}
+
+	internalReader := bytes.NewReader(buffer)
+
+	// The document is already UTF-8, do not do anything.
+	if utf8.Valid(buffer) {
+		return internalReader, nil
+	}
+
+	// Transform document to UTF-8 from the specified encoding in Content-Type header.
+	// Note that only the first 1024 bytes are used to detect the encoding.
+	// If the <meta charset> tag is not found in the first 1024 bytes, charset.DetermineEncoding returns "windows-1252" resulting in encoding issues.
+	// See https://html.spec.whatwg.org/multipage/parsing.html#determining-the-character-encoding
+	return charset.NewReader(internalReader, contentType)
+}

internal/reader/encoding/encoding_test.go

@@ -0,0 +1,348 @@
+// SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package encoding // import "miniflux.app/v2/internal/reader/encoding"
+
+import (
+	"bytes"
+	"io"
+	"os"
+	"testing"
+	"unicode/utf8"
+)
+
+func TestCharsetReaderWithUTF8(t *testing.T) {
+	file := "testdata/utf8.xml"
+
+	f, err := os.Open(file)
+	if err != nil {
+		t.Fatalf("Unable to open file: %v", err)
+	}
+
+	reader, err := CharsetReader("UTF-8", f)
+	if err != nil {
+		t.Fatalf("Unable to create reader: %v", err)
+	}
+
+	data, err := io.ReadAll(reader)
+	if err != nil {
+		t.Fatalf("Unable to read data: %v", err)
+	}
+
+	if !utf8.Valid(data) {
+		t.Fatalf("Data is not valid UTF-8")
+	}
+
+	expectedUnicodeString := "Café"
+	if !bytes.Contains(data, []byte(expectedUnicodeString)) {
+		t.Fatalf("Data does not contain expected unicode string: %s", expectedUnicodeString)
+	}
+}
+
+func TestCharsetReaderWithISO88591(t *testing.T) {
+	file := "testdata/iso-8859-1.xml"
+
+	f, err := os.Open(file)
+	if err != nil {
+		t.Fatalf("Unable to open file: %v", err)
+	}
+
+	reader, err := CharsetReader("ISO-8859-1", f)
+	if err != nil {
+		t.Fatalf("Unable to create reader: %v", err)
+	}
+
+	data, err := io.ReadAll(reader)
+	if err != nil {
+		t.Fatalf("Unable to read data: %v", err)
+	}
+
+	if !utf8.Valid(data) {
+		t.Fatalf("Data is not valid UTF-8")
+	}
+
+	expectedUnicodeString := "Café"
+	if !bytes.Contains(data, []byte(expectedUnicodeString)) {
+		t.Fatalf("Data does not contain expected unicode string: %s", expectedUnicodeString)
+	}
+}
+
+func TestCharsetReaderWithWindows1252(t *testing.T) {
+	file := "testdata/windows-1252.xml"
+
+	f, err := os.Open(file)
+	if err != nil {
+		t.Fatalf("Unable to open file: %v", err)
+	}
+
+	reader, err := CharsetReader("windows-1252", f)
+	if err != nil {
+		t.Fatalf("Unable to create reader: %v", err)
+	}
+
+	data, err := io.ReadAll(reader)
+	if err != nil {
+		t.Fatalf("Unable to read data: %v", err)
+	}
+
+	if !utf8.Valid(data) {
+		t.Fatalf("Data is not valid UTF-8")
+	}
+
+	expectedUnicodeString := "Euro €"
+	if !bytes.Contains(data, []byte(expectedUnicodeString)) {
+		t.Fatalf("Data does not contain expected unicode string: %s", expectedUnicodeString)
+	}
+}
+
+func TestCharsetReaderWithInvalidProlog(t *testing.T) {
+	file := "testdata/invalid-prolog.xml"
+
+	f, err := os.Open(file)
+	if err != nil {
+		t.Fatalf("Unable to open file: %v", err)
+	}
+
+	reader, err := CharsetReader("invalid", f)
+	if err != nil {
+		t.Fatalf("Unable to create reader: %v", err)
+	}
+
+	data, err := io.ReadAll(reader)
+	if err != nil {
+		t.Fatalf("Unable to read data: %v", err)
+	}
+
+	if !utf8.Valid(data) {
+		t.Fatalf("Data is not valid UTF-8")
+	}
+
+	expectedUnicodeString := "Café"
+	if !bytes.Contains(data, []byte(expectedUnicodeString)) {
+		t.Fatalf("Data does not contain expected unicode string: %s", expectedUnicodeString)
+	}
+}
+
+func TestCharsetReaderWithUTF8DocumentWithIncorrectProlog(t *testing.T) {
+	file := "testdata/utf8-incorrect-prolog.xml"
+
+	f, err := os.Open(file)
+	if err != nil {
+		t.Fatalf("Unable to open file: %v", err)
+	}
+
+	reader, err := CharsetReader("ISO-8859-1", f)
+	if err != nil {
+		t.Fatalf("Unable to create reader: %v", err)
+	}
+
+	data, err := io.ReadAll(reader)
+	if err != nil {
+		t.Fatalf("Unable to read data: %v", err)
+	}
+
+	if !utf8.Valid(data) {
+		t.Fatalf("Data is not valid UTF-8")
+	}
+
+	expectedUnicodeString := "Café"
+	if !bytes.Contains(data, []byte(expectedUnicodeString)) {
+		t.Fatalf("Data does not contain expected unicode string: %s", expectedUnicodeString)
+	}
+}
+
+func TestCharsetReaderWithWindows1252DocumentWithIncorrectProlog(t *testing.T) {
+	file := "testdata/windows-1252-incorrect-prolog.xml"
+
+	f, err := os.Open(file)
+	if err != nil {
+		t.Fatalf("Unable to open file: %v", err)
+	}
+
+	reader, err := CharsetReader("windows-1252", f)
+	if err != nil {
+		t.Fatalf("Unable to create reader: %v", err)
+	}
+
+	data, err := io.ReadAll(reader)
+	if err != nil {
+		t.Fatalf("Unable to read data: %v", err)
+	}
+
+	if !utf8.Valid(data) {
+		t.Fatalf("Data is not valid UTF-8")
+	}
+
+	expectedUnicodeString := "Euro €"
+	if !bytes.Contains(data, []byte(expectedUnicodeString)) {
+		t.Fatalf("Data does not contain expected unicode string: %s", expectedUnicodeString)
+	}
+}
+
+func TestNewReaderWithUTF8Document(t *testing.T) {
+	file := "testdata/utf8.html"
+
+	f, err := os.Open(file)
+	if err != nil {
+		t.Fatalf("Unable to open file: %v", err)
+	}
+
+	reader, err := NewCharsetReader(f, "text/html; charset=UTF-8")
+	if err != nil {
+		t.Fatalf("Unable to create reader: %v", err)
+	}
+
+	data, err := io.ReadAll(reader)
+	if err != nil {
+		t.Fatalf("Unable to read data: %v", err)
+	}
+
+	if !utf8.Valid(data) {
+		t.Fatalf("Data is not valid UTF-8")
+	}
+
+	expectedUnicodeString := "Café"
+	if !bytes.Contains(data, []byte(expectedUnicodeString)) {
+		t.Fatalf("Data does not contain expected unicode string: %s", expectedUnicodeString)
+	}
+}
+
+func TestNewReaderWithUTF8DocumentAndNoContentEncoding(t *testing.T) {
+	file := "testdata/utf8.html"
+
+	f, err := os.Open(file)
+	if err != nil {
+		t.Fatalf("Unable to open file: %v", err)
+	}
+
+	reader, err := NewCharsetReader(f, "text/html")
+	if err != nil {
+		t.Fatalf("Unable to create reader: %v", err)
+	}
+
+	data, err := io.ReadAll(reader)
+	if err != nil {
+		t.Fatalf("Unable to read data: %v", err)
+	}
+
+	if !utf8.Valid(data) {
+		t.Fatalf("Data is not valid UTF-8")
+	}
+
+	expectedUnicodeString := "Café"
+	if !bytes.Contains(data, []byte(expectedUnicodeString)) {
+		t.Fatalf("Data does not contain expected unicode string: %s", expectedUnicodeString)
+	}
+}
+
+func TestNewReaderWithISO88591Document(t *testing.T) {
+	file := "testdata/iso-8859-1.xml"
+
+	f, err := os.Open(file)
+	if err != nil {
+		t.Fatalf("Unable to open file: %v", err)
+	}
+
+	reader, err := NewCharsetReader(f, "text/html; charset=ISO-8859-1")
+	if err != nil {
+		t.Fatalf("Unable to create reader: %v", err)
+	}
+
+	data, err := io.ReadAll(reader)
+	if err != nil {
+		t.Fatalf("Unable to read data: %v", err)
+	}
+
+	if !utf8.Valid(data) {
+		t.Fatalf("Data is not valid UTF-8")
+	}
+
+	expectedUnicodeString := "Café"
+	if !bytes.Contains(data, []byte(expectedUnicodeString)) {
+		t.Fatalf("Data does not contain expected unicode string: %s", expectedUnicodeString)
+	}
+}
+
+func TestNewReaderWithISO88591DocumentAndNoContentType(t *testing.T) {
+	file := "testdata/iso-8859-1.xml"
+
+	f, err := os.Open(file)
+	if err != nil {
+		t.Fatalf("Unable to open file: %v", err)
+	}
+
+	reader, err := NewCharsetReader(f, "")
+	if err != nil {
+		t.Fatalf("Unable to create reader: %v", err)
+	}
+
+	data, err := io.ReadAll(reader)
+	if err != nil {
+		t.Fatalf("Unable to read data: %v", err)
+	}
+
+	if !utf8.Valid(data) {
+		t.Fatalf("Data is not valid UTF-8")
+	}
+
+	expectedUnicodeString := "Café"
+	if !bytes.Contains(data, []byte(expectedUnicodeString)) {
+		t.Fatalf("Data does not contain expected unicode string: %s", expectedUnicodeString)
+	}
+}
+
+func TestNewReaderWithISO88591DocumentWithMetaAfter1024Bytes(t *testing.T) {
+	file := "testdata/iso-8859-1-meta-after-1024.html"
+
+	f, err := os.Open(file)
+	if err != nil {
+		t.Fatalf("Unable to open file: %v", err)
+	}
+
+	reader, err := NewCharsetReader(f, "text/html")
+	if err != nil {
+		t.Fatalf("Unable to create reader: %v", err)
+	}
+
+	data, err := io.ReadAll(reader)
+	if err != nil {
+		t.Fatalf("Unable to read data: %v", err)
+	}
+
+	if !utf8.Valid(data) {
+		t.Fatalf("Data is not valid UTF-8")
+	}
+
+	expectedUnicodeString := "Café"
+	if !bytes.Contains(data, []byte(expectedUnicodeString)) {
+		t.Fatalf("Data does not contain expected unicode string: %s", expectedUnicodeString)
+	}
+}
+
+func TestNewReaderWithUTF8DocumentWithMetaAfter1024Bytes(t *testing.T) {
+	file := "testdata/utf8-meta-after-1024.html"
+
+	f, err := os.Open(file)
+	if err != nil {
+		t.Fatalf("Unable to open file: %v", err)
+	}
+
+	reader, err := NewCharsetReader(f, "text/html")
+	if err != nil {
+		t.Fatalf("Unable to create reader: %v", err)
+	}
+
+	data, err := io.ReadAll(reader)
+	if err != nil {
+		t.Fatalf("Unable to read data: %v", err)
+	}
+
+	if !utf8.Valid(data) {
+		t.Fatalf("Data is not valid UTF-8")
+	}
+
+	expectedUnicodeString := "Café"
+	if !bytes.Contains(data, []byte(expectedUnicodeString)) {
+		t.Fatalf("Data does not contain expected unicode string: %s", expectedUnicodeString)
+	}
+}