feat(client): allow http.Client as option and add context to api methods

- There is no need to use two replacers instead of one. It might help keep the
  input in a low CPU cache.
- Don't cast an int to float (twice) for nothing in checkTimezoneRange.

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -63,3 +63,5 @@ body:
           required: true
         - label: "I understand that feature requests are not guaranteed to be implemented."
           required: true
+        - label: "I agree to follow the project's contribution guidelines."
+          required: true

.github/ISSUE_TEMPLATE/proposal.yml

@@ -84,3 +84,5 @@ body:
           required: true
         - label: "I agree to provide follow-up updates and maintain discussion on this proposal."
           required: true
+        - label: "I agree to follow the project's contribution guidelines."
+          required: true

.github/pull_request_template.md

@@ -4,4 +4,4 @@ Have you followed these guidelines?
 - [ ] 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
+- [ ] I have read and understood the [contribution guidelines](https://github.com/miniflux/v2/blob/main/CONTRIBUTING.md)

.github/workflows/build_binaries.yml

@@ -10,11 +10,11 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
       - name: Set up Golang
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v6
         with:
-          go-version: "1.24.x"
+          go-version: stable
           check-latest: true
       - name: Compile binaries
         env:

.github/workflows/codeql-analysis.yml

@@ -33,17 +33,17 @@ jobs:
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v4
+      uses: actions/checkout@v5
 
-    - uses: actions/setup-go@v5
+    - uses: actions/setup-go@v6
       with:
-        go-version: "1.24.x"
+        go-version: stable
 
     - name: Initialize CodeQL
-      uses: github/codeql-action/init@v3
+      uses: github/codeql-action/init@v4
 
     - name: Autobuild
-      uses: github/codeql-action/autobuild@v3
+      uses: github/codeql-action/autobuild@v4
 
     - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@v3
+      uses: github/codeql-action/analyze@v4

.github/workflows/debian_packages.yml

@@ -17,7 +17,7 @@ jobs:
     name: Test Packages
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
       with:
           fetch-depth: 0
     - name: Set up QEMU
@@ -38,7 +38,7 @@ jobs:
     name: Build Packages Manually
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
       with:
           fetch-depth: 0
     - name: Set up QEMU
@@ -64,7 +64,7 @@ jobs:
     name: Publish Packages
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
       with:
           fetch-depth: 0
     - name: Set up QEMU

.github/workflows/docker.yml

@@ -17,7 +17,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
         with:
           fetch-depth: 0
 

.github/workflows/linters.yml

@@ -12,7 +12,7 @@ jobs:
     name: Javascript Linter
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
     - name: Install linters
       run: |
         sudo npm install -g jshint@2.13.6 eslint@8.57.0
@@ -25,16 +25,11 @@ jobs:
     name: Golang Linters
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-go@v5
+      - uses: actions/checkout@v5
+      - uses: actions/setup-go@v6
         with:
-          go-version: "1.24.x"
+          go-version: stable
       - uses: golangci/golangci-lint-action@v8
-        with:
-          args: >
-            --timeout 10m
-            --disable errcheck
-            --enable sqlclosecheck,misspell,whitespace,gocritic
       - name: Run gofmt linter
         run: gofmt -d -e .
 
@@ -43,11 +38,11 @@ jobs:
     name: Commit Linter
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
         with:
           fetch-depth: 0
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
         with:
           python-version: '3.13'
       - name: Validate PR commits

.github/workflows/rpm_packages.yml

@@ -17,7 +17,7 @@ jobs:
     name: Test Packages
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
       with:
           fetch-depth: 0
     - name: Build RPM Package
@@ -29,7 +29,7 @@ jobs:
     name: Build Packages Manually
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
       with:
           fetch-depth: 0
     - name: Build RPM Package
@@ -46,7 +46,7 @@ jobs:
     name: Publish Packages
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
+    - uses: actions/checkout@v5
       with:
           fetch-depth: 0
     - name: Build RPM Package

.github/workflows/scripts/commit-checker.py

@@ -4,8 +4,10 @@ import sys
 import argparse
 from typing import Match
 
-# Conventional commit pattern
-CONVENTIONAL_COMMIT_PATTERN: str = r"^(build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test)(\([a-z0-9-]+\))?!?: .{1,100}"
+# Conventional commit pattern (including Git revert messages)
+CONVENTIONAL_COMMIT_PATTERN: str = (
+    r"^((build|chore|ci|docs|feat|fix|perf|refactor|revert|style|test)(\([a-z0-9-]+\))?!?: .{1,100}|Revert .+)"
+)
 
 
 def get_commit_message(commit_hash: str) -> str:
@@ -23,9 +25,7 @@ def get_commit_message(commit_hash: str) -> str:
         sys.exit(1)
 
 
-def check_commit_message(
-    message: str, pattern: str = CONVENTIONAL_COMMIT_PATTERN
-) -> bool:
+def check_commit_message(message: str, pattern: str = CONVENTIONAL_COMMIT_PATTERN) -> bool:
     """Check if commit message follows conventional commit format."""
     first_line: str = message.split("\n")[0]
     match: Match[str] | None = re.match(pattern, first_line)
@@ -50,9 +50,7 @@ def check_commit_range(base_ref: str, head_ref: str) -> list[dict[str, str]]:
         for commit_hash in commit_hashes:
             message: str = get_commit_message(commit_hash)
             if not check_commit_message(message):
-                non_compliant.append(
-                    {"hash": commit_hash, "message": message.split("\n")[0]}
-                )
+                non_compliant.append({"hash": commit_hash, "message": message.split("\n")[0]})
 
         return non_compliant
     except subprocess.CalledProcessError as e:
@@ -61,15 +59,9 @@ def check_commit_range(base_ref: str, head_ref: str) -> list[dict[str, str]]:
 
 
 def main() -> None:
-    parser: argparse.ArgumentParser = argparse.ArgumentParser(
-        description="Check conventional commit compliance"
-    )
-    parser.add_argument(
-        "--base", required=True, help="Base ref (starting commit, exclusive)"
-    )
-    parser.add_argument(
-        "--head", required=True, help="Head ref (ending commit, inclusive)"
-    )
+    parser: argparse.ArgumentParser = argparse.ArgumentParser(description="Check conventional commit compliance")
+    parser.add_argument("--base", required=True, help="Base ref (starting commit, exclusive)")
+    parser.add_argument("--head", required=True, help="Head ref (ending commit, inclusive)")
     args: argparse.Namespace = parser.parse_args()
 
     non_compliant: list[dict[str, str]] = check_commit_range(args.base, args.head)
@@ -80,9 +72,7 @@ def main() -> None:
             print(f"- {commit['hash'][:8]}: {commit['message']}")
         print("\nPlease ensure your commit messages follow the format:")
         print("type(scope): subject")
-        print(
-            "\nWhere type is one of: build, chore, ci, docs, feat, fix, perf, refactor, revert, style, test"
-        )
+        print("\nWhere type is one of: build, chore, ci, docs, feat, fix, perf, refactor, revert, style, test")
         sys.exit(1)
     else:
         print("All commits follow the conventional commit format!")

.github/workflows/tests.yml

@@ -15,14 +15,13 @@ jobs:
       max-parallel: 4
       matrix:
         os: [ubuntu-latest, windows-latest, macOS-latest]
-        go-version: ["1.24.x"]
     steps:
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v5
     - name: Set up Go
-      uses: actions/setup-go@v5
+      uses: actions/setup-go@v6
       with:
-        go-version: ${{ matrix.go-version }}
+        go-version: stable
     - name: Run unit tests with coverage and race conditions checking
       if: matrix.os == 'ubuntu-latest'
       run: make test
@@ -45,16 +44,15 @@ jobs:
         options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
     steps:
     - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v5
     - name: Set up Go
-      uses: actions/setup-go@v5
+      uses: actions/setup-go@v6
       with:
-        go-version: "1.24.x"
+        go-version: stable
     - name: Install Postgres client
       run: sudo apt update && sudo apt install -y postgresql-client
     - name: Run integration tests
       run: make integration-test
       env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         PGHOST: 127.0.0.1
         PGPASSWORD: postgres

.golangci.yml

@@ -0,0 +1,23 @@
+version: "2"
+linters:
+  default: standard
+  disable:
+    - errcheck
+  enable:
+    - errname
+    - gocritic
+    - goheader
+    - loggercheck
+    - misspell
+    - perfsprint
+    - prealloc
+    - sqlclosecheck
+    - staticcheck
+    - whitespace
+  settings:
+    loggercheck:
+      slog: true
+    goheader:
+      template: |-
+        SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
+        SPDX-License-Identifier: Apache-2.0

CONTRIBUTING.md

@@ -0,0 +1,178 @@
+# Contributing to Miniflux
+
+This document outlines how to contribute effectively to Miniflux.
+
+## Philosophy
+
+Miniflux follows a **minimalist philosophy**. The feature set is intentionally kept limited to avoid bloatware. Before contributing, please understand that:
+
+- **Improving existing features takes priority over adding new ones**
+- **Quality over quantity** - well-implemented, focused features are preferred
+- **Simplicity is key** - complex solutions are discouraged in favor of simple, maintainable code
+
+## Before You Start
+
+### Feature Requests
+
+Before implementing a new feature:
+
+- Check if it aligns with Miniflux's philosophy
+- Consider if the feature could be implemented differently to maintain simplicity
+- Remember that developing software takes significant time, and this is a volunteer-driven project
+- If you need a specific feature, the best approach is to contribute it yourself
+
+### Bug Reports
+
+When reporting bugs:
+
+- Search existing issues first to avoid duplicates
+- Provide clear reproduction steps
+- Include relevant system information (OS, browser, Miniflux version)
+- Include error messages, screenshots, and logs when applicable
+
+## Development Setup
+
+### Requirements
+
+- **Git**
+- **Go >= 1.24**
+- **PostgreSQL**
+
+### Getting Started
+
+1. **Fork the repository** on GitHub
+2. **Clone your fork locally:**
+   ```bash
+   git clone https://github.com/YOUR_USERNAME/miniflux.git
+   cd miniflux
+   ```
+
+3. **Build the application binary:**
+   ```bash
+   make miniflux
+   ```
+
+4. **Run locally in debug mode:**
+   ```bash
+   make run
+   ```
+
+### Database Setup
+
+For development and testing, you can run a local PostgreSQL database with Docker:
+
+```bash
+# Start PostgreSQL container
+docker run --rm --name miniflux2-db -p 5432:5432 \
+  -e POSTGRES_DB=miniflux2 \
+  -e POSTGRES_USER=postgres \
+  -e POSTGRES_PASSWORD=postgres \
+  postgres
+```
+
+You can also use an existing PostgreSQL instance. Make sure to set the `DATABASE_URL` environment variable accordingly.
+
+## Development Workflow
+
+### Code Quality
+
+1. **Run the linter:**
+   ```bash
+   make lint
+   ```
+   Requires `staticcheck` and `golangci-lint` to be installed.
+
+2. **Run unit tests:**
+   ```bash
+   make test
+   ```
+
+3. **Run integration tests:**
+   ```bash
+   make integration-test
+   make clean-integration-test
+   ```
+
+### Building
+
+- **Current platform:** `make miniflux`
+- **All platforms:** `make build`
+- **Specific platforms:** `make linux-amd64`, `make darwin-arm64`, etc.
+- **Docker image:** `make docker-image`
+
+### Cross-Platform Support
+
+Miniflux supports multiple architectures. When making changes, ensure compatibility across:
+- Linux (amd64, arm64, armv7, armv6, armv5)
+- macOS (amd64, arm64)
+- FreeBSD, OpenBSD, Windows (amd64)
+
+## Pull Request Guidelines
+
+### What Is Preferred
+
+✅ **Good Pull Requests:**
+
+- Focus on a single issue or feature
+- Include tests for new functionality
+- Maintain or improve performance
+- Follow existing code style and patterns
+- The commit messages follow the [conventional commit format](https://www.conventionalcommits.org/) (e.g., `feat: add new feature`, `fix: resolve bug`)
+- Update documentation when necessary
+
+### What to Avoid
+
+❌ **Pull Requests That Cannot Be Accepted:**
+
+- **Too many changes** - makes review difficult
+- **Breaking changes** - disrupts existing functionality
+- **New bugs or regressions** - reduces software quality
+- **Unnecessary dependencies** - conflicts with minimalist approach
+- **Performance degradation** - slows down the software
+- **Poor-quality code** - hard to maintain
+- **Dependent PRs** - creates review complexity
+- **Radical UI changes** - disrupts user experience
+- **Conflicts with philosophy** - doesn't align with minimalist approach
+
+### Pull Request Template
+
+When creating a pull request, please include:
+
+- **Description:** What does this PR do?
+- **Motivation:** Why is this change needed?
+- **Testing:** How was this tested?
+- **Breaking Changes:** Are there any breaking changes?
+- **Related Issues:** Link to any related issues
+
+## Code Style
+
+- Follow Go conventions and best practices
+- Use `gofmt` to format your Go code, and `jshint` for JavaScript
+- Write clear, descriptive variable and function names
+- Include comments for complex logic
+- Keep functions small and focused
+
+## Testing
+
+### Unit Tests
+- Write unit tests for new functions and methods
+- Ensure tests are fast and don't require external dependencies
+- Aim for good test coverage
+
+### Integration Tests
+- Add integration tests for new API endpoints
+- Tests run against a real PostgreSQL database
+- Ensure tests clean up after themselves
+
+## Communication
+
+- **Discussions:** Use GitHub Discussions for general questions and community interaction
+- **Issues:** Use GitHub issues for bug reports and feature requests
+- **Pull Requests:** Use PR comments for code-specific discussions
+- **Philosophy Questions:** Refer to the FAQ for common questions about project direction
+
+## Questions?
+
+- Check the [FAQ](https://miniflux.app/faq.html) for common questions
+- Review the [development documentation](https://miniflux.app/docs/development.html) and [internationalization guide](https://miniflux.app/docs/i18n.html)
+- Look at existing issues and pull requests for examples

Makefile

@@ -1,9 +1,7 @@
 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)'"
+VERSION         := $(shell git describe --tags --exact-match 2>/dev/null)
+LD_FLAGS        := "-s -w -X 'miniflux.app/v2/internal/version.Version=$(VERSION)'"
 PKG_LIST        := $(shell go list ./... | grep -v /vendor/)
 DB_URL          := postgres://postgres:postgres@localhost/miniflux_test?sslmode=disable
 DOCKER_PLATFORM := amd64
@@ -22,16 +20,12 @@ export PGPASSWORD := postgres
 	darwin-amd64 \
 	darwin-arm64 \
 	freebsd-amd64 \
-	freebsd-x86 \
 	openbsd-amd64 \
-	openbsd-x86 \
-	netbsd-x86 \
 	netbsd-amd64 \
-	windows-amd64 \
-	windows-x86 \
 	build \
 	run \
 	clean \
+	add-string \
 	test \
 	lint \
 	integration-test \
@@ -44,71 +38,48 @@ export PGPASSWORD := postgres
 	debian-packages
 
 miniflux:
-	@ go build -buildmode=pie -ldflags=$(LD_FLAGS) -o $(APP) main.go
+	@ go build -buildmode=pie -ldflags=$(LD_FLAGS) -o $(APP)
 
 miniflux-no-pie:
-	@ go build -ldflags=$(LD_FLAGS) -o $(APP) main.go
+	@ go build -ldflags=$(LD_FLAGS) -o $(APP)
 
 linux-amd64:
-	@ CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@ main.go
+	@ CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@
 	@ sha256sum $(APP)-$@ > $(APP)-$@.sha256
 
 linux-arm64:
-	@ CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@ main.go
+	@ CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@
 	@ sha256sum $(APP)-$@ > $(APP)-$@.sha256
 
 linux-armv7:
-	@ CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=7 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@ main.go
+	@ CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=7 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@
 	@ sha256sum $(APP)-$@ > $(APP)-$@.sha256
 
 linux-armv6:
-	@ CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=6 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@ main.go
+	@ CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=6 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@
 	@ sha256sum $(APP)-$@ > $(APP)-$@.sha256
 
 linux-armv5:
-	@ CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=5 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@ main.go
+	@ CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=5 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@
 	@ sha256sum $(APP)-$@ > $(APP)-$@.sha256
 
 darwin-amd64:
-	@ GOOS=darwin GOARCH=amd64 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@ main.go
+	@ GOOS=darwin GOARCH=amd64 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@
 	@ sha256sum $(APP)-$@ > $(APP)-$@.sha256
 
 darwin-arm64:
-	@ GOOS=darwin GOARCH=arm64 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@ main.go
+	@ GOOS=darwin GOARCH=arm64 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@
 	@ sha256sum $(APP)-$@ > $(APP)-$@.sha256
 
 freebsd-amd64:
-	@ CGO_ENABLED=0 GOOS=freebsd GOARCH=amd64 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@ main.go
+	@ CGO_ENABLED=0 GOOS=freebsd GOARCH=amd64 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@
 	@ sha256sum $(APP)-$@ > $(APP)-$@.sha256
 
 openbsd-amd64:
-	@ GOOS=openbsd GOARCH=amd64 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@ main.go
+	@ GOOS=openbsd GOARCH=amd64 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@
 	@ 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
-
-# NOTE: unsupported targets
-netbsd-amd64:
-	@ CGO_ENABLED=0 GOOS=netbsd GOARCH=amd64 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@ main.go
-
-linux-x86:
-	@ CGO_ENABLED=0 GOOS=linux GOARCH=386 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@ main.go
-
-freebsd-x86:
-	@ CGO_ENABLED=0 GOOS=freebsd GOARCH=386 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@ main.go
-
-netbsd-x86:
-	@ CGO_ENABLED=0 GOOS=netbsd GOARCH=386 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@ main.go
-
-openbsd-x86:
-	@ GOOS=openbsd GOARCH=386 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@ main.go
-
-windows-x86:
-	@ GOOS=windows GOARCH=386 go build -ldflags=$(LD_FLAGS) -o $(APP)-$@.exe main.go
+build: linux-amd64 linux-arm64 linux-armv7 linux-armv6 linux-armv5 darwin-amd64 darwin-arm64 freebsd-amd64 openbsd-amd64
 
 run:
 	@ LOG_DATE_TIME=1 LOG_LEVEL=debug RUN_MIGRATIONS=1 CREATE_ADMIN=1 ADMIN_USERNAME=admin ADMIN_PASSWORD=test123 go run main.go
@@ -116,7 +87,6 @@ run:
 clean:
 	@ rm -f $(APP)-* $(APP) $(APP)*.rpm $(APP)*.deb $(APP)*.exe $(APP)*.sha256
 
-.PHONY: add-string
 add-string:
 	cd internal/locale/translations && \
 	for file in *.json; do \
@@ -125,19 +95,17 @@ add-string:
 		mv tmp "$$file"; \
 	done
 
-
 test:
 	go test -cover -race -count=1 ./...
 
 lint:
 	go vet ./...
-	staticcheck ./...
-	golangci-lint run --disable errcheck --enable sqlclosecheck --enable misspell --enable gofmt --enable goimports --enable whitespace
+	gofmt -d -e .
+	golangci-lint run
 
 integration-test:
 	psql -U postgres -c 'drop database if exists miniflux_test;'
 	psql -U postgres -c 'create database miniflux_test;'
-	go build -o miniflux-test main.go
 
 	DATABASE_URL=$(DB_URL) \
 	ADMIN_USERNAME=admin \
@@ -145,7 +113,7 @@ integration-test:
 	CREATE_ADMIN=1 \
 	RUN_MIGRATIONS=1 \
 	LOG_LEVEL=debug \
-	./miniflux-test >/tmp/miniflux.log 2>&1 & echo "$$!" > "/tmp/miniflux.pid"
+	go run main.go >/tmp/miniflux.log 2>&1 & echo "$$!" > "/tmp/miniflux.pid"
 
 	while ! nc -z localhost 8080; do sleep 1; done
 
@@ -157,7 +125,6 @@ integration-test:
 clean-integration-test:
 	@ kill -9 `cat /tmp/miniflux.pid`
 	@ rm -f /tmp/miniflux.pid /tmp/miniflux.log
-	@ rm miniflux-test
 	@ psql -U postgres -c 'drop database if exists miniflux_test;'
 
 docker-image:

README.md

@@ -22,7 +22,7 @@ Features
 - Provides full-text search (powered by Postgres).
 - Available in 20 languages: Portuguese (Brazilian), Chinese (Simplified and Traditional), Dutch, English (US), Finnish, French, German, Greek, Hindi, Indonesian, Italian, Japanese, Polish, Romanian, Russian, Taiwanese POJ, Ukrainian, Spanish, and Turkish.
 
-### Privacy
+### Privacy and Security
 
 - Removes pixel trackers.
 - Strips tracking parameters from URLs (e.g., `utm_source`, `utm_medium`, `utm_campaign`, `fbclid`, etc.).
@@ -33,6 +33,8 @@ Features
 - Plays YouTube videos via the privacy-focused domain `youtube-nocookie.com`.
 - Supports alternative YouTube video players such as [Invidious](https://invidio.us).
 - Blocks external JavaScript to prevent tracking and enhance security.
+- Sanitizes external content before rendering it.
+- Enforces a [Content Security](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP) and a [Trusted Types Policy](https://developer.mozilla.org/en-US/docs/Web/API/Trusted_Types_API) to only application JavaScript and blocks inline scripts and styles. 
 
 ### Bot Protection Bypass Mechanisms
 
@@ -70,7 +72,7 @@ Features
 
 ### Integrations
 
-- 25+ integrations with third-party services: [Apprise](https://github.com/caronc/apprise), [Betula](https://sr.ht/~bouncepaw/betula/), [Cubox](https://cubox.cc/), [Discord](https://discord.com/), [Espial](https://github.com/jonschoning/espial), [Instapaper](https://www.instapaper.com/), [LinkAce](https://www.linkace.org/), [Linkding](https://github.com/sissbruecker/linkding), [LinkWarden](https://linkwarden.app/), [Matrix](https://matrix.org), [Notion](https://www.notion.com/), [Ntfy](https://ntfy.sh/), [Nunux Keeper](https://keeper.nunux.org/), [Pinboard](https://pinboard.in/), [Pocket](https://getpocket.com/), [Pushover](https://pushover.net), [RainDrop](https://raindrop.io/), [Readeck](https://readeck.org/en/), [Readwise Reader](https://readwise.io/read), [RssBridge](https://rss-bridge.org/), [Shaarli](https://github.com/shaarli/Shaarli), [Shiori](https://github.com/go-shiori/shiori), [Slack](https://slack.com/), [Telegram](https://telegram.org), [Wallabag](https://www.wallabag.org/), etc.
+- 25+ integrations with third-party services: [Apprise](https://github.com/caronc/apprise), [Betula](https://sr.ht/~bouncepaw/betula/), [Cubox](https://cubox.cc/), [Discord](https://discord.com/), [Espial](https://github.com/jonschoning/espial), [Instapaper](https://www.instapaper.com/), [LinkAce](https://www.linkace.org/), [Linkding](https://github.com/sissbruecker/linkding), [LinkTaco](https://linktaco.com), [LinkWarden](https://linkwarden.app/), [Matrix](https://matrix.org), [Notion](https://www.notion.com/), [Ntfy](https://ntfy.sh/), [Nunux Keeper](https://keeper.nunux.org/), [Pinboard](https://pinboard.in/), [Pushover](https://pushover.net), [RainDrop](https://raindrop.io/), [Readeck](https://readeck.org/en/), [Readwise Reader](https://readwise.io/read), [RssBridge](https://rss-bridge.org/), [Shaarli](https://github.com/shaarli/Shaarli), [Shiori](https://github.com/go-shiori/shiori), [Slack](https://slack.com/), [Telegram](https://telegram.org), [Wallabag](https://www.wallabag.org/), etc.
 - Bookmarklet for subscribing to websites directly from any web browser.
 - Webhooks for real-time notifications or custom integrations.
 - Compatibility with existing mobile applications using the Fever or Google Reader API.
@@ -97,13 +99,15 @@ Features
 - Allows the use of custom <abbr title="Secure Sockets Layer">SSL</abbr> certificates.
 - Supports [HTTP/2](https://en.wikipedia.org/wiki/HTTP/2) when TLS is enabled.
 - Updates feeds in the background using an internal scheduler or a traditional cron job.
-- Sanitizes external content before rendering it.
-- Enforces a [Content Security Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP) that permits only application JavaScript and blocks inline scripts and styles.
 - Uses native lazy loading for images and iframes.
 - Compatible only with modern browsers.
 - Adheres to the [Twelve-Factor App](https://12factor.net/) methodology.
 - Provides official Debian/RPM packages and pre-built binaries.
 - Publishes a Docker image to Docker Hub, GitHub Registry, and Quay.io Registry, with ARM architecture support.
+- Uses a limited amount of third-party go dependencies
+- Has a comprehensive testsuite, with both unit tests and integration tests.
+- Only uses a couple of MB of memory and a negligible amount of CPU, even with several hundreds of feeds.
+- Respects/sends Last-Modified, If-Modified-Since, If-None-Match, Cache-Control, Expires and ETags headers, and has a default polling interval of 1h.
 
 Documentation
 -------------

client/client.go

@@ -4,9 +4,11 @@
 package client // import "miniflux.app/v2/client"
 
 import (
+	"context"
 	"encoding/json"
 	"fmt"
 	"io"
+	"net/http"
 	"net/url"
 	"strconv"
 	"strings"
@@ -26,22 +28,45 @@ func New(endpoint string, credentials ...string) *Client {
 
 // NewClient returns a new Miniflux client.
 func NewClient(endpoint string, credentials ...string) *Client {
+	switch len(credentials) {
+	case 2:
+		return NewClientWithOptions(endpoint, WithCredentials(credentials[0], credentials[1]))
+	case 1:
+		return NewClientWithOptions(endpoint, WithAPIKey(credentials[0]))
+	default:
+		return NewClientWithOptions(endpoint)
+	}
+}
+
+// NewClientWithOptions returns a new Miniflux client with options.
+func NewClientWithOptions(endpoint string, options ...Option) *Client {
 	// Trim trailing slashes and /v1 from the endpoint.
 	endpoint = strings.TrimSuffix(endpoint, "/")
 	endpoint = strings.TrimSuffix(endpoint, "/v1")
-	switch len(credentials) {
-	case 2:
-		return &Client{request: &request{endpoint: endpoint, username: credentials[0], password: credentials[1]}}
-	case 1:
-		return &Client{request: &request{endpoint: endpoint, apiKey: credentials[0]}}
-	default:
-		return &Client{request: &request{endpoint: endpoint}}
+	request := &request{endpoint: endpoint, client: http.DefaultClient}
+
+	for _, option := range options {
+		option(request)
 	}
+
+	return &Client{request: request}
+}
+
+func withDefaultTimeout() (context.Context, func()) {
+	ctx, cancel := context.WithTimeout(context.Background(), defaultTimeout)
+	return ctx, cancel
 }
 
 // Healthcheck checks if the application is up and running.
 func (c *Client) Healthcheck() error {
-	body, err := c.request.Get("/healthcheck")
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.HealthcheckContext(ctx)
+}
+
+// HealthcheckContext checks if the application is up and running.
+func (c *Client) HealthcheckContext(ctx context.Context) error {
+	body, err := c.request.Get(ctx, "/healthcheck")
 	if err != nil {
 		return fmt.Errorf("miniflux: unable to perform healthcheck: %w", err)
 	}
@@ -61,7 +86,14 @@ func (c *Client) Healthcheck() error {
 
 // Version returns the version of the Miniflux instance.
 func (c *Client) Version() (*VersionResponse, error) {
-	body, err := c.request.Get("/v1/version")
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.VersionContext(ctx)
+}
+
+// VersionContext returns the version of the Miniflux instance.
+func (c *Client) VersionContext(ctx context.Context) (*VersionResponse, error) {
+	body, err := c.request.Get(ctx, "/v1/version")
 	if err != nil {
 		return nil, err
 	}
@@ -77,7 +109,14 @@ func (c *Client) Version() (*VersionResponse, error) {
 
 // Me returns the logged user information.
 func (c *Client) Me() (*User, error) {
-	body, err := c.request.Get("/v1/me")
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.MeContext(ctx)
+}
+
+// MeContext returns the logged user information.
+func (c *Client) MeContext(ctx context.Context) (*User, error) {
+	body, err := c.request.Get(ctx, "/v1/me")
 	if err != nil {
 		return nil, err
 	}
@@ -93,7 +132,14 @@ func (c *Client) Me() (*User, error) {
 
 // Users returns all users.
 func (c *Client) Users() (Users, error) {
-	body, err := c.request.Get("/v1/users")
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.UsersContext(ctx)
+}
+
+// UsersContext returns all users.
+func (c *Client) UsersContext(ctx context.Context) (Users, error) {
+	body, err := c.request.Get(ctx, "/v1/users")
 	if err != nil {
 		return nil, err
 	}
@@ -109,7 +155,14 @@ func (c *Client) Users() (Users, error) {
 
 // UserByID returns a single user.
 func (c *Client) UserByID(userID int64) (*User, error) {
-	body, err := c.request.Get(fmt.Sprintf("/v1/users/%d", userID))
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.UserByIDContext(ctx, userID)
+}
+
+// UserByIDContext returns a single user.
+func (c *Client) UserByIDContext(ctx context.Context, userID int64) (*User, error) {
+	body, err := c.request.Get(ctx, fmt.Sprintf("/v1/users/%d", userID))
 	if err != nil {
 		return nil, err
 	}
@@ -125,7 +178,14 @@ func (c *Client) UserByID(userID int64) (*User, error) {
 
 // UserByUsername returns a single user.
 func (c *Client) UserByUsername(username string) (*User, error) {
-	body, err := c.request.Get(fmt.Sprintf("/v1/users/%s", username))
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.UserByUsernameContext(ctx, username)
+}
+
+// UserByUsernameContext returns a single user.
+func (c *Client) UserByUsernameContext(ctx context.Context, username string) (*User, error) {
+	body, err := c.request.Get(ctx, "/v1/users/"+username)
 	if err != nil {
 		return nil, err
 	}
@@ -141,7 +201,14 @@ func (c *Client) UserByUsername(username string) (*User, error) {
 
 // CreateUser creates a new user in the system.
 func (c *Client) CreateUser(username, password string, isAdmin bool) (*User, error) {
-	body, err := c.request.Post("/v1/users", &UserCreationRequest{
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.CreateUserContext(ctx, username, password, isAdmin)
+}
+
+// CreateUserContext creates a new user in the system.
+func (c *Client) CreateUserContext(ctx context.Context, username, password string, isAdmin bool) (*User, error) {
+	body, err := c.request.Post(ctx, "/v1/users", &UserCreationRequest{
 		Username: username,
 		Password: password,
 		IsAdmin:  isAdmin,
@@ -161,7 +228,14 @@ func (c *Client) CreateUser(username, password string, isAdmin bool) (*User, err
 
 // UpdateUser updates a user in the system.
 func (c *Client) UpdateUser(userID int64, userChanges *UserModificationRequest) (*User, error) {
-	body, err := c.request.Put(fmt.Sprintf("/v1/users/%d", userID), userChanges)
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.UpdateUserContext(ctx, userID, userChanges)
+}
+
+// UpdateUserContext updates a user in the system.
+func (c *Client) UpdateUserContext(ctx context.Context, userID int64, userChanges *UserModificationRequest) (*User, error) {
+	body, err := c.request.Put(ctx, fmt.Sprintf("/v1/users/%d", userID), userChanges)
 	if err != nil {
 		return nil, err
 	}
@@ -177,12 +251,26 @@ func (c *Client) UpdateUser(userID int64, userChanges *UserModificationRequest)
 
 // DeleteUser removes a user from the system.
 func (c *Client) DeleteUser(userID int64) error {
-	return c.request.Delete(fmt.Sprintf("/v1/users/%d", userID))
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.DeleteUserContext(ctx, userID)
+}
+
+// DeleteUserContext removes a user from the system.
+func (c *Client) DeleteUserContext(ctx context.Context, userID int64) error {
+	return c.request.Delete(ctx, fmt.Sprintf("/v1/users/%d", userID))
 }
 
 // APIKeys returns all API keys for the authenticated user.
 func (c *Client) APIKeys() (APIKeys, error) {
-	body, err := c.request.Get("/v1/api-keys")
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.APIKeysContext(ctx)
+}
+
+// APIKeysContext returns all API keys for the authenticated user.
+func (c *Client) APIKeysContext(ctx context.Context) (APIKeys, error) {
+	body, err := c.request.Get(ctx, "/v1/api-keys")
 	if err != nil {
 		return nil, err
 	}
@@ -198,7 +286,14 @@ func (c *Client) APIKeys() (APIKeys, error) {
 
 // CreateAPIKey creates a new API key for the authenticated user.
 func (c *Client) CreateAPIKey(description string) (*APIKey, error) {
-	body, err := c.request.Post("/v1/api-keys", &APIKeyCreationRequest{
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.CreateAPIKeyContext(ctx, description)
+}
+
+// CreateAPIKeyContext creates a new API key for the authenticated user.
+func (c *Client) CreateAPIKeyContext(ctx context.Context, description string) (*APIKey, error) {
+	body, err := c.request.Post(ctx, "/v1/api-keys", &APIKeyCreationRequest{
 		Description: description,
 	})
 	if err != nil {
@@ -216,18 +311,39 @@ func (c *Client) CreateAPIKey(description string) (*APIKey, error) {
 
 // DeleteAPIKey removes an API key for the authenticated user.
 func (c *Client) DeleteAPIKey(apiKeyID int64) error {
-	return c.request.Delete(fmt.Sprintf("/v1/api-keys/%d", apiKeyID))
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.DeleteAPIKeyContext(ctx, apiKeyID)
+}
+
+// DeleteAPIKeyContext removes an API key for the authenticated user.
+func (c *Client) DeleteAPIKeyContext(ctx context.Context, apiKeyID int64) error {
+	return c.request.Delete(ctx, fmt.Sprintf("/v1/api-keys/%d", apiKeyID))
 }
 
 // MarkAllAsRead marks all unread entries as read for a given user.
 func (c *Client) MarkAllAsRead(userID int64) error {
-	_, err := c.request.Put(fmt.Sprintf("/v1/users/%d/mark-all-as-read", userID), nil)
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.MarkAllAsReadContext(ctx, userID)
+}
+
+// MarkAllAsReadContext marks all unread entries as read for a given user.
+func (c *Client) MarkAllAsReadContext(ctx context.Context, userID int64) error {
+	_, err := c.request.Put(ctx, fmt.Sprintf("/v1/users/%d/mark-all-as-read", userID), nil)
 	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")
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.IntegrationsStatusContext(ctx)
+}
+
+// IntegrationsStatusContext fetches the integrations status for the logged user.
+func (c *Client) IntegrationsStatusContext(ctx context.Context) (bool, error) {
+	body, err := c.request.Get(ctx, "/v1/integrations/status")
 	if err != nil {
 		return false, err
 	}
@@ -246,7 +362,14 @@ func (c *Client) IntegrationsStatus() (bool, error) {
 
 // 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})
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.DiscoverContext(ctx, url)
+}
+
+// DiscoverContext tries to find subscriptions from a website.
+func (c *Client) DiscoverContext(ctx context.Context, url string) (Subscriptions, error) {
+	body, err := c.request.Post(ctx, "/v1/discover", map[string]string{"url": url})
 	if err != nil {
 		return nil, err
 	}
@@ -262,7 +385,37 @@ func (c *Client) Discover(url string) (Subscriptions, error) {
 
 // Categories gets the list of categories.
 func (c *Client) Categories() (Categories, error) {
-	body, err := c.request.Get("/v1/categories")
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.CategoriesContext(ctx)
+}
+
+// CategoriesContext gets the list of categories.
+func (c *Client) CategoriesContext(ctx context.Context) (Categories, error) {
+	body, err := c.request.Get(ctx, "/v1/categories")
+	if err != nil {
+		return nil, err
+	}
+	defer body.Close()
+
+	var categories Categories
+	if err := json.NewDecoder(body).Decode(&categories); err != nil {
+		return nil, fmt.Errorf("miniflux: response error (%v)", err)
+	}
+
+	return categories, nil
+}
+
+// CategoriesWithCounters fetches the categories with their respective feed and unread counts.
+func (c *Client) CategoriesWithCounters() (Categories, error) {
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.CategoriesWithCountersContext(ctx)
+}
+
+// CategoriesWithCountersContext fetches the categories with their respective feed and unread counts.
+func (c *Client) CategoriesWithCountersContext(ctx context.Context) (Categories, error) {
+	body, err := c.request.Get(ctx, "/v1/categories?counts=true")
 	if err != nil {
 		return nil, err
 	}
@@ -278,7 +431,14 @@ func (c *Client) Categories() (Categories, error) {
 
 // CreateCategory creates a new category.
 func (c *Client) CreateCategory(title string) (*Category, error) {
-	body, err := c.request.Post("/v1/categories", &CategoryCreationRequest{
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.CreateCategoryContext(ctx, title)
+}
+
+// CreateCategoryContext creates a new category.
+func (c *Client) CreateCategoryContext(ctx context.Context, title string) (*Category, error) {
+	body, err := c.request.Post(ctx, "/v1/categories", &CategoryCreationRequest{
 		Title: title,
 	})
 	if err != nil {
@@ -296,7 +456,14 @@ func (c *Client) CreateCategory(title string) (*Category, error) {
 
 // CreateCategoryWithOptions creates a new category with options.
 func (c *Client) CreateCategoryWithOptions(createRequest *CategoryCreationRequest) (*Category, error) {
-	body, err := c.request.Post("/v1/categories", createRequest)
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.CreateCategoryWithOptionsContext(ctx, createRequest)
+}
+
+// CreateCategoryWithOptionsContext creates a new category with options.
+func (c *Client) CreateCategoryWithOptionsContext(ctx context.Context, createRequest *CategoryCreationRequest) (*Category, error) {
+	body, err := c.request.Post(ctx, "/v1/categories", createRequest)
 	if err != nil {
 		return nil, err
 	}
@@ -311,7 +478,14 @@ func (c *Client) CreateCategoryWithOptions(createRequest *CategoryCreationReques
 
 // UpdateCategory updates a category.
 func (c *Client) UpdateCategory(categoryID int64, title string) (*Category, error) {
-	body, err := c.request.Put(fmt.Sprintf("/v1/categories/%d", categoryID), &CategoryModificationRequest{
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.UpdateCategoryContext(ctx, categoryID, title)
+}
+
+// UpdateCategoryContext updates a category.
+func (c *Client) UpdateCategoryContext(ctx context.Context, categoryID int64, title string) (*Category, error) {
+	body, err := c.request.Put(ctx, fmt.Sprintf("/v1/categories/%d", categoryID), &CategoryModificationRequest{
 		Title: SetOptionalField(title),
 	})
 	if err != nil {
@@ -329,7 +503,14 @@ func (c *Client) UpdateCategory(categoryID int64, title string) (*Category, erro
 
 // UpdateCategoryWithOptions updates a category with options.
 func (c *Client) UpdateCategoryWithOptions(categoryID int64, categoryChanges *CategoryModificationRequest) (*Category, error) {
-	body, err := c.request.Put(fmt.Sprintf("/v1/categories/%d", categoryID), categoryChanges)
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.UpdateCategoryWithOptionsContext(ctx, categoryID, categoryChanges)
+}
+
+// UpdateCategoryWithOptionsContext updates a category with options.
+func (c *Client) UpdateCategoryWithOptionsContext(ctx context.Context, categoryID int64, categoryChanges *CategoryModificationRequest) (*Category, error) {
+	body, err := c.request.Put(ctx, fmt.Sprintf("/v1/categories/%d", categoryID), categoryChanges)
 	if err != nil {
 		return nil, err
 	}
@@ -345,13 +526,27 @@ func (c *Client) UpdateCategoryWithOptions(categoryID int64, categoryChanges *Ca
 
 // MarkCategoryAsRead marks all unread entries in a category as read.
 func (c *Client) MarkCategoryAsRead(categoryID int64) error {
-	_, err := c.request.Put(fmt.Sprintf("/v1/categories/%d/mark-all-as-read", categoryID), nil)
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.MarkCategoryAsReadContext(ctx, categoryID)
+}
+
+// MarkCategoryAsReadContext marks all unread entries in a category as read.
+func (c *Client) MarkCategoryAsReadContext(ctx context.Context, categoryID int64) error {
+	_, err := c.request.Put(ctx, fmt.Sprintf("/v1/categories/%d/mark-all-as-read", categoryID), nil)
 	return err
 }
 
 // CategoryFeeds gets feeds of a category.
 func (c *Client) CategoryFeeds(categoryID int64) (Feeds, error) {
-	body, err := c.request.Get(fmt.Sprintf("/v1/categories/%d/feeds", categoryID))
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.CategoryFeedsContext(ctx, categoryID)
+}
+
+// CategoryFeedsContext gets feeds of a category.
+func (c *Client) CategoryFeedsContext(ctx context.Context, categoryID int64) (Feeds, error) {
+	body, err := c.request.Get(ctx, fmt.Sprintf("/v1/categories/%d/feeds", categoryID))
 	if err != nil {
 		return nil, err
 	}
@@ -367,18 +562,39 @@ func (c *Client) CategoryFeeds(categoryID int64) (Feeds, error) {
 
 // DeleteCategory removes a category.
 func (c *Client) DeleteCategory(categoryID int64) error {
-	return c.request.Delete(fmt.Sprintf("/v1/categories/%d", categoryID))
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.DeleteCategoryContext(ctx, categoryID)
+}
+
+// DeleteCategoryContext removes a category.
+func (c *Client) DeleteCategoryContext(ctx context.Context, categoryID int64) error {
+	return c.request.Delete(ctx, fmt.Sprintf("/v1/categories/%d", categoryID))
 }
 
 // RefreshCategory refreshes a category.
 func (c *Client) RefreshCategory(categoryID int64) error {
-	_, err := c.request.Put(fmt.Sprintf("/v1/categories/%d/refresh", categoryID), nil)
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.RefreshCategoryContext(ctx, categoryID)
+}
+
+// RefreshCategoryContext refreshes a category.
+func (c *Client) RefreshCategoryContext(ctx context.Context, categoryID int64) error {
+	_, err := c.request.Put(ctx, fmt.Sprintf("/v1/categories/%d/refresh", categoryID), nil)
 	return err
 }
 
 // Feeds gets all feeds.
 func (c *Client) Feeds() (Feeds, error) {
-	body, err := c.request.Get("/v1/feeds")
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.FeedsContext(ctx)
+}
+
+// FeedsContext gets all feeds.
+func (c *Client) FeedsContext(ctx context.Context) (Feeds, error) {
+	body, err := c.request.Get(ctx, "/v1/feeds")
 	if err != nil {
 		return nil, err
 	}
@@ -394,7 +610,14 @@ func (c *Client) Feeds() (Feeds, error) {
 
 // Export creates OPML file.
 func (c *Client) Export() ([]byte, error) {
-	body, err := c.request.Get("/v1/export")
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.ExportContext(ctx)
+}
+
+// ExportContext creates OPML file.
+func (c *Client) ExportContext(ctx context.Context) ([]byte, error) {
+	body, err := c.request.Get(ctx, "/v1/export")
 	if err != nil {
 		return nil, err
 	}
@@ -410,13 +633,27 @@ func (c *Client) Export() ([]byte, error) {
 
 // Import imports an OPML file.
 func (c *Client) Import(f io.ReadCloser) error {
-	_, err := c.request.PostFile("/v1/import", f)
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.ImportContext(ctx, f)
+}
+
+// ImportContext imports an OPML file.
+func (c *Client) ImportContext(ctx context.Context, f io.ReadCloser) error {
+	_, err := c.request.PostFile(ctx, "/v1/import", f)
 	return err
 }
 
 // Feed gets a feed.
 func (c *Client) Feed(feedID int64) (*Feed, error) {
-	body, err := c.request.Get(fmt.Sprintf("/v1/feeds/%d", feedID))
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.FeedContext(ctx, feedID)
+}
+
+// FeedContext gets a feed.
+func (c *Client) FeedContext(ctx context.Context, feedID int64) (*Feed, error) {
+	body, err := c.request.Get(ctx, fmt.Sprintf("/v1/feeds/%d", feedID))
 	if err != nil {
 		return nil, err
 	}
@@ -432,7 +669,14 @@ func (c *Client) Feed(feedID int64) (*Feed, error) {
 
 // CreateFeed creates a new feed.
 func (c *Client) CreateFeed(feedCreationRequest *FeedCreationRequest) (int64, error) {
-	body, err := c.request.Post("/v1/feeds", feedCreationRequest)
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.CreateFeedContext(ctx, feedCreationRequest)
+}
+
+// CreateFeedContext creates a new feed.
+func (c *Client) CreateFeedContext(ctx context.Context, feedCreationRequest *FeedCreationRequest) (int64, error) {
+	body, err := c.request.Post(ctx, "/v1/feeds", feedCreationRequest)
 	if err != nil {
 		return 0, err
 	}
@@ -452,7 +696,14 @@ func (c *Client) CreateFeed(feedCreationRequest *FeedCreationRequest) (int64, er
 
 // UpdateFeed updates a feed.
 func (c *Client) UpdateFeed(feedID int64, feedChanges *FeedModificationRequest) (*Feed, error) {
-	body, err := c.request.Put(fmt.Sprintf("/v1/feeds/%d", feedID), feedChanges)
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.UpdateFeedContext(ctx, feedID, feedChanges)
+}
+
+// UpdateFeedContext updates a feed.
+func (c *Client) UpdateFeedContext(ctx context.Context, feedID int64, feedChanges *FeedModificationRequest) (*Feed, error) {
+	body, err := c.request.Put(ctx, fmt.Sprintf("/v1/feeds/%d", feedID), feedChanges)
 	if err != nil {
 		return nil, err
 	}
@@ -468,30 +719,65 @@ func (c *Client) UpdateFeed(feedID int64, feedChanges *FeedModificationRequest)
 
 // MarkFeedAsRead marks all unread entries of the feed as read.
 func (c *Client) MarkFeedAsRead(feedID int64) error {
-	_, err := c.request.Put(fmt.Sprintf("/v1/feeds/%d/mark-all-as-read", feedID), nil)
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.MarkFeedAsReadContext(ctx, feedID)
+}
+
+// MarkFeedAsReadContext marks all unread entries of the feed as read.
+func (c *Client) MarkFeedAsReadContext(ctx context.Context, feedID int64) error {
+	_, err := c.request.Put(ctx, fmt.Sprintf("/v1/feeds/%d/mark-all-as-read", feedID), nil)
 	return err
 }
 
 // RefreshAllFeeds refreshes all feeds.
 func (c *Client) RefreshAllFeeds() error {
-	_, err := c.request.Put("/v1/feeds/refresh", nil)
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.RefreshAllFeedsContext(ctx)
+}
+
+// RefreshAllFeedsContext refreshes all feeds.
+func (c *Client) RefreshAllFeedsContext(ctx context.Context) error {
+	_, err := c.request.Put(ctx, "/v1/feeds/refresh", nil)
 	return err
 }
 
 // RefreshFeed refreshes a feed.
 func (c *Client) RefreshFeed(feedID int64) error {
-	_, err := c.request.Put(fmt.Sprintf("/v1/feeds/%d/refresh", feedID), nil)
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.RefreshFeedContext(ctx, feedID)
+}
+
+// RefreshFeedContext refreshes a feed.
+func (c *Client) RefreshFeedContext(ctx context.Context, feedID int64) error {
+	_, err := c.request.Put(ctx, fmt.Sprintf("/v1/feeds/%d/refresh", feedID), nil)
 	return err
 }
 
 // DeleteFeed removes a feed.
 func (c *Client) DeleteFeed(feedID int64) error {
-	return c.request.Delete(fmt.Sprintf("/v1/feeds/%d", feedID))
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.DeleteFeedContext(ctx, feedID)
+}
+
+// DeleteFeedContext removes a feed.
+func (c *Client) DeleteFeedContext(ctx context.Context, feedID int64) error {
+	return c.request.Delete(ctx, fmt.Sprintf("/v1/feeds/%d", feedID))
 }
 
 // FeedIcon gets a feed icon.
 func (c *Client) FeedIcon(feedID int64) (*FeedIcon, error) {
-	body, err := c.request.Get(fmt.Sprintf("/v1/feeds/%d/icon", feedID))
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.FeedIconContext(ctx, feedID)
+}
+
+// FeedIconContext gets a feed icon.
+func (c *Client) FeedIconContext(ctx context.Context, feedID int64) (*FeedIcon, error) {
+	body, err := c.request.Get(ctx, fmt.Sprintf("/v1/feeds/%d/icon", feedID))
 	if err != nil {
 		return nil, err
 	}
@@ -507,7 +793,14 @@ func (c *Client) FeedIcon(feedID int64) (*FeedIcon, error) {
 
 // FeedEntry gets a single feed entry.
 func (c *Client) FeedEntry(feedID, entryID int64) (*Entry, error) {
-	body, err := c.request.Get(fmt.Sprintf("/v1/feeds/%d/entries/%d", feedID, entryID))
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.FeedEntryContext(ctx, feedID, entryID)
+}
+
+// FeedEntryContext gets a single feed entry.
+func (c *Client) FeedEntryContext(ctx context.Context, feedID, entryID int64) (*Entry, error) {
+	body, err := c.request.Get(ctx, fmt.Sprintf("/v1/feeds/%d/entries/%d", feedID, entryID))
 	if err != nil {
 		return nil, err
 	}
@@ -523,7 +816,14 @@ func (c *Client) FeedEntry(feedID, entryID int64) (*Entry, error) {
 
 // CategoryEntry gets a single category entry.
 func (c *Client) CategoryEntry(categoryID, entryID int64) (*Entry, error) {
-	body, err := c.request.Get(fmt.Sprintf("/v1/categories/%d/entries/%d", categoryID, entryID))
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.CategoryEntryContext(ctx, categoryID, entryID)
+}
+
+// CategoryEntryContext gets a single category entry.
+func (c *Client) CategoryEntryContext(ctx context.Context, categoryID, entryID int64) (*Entry, error) {
+	body, err := c.request.Get(ctx, fmt.Sprintf("/v1/categories/%d/entries/%d", categoryID, entryID))
 	if err != nil {
 		return nil, err
 	}
@@ -539,7 +839,14 @@ func (c *Client) CategoryEntry(categoryID, entryID int64) (*Entry, error) {
 
 // Entry gets a single entry.
 func (c *Client) Entry(entryID int64) (*Entry, error) {
-	body, err := c.request.Get(fmt.Sprintf("/v1/entries/%d", entryID))
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.EntryContext(ctx, entryID)
+}
+
+// EntryContext gets a single entry.
+func (c *Client) EntryContext(ctx context.Context, entryID int64) (*Entry, error) {
+	body, err := c.request.Get(ctx, fmt.Sprintf("/v1/entries/%d", entryID))
 	if err != nil {
 		return nil, err
 	}
@@ -555,9 +862,16 @@ func (c *Client) Entry(entryID int64) (*Entry, error) {
 
 // Entries fetch entries.
 func (c *Client) Entries(filter *Filter) (*EntryResultSet, error) {
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.EntriesContext(ctx, filter)
+}
+
+// EntriesContext fetches entries.
+func (c *Client) EntriesContext(ctx context.Context, filter *Filter) (*EntryResultSet, error) {
 	path := buildFilterQueryString("/v1/entries", filter)
 
-	body, err := c.request.Get(path)
+	body, err := c.request.Get(ctx, path)
 	if err != nil {
 		return nil, err
 	}
@@ -573,9 +887,16 @@ func (c *Client) Entries(filter *Filter) (*EntryResultSet, error) {
 
 // FeedEntries fetch feed entries.
 func (c *Client) FeedEntries(feedID int64, filter *Filter) (*EntryResultSet, error) {
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.FeedEntriesContext(ctx, feedID, filter)
+}
+
+// FeedEntriesContext fetches feed entries.
+func (c *Client) FeedEntriesContext(ctx context.Context, feedID int64, filter *Filter) (*EntryResultSet, error) {
 	path := buildFilterQueryString(fmt.Sprintf("/v1/feeds/%d/entries", feedID), filter)
 
-	body, err := c.request.Get(path)
+	body, err := c.request.Get(ctx, path)
 	if err != nil {
 		return nil, err
 	}
@@ -591,9 +912,16 @@ func (c *Client) FeedEntries(feedID int64, filter *Filter) (*EntryResultSet, err
 
 // CategoryEntries fetch entries of a category.
 func (c *Client) CategoryEntries(categoryID int64, filter *Filter) (*EntryResultSet, error) {
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.CategoryEntriesContext(ctx, categoryID, filter)
+}
+
+// CategoryEntriesContext fetches category entries.
+func (c *Client) CategoryEntriesContext(ctx context.Context, categoryID int64, filter *Filter) (*EntryResultSet, error) {
 	path := buildFilterQueryString(fmt.Sprintf("/v1/categories/%d/entries", categoryID), filter)
 
-	body, err := c.request.Get(path)
+	body, err := c.request.Get(ctx, path)
 	if err != nil {
 		return nil, err
 	}
@@ -609,18 +937,32 @@ func (c *Client) CategoryEntries(categoryID int64, filter *Filter) (*EntryResult
 
 // UpdateEntries updates the status of a list of entries.
 func (c *Client) UpdateEntries(entryIDs []int64, status string) error {
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.UpdateEntriesContext(ctx, entryIDs, status)
+}
+
+// UpdateEntriesContext updates the status of a list of entries.
+func (c *Client) UpdateEntriesContext(ctx context.Context, entryIDs []int64, status string) error {
 	type payload struct {
 		EntryIDs []int64 `json:"entry_ids"`
 		Status   string  `json:"status"`
 	}
 
-	_, err := c.request.Put("/v1/entries", &payload{EntryIDs: entryIDs, Status: status})
+	_, err := c.request.Put(ctx, "/v1/entries", &payload{EntryIDs: entryIDs, Status: status})
 	return err
 }
 
 // UpdateEntry updates an entry.
 func (c *Client) UpdateEntry(entryID int64, entryChanges *EntryModificationRequest) (*Entry, error) {
-	body, err := c.request.Put(fmt.Sprintf("/v1/entries/%d", entryID), entryChanges)
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.UpdateEntryContext(ctx, entryID, entryChanges)
+}
+
+// UpdateEntryContext updates an entry.
+func (c *Client) UpdateEntryContext(ctx context.Context, entryID int64, entryChanges *EntryModificationRequest) (*Entry, error) {
+	body, err := c.request.Put(ctx, fmt.Sprintf("/v1/entries/%d", entryID), entryChanges)
 	if err != nil {
 		return nil, err
 	}
@@ -634,21 +976,42 @@ func (c *Client) UpdateEntry(entryID int64, entryChanges *EntryModificationReque
 	return entry, nil
 }
 
-// ToggleBookmark toggles entry bookmark value.
-func (c *Client) ToggleBookmark(entryID int64) error {
-	_, err := c.request.Put(fmt.Sprintf("/v1/entries/%d/bookmark", entryID), nil)
+// ToggleStarred toggles entry starred value.
+func (c *Client) ToggleStarred(entryID int64) error {
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.ToggleStarredContext(ctx, entryID)
+}
+
+// ToggleStarredContext toggles entry starred value.
+func (c *Client) ToggleStarredContext(ctx context.Context, entryID int64) error {
+	_, err := c.request.Put(ctx, fmt.Sprintf("/v1/entries/%d/star", entryID), nil)
 	return err
 }
 
 // SaveEntry sends an entry to a third-party service.
 func (c *Client) SaveEntry(entryID int64) error {
-	_, err := c.request.Post(fmt.Sprintf("/v1/entries/%d/save", entryID), nil)
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.SaveEntryContext(ctx, entryID)
+}
+
+// SaveEntryContext sends an entry to a third-party service.
+func (c *Client) SaveEntryContext(ctx context.Context, entryID int64) error {
+	_, err := c.request.Post(ctx, fmt.Sprintf("/v1/entries/%d/save", entryID), nil)
 	return err
 }
 
 // FetchEntryOriginalContent fetches the original content of an entry using the scraper.
 func (c *Client) FetchEntryOriginalContent(entryID int64) (string, error) {
-	body, err := c.request.Get(fmt.Sprintf("/v1/entries/%d/fetch-content", entryID))
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.FetchEntryOriginalContentContext(ctx, entryID)
+}
+
+// FetchEntryOriginalContentContext fetches the original content of an entry using the scraper.
+func (c *Client) FetchEntryOriginalContentContext(ctx context.Context, entryID int64) (string, error) {
+	body, err := c.request.Get(ctx, fmt.Sprintf("/v1/entries/%d/fetch-content", entryID))
 	if err != nil {
 		return "", err
 	}
@@ -667,7 +1030,14 @@ func (c *Client) FetchEntryOriginalContent(entryID int64) (string, error) {
 
 // FetchCounters fetches feed counters.
 func (c *Client) FetchCounters() (*FeedCounters, error) {
-	body, err := c.request.Get("/v1/feeds/counters")
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.FetchCountersContext(ctx)
+}
+
+// FetchCountersContext fetches feed counters.
+func (c *Client) FetchCountersContext(ctx context.Context) (*FeedCounters, error) {
+	body, err := c.request.Get(ctx, "/v1/feeds/counters")
 	if err != nil {
 		return nil, err
 	}
@@ -683,13 +1053,27 @@ func (c *Client) FetchCounters() (*FeedCounters, error) {
 
 // FlushHistory changes all entries with the status "read" to "removed".
 func (c *Client) FlushHistory() error {
-	_, err := c.request.Put("/v1/flush-history", nil)
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.FlushHistoryContext(ctx)
+}
+
+// FlushHistoryContext changes all entries with the status "read" to "removed".
+func (c *Client) FlushHistoryContext(ctx context.Context) error {
+	_, err := c.request.Put(ctx, "/v1/flush-history", nil)
 	return err
 }
 
 // Icon fetches a feed icon.
 func (c *Client) Icon(iconID int64) (*FeedIcon, error) {
-	body, err := c.request.Get(fmt.Sprintf("/v1/icons/%d", iconID))
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.IconContext(ctx, iconID)
+}
+
+// IconContext fetches a feed icon.
+func (c *Client) IconContext(ctx context.Context, iconID int64) (*FeedIcon, error) {
+	body, err := c.request.Get(ctx, fmt.Sprintf("/v1/icons/%d", iconID))
 	if err != nil {
 		return nil, err
 	}
@@ -705,7 +1089,14 @@ func (c *Client) Icon(iconID int64) (*FeedIcon, error) {
 
 // Enclosure fetches a specific enclosure.
 func (c *Client) Enclosure(enclosureID int64) (*Enclosure, error) {
-	body, err := c.request.Get(fmt.Sprintf("/v1/enclosures/%d", enclosureID))
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.EnclosureContext(ctx, enclosureID)
+}
+
+// EnclosureContext fetches a specific enclosure.
+func (c *Client) EnclosureContext(ctx context.Context, enclosureID int64) (*Enclosure, error) {
+	body, err := c.request.Get(ctx, fmt.Sprintf("/v1/enclosures/%d", enclosureID))
 	if err != nil {
 		return nil, err
 	}
@@ -721,7 +1112,14 @@ func (c *Client) Enclosure(enclosureID int64) (*Enclosure, error) {
 
 // UpdateEnclosure updates an enclosure.
 func (c *Client) UpdateEnclosure(enclosureID int64, enclosureUpdate *EnclosureUpdateRequest) error {
-	_, err := c.request.Put(fmt.Sprintf("/v1/enclosures/%d", enclosureID), enclosureUpdate)
+	ctx, cancel := withDefaultTimeout()
+	defer cancel()
+	return c.UpdateEnclosureContext(ctx, enclosureID, enclosureUpdate)
+}
+
+// UpdateEnclosureContext updates an enclosure.
+func (c *Client) UpdateEnclosureContext(ctx context.Context, enclosureID int64, enclosureUpdate *EnclosureUpdateRequest) error {
+	_, err := c.request.Put(ctx, fmt.Sprintf("/v1/enclosures/%d", enclosureID), enclosureUpdate)
 	return err
 }
 

client/model.go

@@ -17,36 +17,37 @@ const (
 
 // User represents a user in the system.
 type User struct {
-	ID                      int64      `json:"id"`
-	Username                string     `json:"username"`
-	Password                string     `json:"password,omitempty"`
-	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"`
-	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"`
-	BlockFilterEntryRules   string     `json:"block_filter_entry_rules"`
-	KeepFilterEntryRules    string     `json:"keep_filter_entry_rules"`
-	ExternalFontHosts       string     `json:"external_font_hosts"`
-	AlwaysOpenExternalLinks bool       `json:"always_open_external_links"`
+	ID                        int64      `json:"id"`
+	Username                  string     `json:"username"`
+	Password                  string     `json:"password,omitempty"`
+	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"`
+	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"`
+	BlockFilterEntryRules     string     `json:"block_filter_entry_rules"`
+	KeepFilterEntryRules      string     `json:"keep_filter_entry_rules"`
+	ExternalFontHosts         string     `json:"external_font_hosts"`
+	AlwaysOpenExternalLinks   bool       `json:"always_open_external_links"`
+	OpenExternalLinksInNewTab bool       `json:"open_external_links_in_new_tab"`
 }
 
 func (u User) String() string {
@@ -64,34 +65,35 @@ type UserCreationRequest struct {
 
 // UserModificationRequest represents the request to update a user.
 type UserModificationRequest struct {
-	Username                *string  `json:"username"`
-	Password                *string  `json:"password"`
-	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"`
-	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"`
-	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"`
-	BlockFilterEntryRules   *string  `json:"block_filter_entry_rules"`
-	KeepFilterEntryRules    *string  `json:"keep_filter_entry_rules"`
-	ExternalFontHosts       *string  `json:"external_font_hosts"`
-	AlwaysOpenExternalLinks *bool    `json:"always_open_external_links"`
+	Username                  *string  `json:"username"`
+	Password                  *string  `json:"password"`
+	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"`
+	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"`
+	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"`
+	BlockFilterEntryRules     *string  `json:"block_filter_entry_rules"`
+	KeepFilterEntryRules      *string  `json:"keep_filter_entry_rules"`
+	ExternalFontHosts         *string  `json:"external_font_hosts"`
+	AlwaysOpenExternalLinks   *bool    `json:"always_open_external_links"`
+	OpenExternalLinksInNewTab *bool    `json:"open_external_links_in_new_tab"`
 }
 
 // Users represents a list of users.
@@ -158,8 +160,11 @@ type Feed struct {
 	FetchViaProxy               bool      `json:"fetch_via_proxy"`
 	ScraperRules                string    `json:"scraper_rules"`
 	RewriteRules                string    `json:"rewrite_rules"`
+	UrlRewriteRules             string    `json:"urlrewrite_rules"`
 	BlocklistRules              string    `json:"blocklist_rules"`
 	KeeplistRules               string    `json:"keeplist_rules"`
+	BlockFilterEntryRules       string    `json:"block_filter_entry_rules"`
+	KeepFilterEntryRules        string    `json:"keep_filter_entry_rules"`
 	Crawler                     bool      `json:"crawler"`
 	UserAgent                   string    `json:"user_agent"`
 	Cookie                      string    `json:"cookie"`
@@ -186,8 +191,11 @@ type FeedCreationRequest struct {
 	FetchViaProxy               bool   `json:"fetch_via_proxy"`
 	ScraperRules                string `json:"scraper_rules"`
 	RewriteRules                string `json:"rewrite_rules"`
+	UrlRewriteRules             string `json:"urlrewrite_rules"`
 	BlocklistRules              string `json:"blocklist_rules"`
 	KeeplistRules               string `json:"keeplist_rules"`
+	BlockFilterEntryRules       string `json:"block_filter_entry_rules"`
+	KeepFilterEntryRules        string `json:"keep_filter_entry_rules"`
 	HideGlobally                bool   `json:"hide_globally"`
 	DisableHTTP2                bool   `json:"disable_http2"`
 	ProxyURL                    string `json:"proxy_url"`
@@ -200,8 +208,11 @@ type FeedModificationRequest struct {
 	Title                       *string `json:"title"`
 	ScraperRules                *string `json:"scraper_rules"`
 	RewriteRules                *string `json:"rewrite_rules"`
+	UrlRewriteRules             *string `json:"urlrewrite_rules"`
 	BlocklistRules              *string `json:"blocklist_rules"`
 	KeeplistRules               *string `json:"keeplist_rules"`
+	BlockFilterEntryRules       *string `json:"block_filter_entry_rules"`
+	KeepFilterEntryRules        *string `json:"keep_filter_entry_rules"`
 	Crawler                     *bool   `json:"crawler"`
 	UserAgent                   *string `json:"user_agent"`
 	Cookie                      *string `json:"cookie"`

client/options.go

@@ -0,0 +1,30 @@
+// SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package client // import "miniflux.app/v2/client"
+
+import "net/http"
+
+type Option func(*request)
+
+// WithAPIKey sets the API key for the client.
+func WithAPIKey(apiKey string) Option {
+	return func(r *request) {
+		r.apiKey = apiKey
+	}
+}
+
+// WithCredentials sets the username and password for the client.
+func WithCredentials(username, password string) Option {
+	return func(r *request) {
+		r.username = username
+		r.password = password
+	}
+}
+
+// WithHTTPClient sets the HTTP client for the client.
+func WithHTTPClient(client *http.Client) Option {
+	return func(r *request) {
+		r.client = client
+	}
+}

client/request.go

@@ -5,6 +5,7 @@ package client // import "miniflux.app/v2/client"
 
 import (
 	"bytes"
+	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -17,7 +18,7 @@ import (
 
 const (
 	userAgent      = "Miniflux Client Library"
-	defaultTimeout = 80
+	defaultTimeout = 80 * time.Second
 )
 
 // List of exposed errors.
@@ -39,30 +40,36 @@ type request struct {
 	username string
 	password string
 	apiKey   string
+	client   *http.Client
 }
 
-func (r *request) Get(path string) (io.ReadCloser, error) {
-	return r.execute(http.MethodGet, path, nil)
+func (r *request) Get(ctx context.Context, path string) (io.ReadCloser, error) {
+	return r.execute(ctx, http.MethodGet, path, nil)
 }
 
-func (r *request) Post(path string, data interface{}) (io.ReadCloser, error) {
-	return r.execute(http.MethodPost, path, data)
+func (r *request) Post(ctx context.Context, path string, data any) (io.ReadCloser, error) {
+	return r.execute(ctx, http.MethodPost, path, data)
 }
 
-func (r *request) PostFile(path string, f io.ReadCloser) (io.ReadCloser, error) {
-	return r.execute(http.MethodPost, path, f)
+func (r *request) PostFile(ctx context.Context, path string, f io.ReadCloser) (io.ReadCloser, error) {
+	return r.execute(ctx, http.MethodPost, path, f)
 }
 
-func (r *request) Put(path string, data interface{}) (io.ReadCloser, error) {
-	return r.execute(http.MethodPut, path, data)
+func (r *request) Put(ctx context.Context, path string, data any) (io.ReadCloser, error) {
+	return r.execute(ctx, http.MethodPut, path, data)
 }
 
-func (r *request) Delete(path string) error {
-	_, err := r.execute(http.MethodDelete, path, nil)
+func (r *request) Delete(ctx context.Context, path string) error {
+	_, err := r.execute(ctx, http.MethodDelete, path, nil)
 	return err
 }
 
-func (r *request) execute(method, path string, data interface{}) (io.ReadCloser, error) {
+func (r *request) execute(
+	ctx context.Context,
+	method string,
+	path string,
+	data any,
+) (io.ReadCloser, error) {
 	if r.endpoint == "" {
 		return nil, ErrEmptyEndpoint
 	}
@@ -75,12 +82,13 @@ func (r *request) execute(method, path string, data interface{}) (io.ReadCloser,
 		return nil, err
 	}
 
-	request := &http.Request{
-		URL:    u,
-		Method: method,
-		Header: r.buildHeaders(),
+	request, err := http.NewRequestWithContext(ctx, method, u.String(), nil)
+	if err != nil {
+		return nil, err
 	}
 
+	request.Header = r.buildHeaders()
+
 	if r.username != "" && r.password != "" {
 		request.SetBasicAuth(r.username, r.password)
 	}
@@ -94,7 +102,7 @@ func (r *request) execute(method, path string, data interface{}) (io.ReadCloser,
 		}
 	}
 
-	client := r.buildClient()
+	client := r.client
 	response, err := client.Do(request)
 	if err != nil {
 		return nil, err
@@ -143,12 +151,6 @@ func (r *request) execute(method, path string, data interface{}) (io.ReadCloser,
 	return response.Body, nil
 }
 
-func (r *request) buildClient() http.Client {
-	return http.Client{
-		Timeout: defaultTimeout * time.Second,
-	}
-}
-
 func (r *request) buildHeaders() http.Header {
 	headers := make(http.Header)
 	headers.Add("User-Agent", userAgent)
@@ -160,7 +162,7 @@ func (r *request) buildHeaders() http.Header {
 	return headers
 }
 
-func (r *request) toJSON(v interface{}) []byte {
+func (r *request) toJSON(v any) []byte {
 	b, err := json.Marshal(v)
 	if err != nil {
 		log.Println("Unable to convert interface to JSON:", err)

contrib/docker-compose/basic.yml

@@ -19,7 +19,7 @@ services:
     # healthcheck:
     #  test: ["CMD", "/usr/bin/miniflux", "-healthcheck", "auto"]
   db:
-    image: postgres:15
+    image: postgres:latest
     container_name: postgres
     environment:
       - POSTGRES_USER=miniflux

contrib/docker-compose/caddy.yml

@@ -25,7 +25,7 @@ services:
       - ADMIN_PASSWORD=test123
       - BASE_URL=https://miniflux.example.org
   db:
-    image: postgres:15
+    image: postgres:latest
     container_name: postgres
     environment:
       - POSTGRES_USER=miniflux

contrib/docker-compose/traefik.yml

@@ -37,7 +37,7 @@ services:
       - "traefik.http.routers.miniflux.entrypoints=websecure"
       - "traefik.http.routers.miniflux.tls.certresolver=myresolver"
   db:
-    image: postgres:15
+    image: postgres:latest
     container_name: postgres
     environment:
       - POSTGRES_USER=miniflux

go.mod

@@ -1,27 +1,26 @@
 module miniflux.app/v2
 
-// +heroku goVersion go1.23
+// +heroku goVersion go1.24
 
 require (
 	github.com/PuerkitoBio/goquery v1.10.3
-	github.com/andybalholm/brotli v1.1.1
-	github.com/coreos/go-oidc/v3 v3.14.1
-	github.com/go-webauthn/webauthn v0.13.0
+	github.com/andybalholm/brotli v1.2.0
+	github.com/coreos/go-oidc/v3 v3.16.0
+	github.com/go-webauthn/webauthn v0.14.0
 	github.com/gorilla/mux v1.8.1
 	github.com/lib/pq v1.10.9
-	github.com/mattn/go-sqlite3 v1.14.28
-	github.com/prometheus/client_golang v1.22.0
-	github.com/tdewolff/minify/v2 v2.23.8
-	golang.org/x/crypto v0.38.0
-	golang.org/x/image v0.27.0
-	golang.org/x/net v0.40.0
-	golang.org/x/oauth2 v0.30.0
-	golang.org/x/term v0.32.0
+	github.com/prometheus/client_golang v1.23.2
+	github.com/tdewolff/minify/v2 v2.24.4
+	golang.org/x/crypto v0.43.0
+	golang.org/x/image v0.32.0
+	golang.org/x/net v0.46.0
+	golang.org/x/oauth2 v0.32.0
+	golang.org/x/term v0.36.0
 )
 
 require (
-	github.com/go-webauthn/x v0.1.21 // indirect
-	github.com/golang-jwt/jwt/v5 v5.2.2 // indirect
+	github.com/go-webauthn/x v0.1.25 // indirect
+	github.com/golang-jwt/jwt/v5 v5.3.0 // indirect
 	github.com/google/go-tpm v0.9.5 // indirect
 )
 
@@ -29,21 +28,23 @@ require (
 	github.com/andybalholm/cascadia v1.3.3 // indirect
 	github.com/beorn7/perks v1.0.1 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
-	github.com/fxamacker/cbor/v2 v2.8.0 // indirect
-	github.com/go-jose/go-jose/v4 v4.0.5 // indirect
+	github.com/fxamacker/cbor/v2 v2.9.0 // indirect
+	github.com/go-jose/go-jose/v4 v4.1.3 // indirect
 	github.com/google/uuid v1.6.0 // indirect
+	github.com/kr/text v0.2.0 // indirect
 	github.com/mitchellh/mapstructure v1.5.0 // 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.62.0 // indirect
-	github.com/prometheus/procfs v0.15.1 // indirect
-	github.com/tdewolff/parse/v2 v2.8.1 // indirect
+	github.com/prometheus/client_model v0.6.2 // indirect
+	github.com/prometheus/common v0.66.1 // indirect
+	github.com/prometheus/procfs v0.16.1 // indirect
+	github.com/tdewolff/parse/v2 v2.8.4 // indirect
 	github.com/x448/float16 v0.8.4 // indirect
-	golang.org/x/sys v0.33.0 // indirect
-	golang.org/x/text v0.25.0 // indirect
-	google.golang.org/protobuf v1.36.5 // indirect
+	go.yaml.in/yaml/v2 v2.4.2 // indirect
+	golang.org/x/sys v0.37.0 // indirect
+	golang.org/x/text v0.30.0 // indirect
+	google.golang.org/protobuf v1.36.8 // indirect
 )
 
-go 1.23.0
+go 1.24.0
 
 toolchain go1.24.1

go.sum

@@ -1,27 +1,28 @@
 github.com/PuerkitoBio/goquery v1.10.3 h1:pFYcNSqHxBD06Fpj/KsbStFRsgRATgnf3LeXiUkhzPo=
 github.com/PuerkitoBio/goquery v1.10.3/go.mod h1:tMUX0zDMHXYlAQk6p35XxQMqMweEKB7iK7iLNd4RH4Y=
-github.com/andybalholm/brotli v1.1.1 h1:PR2pgnyFznKEugtsUo0xLdDop5SKXd5Qf5ysW+7XdTA=
-github.com/andybalholm/brotli v1.1.1/go.mod h1:05ib4cKhjx3OQYUY22hTVd34Bc8upXjOLL2rKwwZBoA=
+github.com/andybalholm/brotli v1.2.0 h1:ukwgCxwYrmACq68yiUqwIWnGY0cTPox/M94sVwToPjQ=
+github.com/andybalholm/brotli v1.2.0/go.mod h1:rzTDkvFWvIrjDXZHkuS16NPggd91W3kUSvPlQ1pLaKY=
 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.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs=
 github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs=
-github.com/coreos/go-oidc/v3 v3.14.1 h1:9ePWwfdwC4QKRlCXsJGou56adA/owXczOzwKdOumLqk=
-github.com/coreos/go-oidc/v3 v3.14.1/go.mod h1:HaZ3szPaZ0e4r6ebqvsLWlk2Tn+aejfmrfah6hnSYEU=
+github.com/coreos/go-oidc/v3 v3.16.0 h1:qRQUCFstKpXwmEjDQTIbyY/5jF00+asXzSkmkoa/mow=
+github.com/coreos/go-oidc/v3 v3.16.0/go.mod h1:wqPbKFrVnE90vty060SB40FCJ8fTHTxSwyXJqZH+sI8=
+github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
 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.8.0 h1:fFtUGXUzXPHTIUdne5+zzMPTfffl3RD5qYnkY40vtxU=
-github.com/fxamacker/cbor/v2 v2.8.0/go.mod h1:vM4b+DJCtHn+zz7h3FFp/hDAI9WNWCsZj23V5ytsSxQ=
-github.com/go-jose/go-jose/v4 v4.0.5 h1:M6T8+mKZl/+fNNuFHvGIzDz7BTLQPIounk/b9dw3AaE=
-github.com/go-jose/go-jose/v4 v4.0.5/go.mod h1:s3P1lRrkT8igV8D9OjyL4WRyHvjB6a4JSllnOrmmBOA=
-github.com/go-webauthn/webauthn v0.13.0 h1:cJIL1/1l+22UekVhipziAaSgESJxokYkowUqAIsWs0Y=
-github.com/go-webauthn/webauthn v0.13.0/go.mod h1:Oy9o2o79dbLKRPZWWgRIOdtBGAhKnDIaBp2PFkICRHs=
-github.com/go-webauthn/x v0.1.21 h1:nFbckQxudvHEJn2uy1VEi713MeSpApoAv9eRqsb9AdQ=
-github.com/go-webauthn/x v0.1.21/go.mod h1:sEYohtg1zL4An1TXIUIQ5csdmoO+WO0R4R2pGKaHYKA=
-github.com/golang-jwt/jwt/v5 v5.2.2 h1:Rl4B7itRWVtYIHFrSNd7vhTiz9UpLdi6gZhZ3wEeDy8=
-github.com/golang-jwt/jwt/v5 v5.2.2/go.mod h1:pqrtFR0X4osieyHYxtmOUWsAWrfe1Q5UVIyoH402zdk=
+github.com/fxamacker/cbor/v2 v2.9.0 h1:NpKPmjDBgUfBms6tr6JZkTHtfFGcMKsw3eGcmD/sapM=
+github.com/fxamacker/cbor/v2 v2.9.0/go.mod h1:vM4b+DJCtHn+zz7h3FFp/hDAI9WNWCsZj23V5ytsSxQ=
+github.com/go-jose/go-jose/v4 v4.1.3 h1:CVLmWDhDVRa6Mi/IgCgaopNosCaHz7zrMeF9MlZRkrs=
+github.com/go-jose/go-jose/v4 v4.1.3/go.mod h1:x4oUasVrzR7071A4TnHLGSPpNOm2a21K9Kf04k1rs08=
+github.com/go-webauthn/webauthn v0.14.0 h1:ZLNPUgPcDlAeoxe+5umWG/tEeCoQIDr7gE2Zx2QnhL0=
+github.com/go-webauthn/webauthn v0.14.0/go.mod h1:QZzPFH3LJ48u5uEPAu+8/nWJImoLBWM7iAH/kSVSo6k=
+github.com/go-webauthn/x v0.1.25 h1:g/0noooIGcz/yCVqebcFgNnGIgBlJIccS+LYAa+0Z88=
+github.com/go-webauthn/x v0.1.25/go.mod h1:ieblaPY1/BVCV0oQTsA/VAo08/TWayQuJuo5Q+XxmTY=
+github.com/golang-jwt/jwt/v5 v5.3.0 h1:pv4AsKCKKZuqlgs5sUmn4x8UlGa0kEVt/puTpKx9vvo=
+github.com/golang-jwt/jwt/v5 v5.3.0/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE=
 github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
@@ -33,32 +34,36 @@ 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.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
 github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
+github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
+github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk=
+github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
+github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
 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.28 h1:ThEiQrnbtumT+QMknw63Befp/ce/nUPgBPMlRFEum7A=
-github.com/mattn/go-sqlite3 v1.14.28/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.22.0 h1:rb93p9lokFEsctTys46VnV1kLCDpVZ0a/Y92Vm0Zc6Q=
-github.com/prometheus/client_golang v1.22.0/go.mod h1:R7ljNsLXhuQXYZYtw6GAE9AZg8Y7vEW5scdCXrWRXC0=
-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.62.0 h1:xasJaQlnWAeyHdUBeGjXmutelfJHWMRr+Fg4QszZ2Io=
-github.com/prometheus/common v0.62.0/go.mod h1:vyBcEuLSvWos9B1+CyL7JZ2up+uFzXhkqml0W5zIY1I=
-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.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA=
-github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY=
-github.com/tdewolff/minify/v2 v2.23.8 h1:tvjHzRer46kwOfpdCBCWsDblCw3QtnLJRd61pTVkyZ8=
-github.com/tdewolff/minify/v2 v2.23.8/go.mod h1:VW3ISUd3gDOZuQ/jwZr4sCzsuX+Qvsx87FDMjk6Rvno=
-github.com/tdewolff/parse/v2 v2.8.1 h1:J5GSHru6o3jF1uLlEKVXkDxxcVx6yzOlIVIotK4w2po=
-github.com/tdewolff/parse/v2 v2.8.1/go.mod h1:Hwlni2tiVNKyzR1o6nUs4FOF07URA+JLBLd6dlIXYqo=
+github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o=
+github.com/prometheus/client_golang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg=
+github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk=
+github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE=
+github.com/prometheus/common v0.66.1 h1:h5E0h5/Y8niHc5DlaLlWLArTQI7tMrsfQjHV+d9ZoGs=
+github.com/prometheus/common v0.66.1/go.mod h1:gcaUsgf3KfRSwHY4dIMXLPV0K/Wg1oZ8+SbZk/HH/dA=
+github.com/prometheus/procfs v0.16.1 h1:hZ15bTNuirocR6u0JZ6BAHHmwS1p8B4P6MRqxtzMyRg=
+github.com/prometheus/procfs v0.16.1/go.mod h1:teAbpZRB1iIAJYREa1LsoWUXykVXA1KlTmWl8x/U+Is=
+github.com/rogpeppe/go-internal v1.10.0 h1:TMyTOH3F/DB16zRVcYyreMH6GnZZrwQVAoYjRBZyWFQ=
+github.com/rogpeppe/go-internal v1.10.0/go.mod h1:UQnix2H7Ngw/k4C5ijL5+65zddjncjaFoBhdsK/akog=
+github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
+github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
+github.com/tdewolff/minify/v2 v2.24.4 h1:pQyr6eWDa+RXtAoZg+6wurh0jB9ojqw/qc5LlU7/z6c=
+github.com/tdewolff/minify/v2 v2.24.4/go.mod h1:iD9Qn7/brhKY9d0KLKMkZrqS8/bqxSxRKruBi7V6m+w=
+github.com/tdewolff/parse/v2 v2.8.4 h1:A6slgBLGGDPBMGA28KQZfHpaKffuNvhOe7zSag+x/rw=
+github.com/tdewolff/parse/v2 v2.8.4/go.mod h1:Hwlni2tiVNKyzR1o6nUs4FOF07URA+JLBLd6dlIXYqo=
 github.com/tdewolff/test v1.0.11 h1:FdLbwQVHxqG16SlkGveC0JVyrJN62COWTRyUFzfbtBE=
 github.com/tdewolff/test v1.0.11/go.mod h1:XPuWBzvdUzhCuxWO1ojpXsyzsA5bFoS3tO/Q3kFuTG8=
 github.com/x448/float16 v0.8.4 h1:qLwI1I70+NjRFUR3zs1JPUCgaCXSh3SW62uAKT1mSBM=
@@ -66,16 +71,22 @@ github.com/x448/float16 v0.8.4/go.mod h1:14CWIYCyZA/cWjXOioeEpHeN/83MdbZDRQHoFcY
 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=
+go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
+go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
+go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y=
+go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU=
+go.yaml.in/yaml/v2 v2.4.2 h1:DzmwEr2rDGHl7lsFgAHxmNz/1NlQ7xLIrlN2h5d1eGI=
+go.yaml.in/yaml/v2 v2.4.2/go.mod h1:081UH+NErpNdqlCXm3TtEran0rJZGxAYx9hb/ELlsPU=
 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.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.38.0 h1:jt+WWG8IZlBnVbomuhg2Mdq0+BBQaHbtqHEFEigjUV8=
-golang.org/x/crypto v0.38.0/go.mod h1:MvrbAqul58NNYPKnOra203SB9vpuZW0e+RRZV+Ggqjw=
-golang.org/x/image v0.27.0 h1:C8gA4oWU/tKkdCfYT6T2u4faJu3MeNS5O8UPWlPF61w=
-golang.org/x/image v0.27.0/go.mod h1:xbdrClrAUway1MUTEZDq9mz/UpRwYAkFFNUslZtcB+g=
+golang.org/x/crypto v0.43.0 h1:dduJYIi3A3KOfdGOHX8AVZ/jGiyPa3IbBozJ5kNuE04=
+golang.org/x/crypto v0.43.0/go.mod h1:BFbav4mRNlXJL4wNeejLpWxB7wMbc79PdRGhWKncxR0=
+golang.org/x/image v0.32.0 h1:6lZQWq75h7L5IWNk0r+SCpUJ6tUVd3v4ZHnbRKLkUDQ=
+golang.org/x/image v0.32.0/go.mod h1:/R37rrQmKXtO6tYXAjtDLwQgFLHmhW+V6ayXlxzP2Pc=
 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=
@@ -90,10 +101,10 @@ 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.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY=
-golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds=
-golang.org/x/oauth2 v0.30.0 h1:dnDm7JmhM45NNpd8FDDeLhK6FwqbOf4MLCM9zb1BOHI=
-golang.org/x/oauth2 v0.30.0/go.mod h1:B++QgG3ZKulg6sRPGD/mqlHQs5rB3Ml9erfeDY7xKlU=
+golang.org/x/net v0.46.0 h1:giFlY12I07fugqwPuWJi68oOnpfqFnJIJzaIIm2JVV4=
+golang.org/x/net v0.46.0/go.mod h1:Q9BGdFy1y4nkUwiLvT5qtyhAnEHgnQ/zd8PfU6nc210=
+golang.org/x/oauth2 v0.32.0 h1:jsCblLleRMDrxMN29H3z/k1KliIvpLgCkE6R8FXXNgY=
+golang.org/x/oauth2 v0.32.0/go.mod h1:lzm5WQJQwKZ3nwavOZ3IS5Aulzxi68dUSgRHujetwEA=
 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=
@@ -112,8 +123,8 @@ 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.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw=
-golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
+golang.org/x/sys v0.37.0 h1:fdNQudmxPjkdUTPnLn5mdQv7Zwvbvpaxqs831goi9kQ=
+golang.org/x/sys v0.37.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
 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=
@@ -123,8 +134,8 @@ 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.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg=
-golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ=
+golang.org/x/term v0.36.0 h1:zMPR+aF8gfksFprF/Nc/rd1wRS1EI6nDBGyWAvDzx2Q=
+golang.org/x/term v0.36.0/go.mod h1:Qu394IJq6V6dCBRgwqshf3mPF85AqzYEzofzRdZkWss=
 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=
@@ -134,8 +145,8 @@ 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.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4=
-golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA=
+golang.org/x/text v0.30.0 h1:yznKA/E9zq54KzlzBEAWn1NXSQ8DIp/NYMy88xJjl4k=
+golang.org/x/text v0.30.0/go.mod h1:yDdHFIX9t+tORqspjENWgzaCVXgk0yYnYuSZ8UzzBVM=
 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=
@@ -143,7 +154,10 @@ 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=
-google.golang.org/protobuf v1.36.5 h1:tPhr+woSbjfYvY6/GPufUoYizxw1cF/yFoxJ2fmpwlM=
-google.golang.org/protobuf v1.36.5/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE=
+google.golang.org/protobuf v1.36.8 h1:xHScyCOEuuwZEc6UtSOvPbAT4zRh0xcNRYekJwfqyMc=
+google.golang.org/protobuf v1.36.8/go.mod h1:fuxRtAxBytpl4zzqUh6/eyUujkJdNiuEkXntxiD/uRU=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
+gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

internal/api/api.go

@@ -67,7 +67,8 @@ func Serve(router *mux.Router, store *storage.Storage, pool *worker.Pool) {
 	sr.HandleFunc("/entries", handler.setEntryStatus).Methods(http.MethodPut)
 	sr.HandleFunc("/entries/{entryID}", handler.getEntry).Methods(http.MethodGet)
 	sr.HandleFunc("/entries/{entryID}", handler.updateEntry).Methods(http.MethodPut)
-	sr.HandleFunc("/entries/{entryID}/bookmark", handler.toggleBookmark).Methods(http.MethodPut)
+	sr.HandleFunc("/entries/{entryID}/bookmark", handler.toggleStarred).Methods(http.MethodPut)
+	sr.HandleFunc("/entries/{entryID}/star", handler.toggleStarred).Methods(http.MethodPut)
 	sr.HandleFunc("/entries/{entryID}/save", handler.saveEntry).Methods(http.MethodPost)
 	sr.HandleFunc("/entries/{entryID}/fetch-content", handler.fetchContent).Methods(http.MethodGet)
 	sr.HandleFunc("/flush-history", handler.flushHistory).Methods(http.MethodPut, http.MethodDelete)

internal/api/api_integration_test.go

@@ -8,7 +8,7 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"math/rand"
+	"math/rand/v2"
 	"os"
 	"strings"
 	"testing"
@@ -1262,6 +1262,14 @@ func TestGetCategoriesEndpoint(t *testing.T) {
 		t.Fatalf(`Invalid title, got %q instead of %q`, categories[0].Title, "All")
 	}
 
+	if categories[0].FeedCount != nil {
+		t.Errorf(`Expected FeedCount to be nil, got %d`, *categories[0].FeedCount)
+	}
+
+	if categories[0].TotalUnread != nil {
+		t.Errorf(`Expected TotalUnread to be nil, got %d`, *categories[0].TotalUnread)
+	}
+
 	if categories[1].ID != category.ID {
 		t.Fatalf(`Invalid categoryID, got %d`, categories[0].ID)
 	}
@@ -1273,6 +1281,40 @@ func TestGetCategoriesEndpoint(t *testing.T) {
 	if categories[1].Title != "My category" {
 		t.Fatalf(`Invalid title, got %q instead of %q`, categories[0].Title, "My category")
 	}
+
+	if categories[1].FeedCount != nil {
+		t.Errorf(`Expected FeedCount to be nil, got %d`, *categories[1].FeedCount)
+	}
+
+	if categories[1].TotalUnread != nil {
+		t.Errorf(`Expected TotalUnread to be nil, got %d`, *categories[1].TotalUnread)
+	}
+
+	categories, err = regularUserClient.CategoriesWithCounters()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if len(categories) != 2 {
+		t.Fatalf(`Invalid number of categories, got %d instead of %d`, len(categories), 1)
+	}
+
+	if categories[1].FeedCount == nil {
+		t.Fatalf(`Expected FeedCount to be not nil`)
+	}
+
+	if categories[1].TotalUnread == nil {
+		t.Fatalf(`Expected TotalUnread to be not nil`)
+	}
+
+	expectedCounterValue := 0
+	if *categories[1].FeedCount != expectedCounterValue {
+		t.Errorf(`Expected FeedCount to be %d, got %d`, expectedCounterValue, *categories[1].FeedCount)
+	}
+
+	if *categories[1].TotalUnread != expectedCounterValue {
+		t.Errorf(`Expected TotalUnread to be %d, got %d`, expectedCounterValue, *categories[1].TotalUnread)
+	}
 }
 
 func TestMarkCategoryAsReadEndpoint(t *testing.T) {
@@ -2339,7 +2381,6 @@ func TestGetGlobalEntriesEndpoint(t *testing.T) {
 	}
 
 	feedIDEntry, err := regularUserClient.Feed(feedID)
-
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -2371,6 +2412,64 @@ func TestGetGlobalEntriesEndpoint(t *testing.T) {
 	}
 }
 
+func TestCannotGetRemovedEntries(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)
+	}
+
+	feedEntries, err := regularUserClient.Entries(&miniflux.Filter{FeedID: feedID})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if feedEntries.Total == 0 {
+		t.Fatalf(`Expected at least one entry, got none`)
+	}
+
+	if err := regularUserClient.UpdateEntries([]int64{feedEntries.Entries[0].ID}, miniflux.EntryStatusRemoved); err != nil {
+		t.Fatal(err)
+	}
+
+	if _, err := regularUserClient.Entry(feedEntries.Entries[0].ID); err != miniflux.ErrNotFound {
+		t.Fatalf(`Expected entry to be not found, got %v`, err)
+	}
+
+	if _, err := regularUserClient.FeedEntry(feedID, feedEntries.Entries[0].ID); err != miniflux.ErrNotFound {
+		t.Fatalf(`Expected entry to be not found, got %v`, err)
+	}
+
+	if _, err := regularUserClient.CategoryEntry(feedEntries.Entries[0].Feed.Category.ID, feedEntries.Entries[0].ID); err != miniflux.ErrNotFound {
+		t.Fatalf(`Expected entry to be not found, got %v`, err)
+	}
+
+	updatedFeedEntries, err := regularUserClient.Entries(&miniflux.Filter{FeedID: feedID})
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if updatedFeedEntries.Total != feedEntries.Total-1 {
+		t.Fatalf(`Expected %d entries, got %d`, feedEntries.Total-1, updatedFeedEntries.Total)
+	}
+}
+
 func TestUpdateEnclosureEndpoint(t *testing.T) {
 	testConfig := newIntegrationTestConfig()
 	if !testConfig.isConfigured() {
@@ -2649,7 +2748,7 @@ func TestUpdateEntryEndpoint(t *testing.T) {
 	}
 }
 
-func TestToggleBookmarkEndpoint(t *testing.T) {
+func TestToggleStarredEndpoint(t *testing.T) {
 	testConfig := newIntegrationTestConfig()
 	if !testConfig.isConfigured() {
 		t.Skip(skipIntegrationTestsMessage)
@@ -2677,7 +2776,7 @@ func TestToggleBookmarkEndpoint(t *testing.T) {
 		t.Fatalf(`Failed to get entries: %v`, err)
 	}
 
-	if err := regularUserClient.ToggleBookmark(result.Entries[0].ID); err != nil {
+	if err := regularUserClient.ToggleStarred(result.Entries[0].ID); err != nil {
 		t.Fatal(err)
 	}
 
@@ -2687,7 +2786,7 @@ func TestToggleBookmarkEndpoint(t *testing.T) {
 	}
 
 	if !entry.Starred {
-		t.Fatalf(`The entry should be bookmarked`)
+		t.Fatalf(`The entry should be starred`)
 	}
 }
 
@@ -2832,13 +2931,4 @@ func TestFlushHistoryEndpoint(t *testing.T) {
 	if readEntries.Total != 0 {
 		t.Fatalf(`Invalid total, got %d`, readEntries.Total)
 	}
-
-	removedEntries, err := regularUserClient.Entries(&miniflux.Filter{Status: miniflux.EntryStatusRemoved})
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if removedEntries.Total != 2 {
-		t.Fatalf(`Invalid total, got %d`, removedEntries.Total)
-	}
 }

internal/api/category.go

@@ -143,6 +143,7 @@ func (h *handler) refreshCategory(w http.ResponseWriter, r *http.Request) {
 	batchBuilder.WithUserID(userID)
 	batchBuilder.WithCategoryID(categoryID)
 	batchBuilder.WithNextCheckExpired()
+	batchBuilder.WithLimitPerHost(config.Opts.PollingLimitPerHost())
 
 	jobs, err := batchBuilder.FetchJobs()
 	if err != nil {

internal/api/enclosure.go

@@ -7,6 +7,7 @@ import (
 	json_parser "encoding/json"
 	"net/http"
 
+	"miniflux.app/v2/internal/config"
 	"miniflux.app/v2/internal/http/request"
 	"miniflux.app/v2/internal/http/response/json"
 	"miniflux.app/v2/internal/model"
@@ -33,7 +34,7 @@ func (h *handler) getEnclosureByID(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	enclosure.ProxifyEnclosureURL(h.router)
+	enclosure.ProxifyEnclosureURL(h.router, config.Opts.MediaProxyMode(), config.Opts.MediaProxyResourceTypes())
 
 	json.OK(w, r, enclosure)
 }

internal/api/entry.go

@@ -10,6 +10,7 @@ import (
 	"strconv"
 	"time"
 
+	"miniflux.app/v2/internal/config"
 	"miniflux.app/v2/internal/http/request"
 	"miniflux.app/v2/internal/http/response/json"
 	"miniflux.app/v2/internal/integration"
@@ -34,8 +35,7 @@ func (h *handler) getEntryFromBuilder(w http.ResponseWriter, r *http.Request, b
 	}
 
 	entry.Content = mediaproxy.RewriteDocumentWithAbsoluteProxyURL(h.router, entry.Content)
-
-	entry.Enclosures.ProxifyEnclosureURL(h.router)
+	entry.Enclosures.ProxifyEnclosureURL(h.router, config.Opts.MediaProxyMode(), config.Opts.MediaProxyResourceTypes())
 
 	json.OK(w, r, entry)
 }
@@ -47,6 +47,7 @@ func (h *handler) getFeedEntry(w http.ResponseWriter, r *http.Request) {
 	builder := h.store.NewEntryQueryBuilder(request.UserID(r))
 	builder.WithFeedID(feedID)
 	builder.WithEntryID(entryID)
+	builder.WithoutStatus(model.EntryStatusRemoved)
 
 	h.getEntryFromBuilder(w, r, builder)
 }
@@ -58,6 +59,7 @@ func (h *handler) getCategoryEntry(w http.ResponseWriter, r *http.Request) {
 	builder := h.store.NewEntryQueryBuilder(request.UserID(r))
 	builder.WithCategoryID(categoryID)
 	builder.WithEntryID(entryID)
+	builder.WithoutStatus(model.EntryStatusRemoved)
 
 	h.getEntryFromBuilder(w, r, builder)
 }
@@ -66,6 +68,7 @@ func (h *handler) getEntry(w http.ResponseWriter, r *http.Request) {
 	entryID := request.RouteInt64Param(r, "entryID")
 	builder := h.store.NewEntryQueryBuilder(request.UserID(r))
 	builder.WithEntryID(entryID)
+	builder.WithoutStatus(model.EntryStatusRemoved)
 
 	h.getEntryFromBuilder(w, r, builder)
 }
@@ -136,6 +139,7 @@ func (h *handler) findEntries(w http.ResponseWriter, r *http.Request, feedID int
 	builder.WithLimit(limit)
 	builder.WithTags(tags)
 	builder.WithEnclosures()
+	builder.WithoutStatus(model.EntryStatusRemoved)
 
 	if request.HasQueryParam(r, "globally_visible") {
 		globallyVisible := request.QueryBoolParam(r, "globally_visible", true)
@@ -186,9 +190,9 @@ func (h *handler) setEntryStatus(w http.ResponseWriter, r *http.Request) {
 	json.NoContent(w, r)
 }
 
-func (h *handler) toggleBookmark(w http.ResponseWriter, r *http.Request) {
+func (h *handler) toggleStarred(w http.ResponseWriter, r *http.Request) {
 	entryID := request.RouteInt64Param(r, "entryID")
-	if err := h.store.ToggleBookmark(request.UserID(r), entryID); err != nil {
+	if err := h.store.ToggleStarred(request.UserID(r), entryID); err != nil {
 		json.ServerError(w, r, err)
 		return
 	}
@@ -338,7 +342,7 @@ func (h *handler) fetchContent(w http.ResponseWriter, r *http.Request) {
 			return
 		}
 
-		json.OK(w, r, map[string]interface{}{"content": mediaproxy.RewriteDocumentWithRelativeProxyURL(h.router, entry.Content), "reading_time": entry.ReadingTime})
+		json.OK(w, r, map[string]any{"content": mediaproxy.RewriteDocumentWithRelativeProxyURL(h.router, entry.Content), "reading_time": entry.ReadingTime})
 
 		return
 	}

internal/api/feed.go

@@ -76,6 +76,7 @@ func (h *handler) refreshAllFeeds(w http.ResponseWriter, r *http.Request) {
 	batchBuilder.WithoutDisabledFeeds()
 	batchBuilder.WithNextCheckExpired()
 	batchBuilder.WithUserID(userID)
+	batchBuilder.WithLimitPerHost(config.Opts.PollingLimitPerHost())
 
 	jobs, err := batchBuilder.FetchJobs()
 	if err != nil {
@@ -140,13 +141,7 @@ func (h *handler) markFeedAsRead(w http.ResponseWriter, r *http.Request) {
 	feedID := request.RouteInt64Param(r, "feedID")
 	userID := request.UserID(r)
 
-	feed, err := h.store.FeedByID(userID, feedID)
-	if err != nil {
-		json.NotFound(w, r)
-		return
-	}
-
-	if feed == nil {
+	if !h.store.FeedExists(userID, feedID) {
 		json.NotFound(w, r)
 		return
 	}

internal/api/middleware.go

@@ -43,6 +43,7 @@ func (m *middleware) apiKeyAuth(next http.Handler) http.Handler {
 			slog.Debug("[API] Skipped API token authentication because no API Key has been provided",
 				slog.String("client_ip", clientIP),
 				slog.String("user_agent", r.UserAgent()),
+				slog.String("request_uri", r.RequestURI),
 			)
 			next.ServeHTTP(w, r)
 			return
@@ -59,6 +60,7 @@ func (m *middleware) apiKeyAuth(next http.Handler) http.Handler {
 				slog.Bool("authentication_failed", true),
 				slog.String("client_ip", clientIP),
 				slog.String("user_agent", r.UserAgent()),
+				slog.String("request_uri", r.RequestURI),
 			)
 			json.Unauthorized(w, r)
 			return
@@ -69,6 +71,7 @@ func (m *middleware) apiKeyAuth(next http.Handler) http.Handler {
 			slog.String("client_ip", clientIP),
 			slog.String("user_agent", r.UserAgent()),
 			slog.String("username", user.Username),
+			slog.String("request_uri", r.RequestURI),
 		)
 
 		m.store.SetLastLogin(user.ID)
@@ -100,6 +103,7 @@ func (m *middleware) basicAuth(next http.Handler) http.Handler {
 				slog.Bool("authentication_failed", true),
 				slog.String("client_ip", clientIP),
 				slog.String("user_agent", r.UserAgent()),
+				slog.String("request_uri", r.RequestURI),
 			)
 			json.Unauthorized(w, r)
 			return
@@ -110,6 +114,7 @@ func (m *middleware) basicAuth(next http.Handler) http.Handler {
 				slog.Bool("authentication_failed", true),
 				slog.String("client_ip", clientIP),
 				slog.String("user_agent", r.UserAgent()),
+				slog.String("request_uri", r.RequestURI),
 			)
 			json.Unauthorized(w, r)
 			return
@@ -121,6 +126,7 @@ func (m *middleware) basicAuth(next http.Handler) http.Handler {
 				slog.String("client_ip", clientIP),
 				slog.String("user_agent", r.UserAgent()),
 				slog.String("username", username),
+				slog.String("request_uri", r.RequestURI),
 			)
 			json.Unauthorized(w, r)
 			return
@@ -138,6 +144,7 @@ func (m *middleware) basicAuth(next http.Handler) http.Handler {
 				slog.String("client_ip", clientIP),
 				slog.String("user_agent", r.UserAgent()),
 				slog.String("username", username),
+				slog.String("request_uri", r.RequestURI),
 			)
 			json.Unauthorized(w, r)
 			return
@@ -148,6 +155,7 @@ func (m *middleware) basicAuth(next http.Handler) http.Handler {
 			slog.String("client_ip", clientIP),
 			slog.String("user_agent", r.UserAgent()),
 			slog.String("username", username),
+			slog.String("request_uri", r.RequestURI),
 		)
 
 		m.store.SetLastLogin(user.ID)

internal/api/user.go

@@ -7,8 +7,6 @@ import (
 	json_parser "encoding/json"
 	"errors"
 	"net/http"
-	"regexp"
-	"strings"
 
 	"miniflux.app/v2/internal/http/request"
 	"miniflux.app/v2/internal/http/response/json"
@@ -84,18 +82,6 @@ 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

internal/cli/ask_credentials.go

@@ -5,6 +5,7 @@ package cli // import "miniflux.app/v2/internal/cli"
 
 import (
 	"bufio"
+	"errors"
 	"fmt"
 	"os"
 	"strings"
@@ -16,7 +17,7 @@ func askCredentials() (string, string) {
 	fd := int(os.Stdin.Fd())
 
 	if !term.IsTerminal(fd) {
-		printErrorAndExit(fmt.Errorf("this is not an interactive terminal, exiting"))
+		printErrorAndExit(errors.New("this is not an interactive terminal, exiting"))
 	}
 
 	fmt.Print("Enter Username: ")
@@ -30,6 +31,6 @@ func askCredentials() (string, string) {
 	defer term.Restore(fd, state)
 	bytePassword, _ := term.ReadPassword(fd)
 
-	fmt.Printf("\n")
+	fmt.Print("\n")
 	return strings.TrimSpace(username), strings.TrimSpace(string(bytePassword))
 }

internal/cli/cleanup_tasks.go

@@ -14,15 +14,15 @@ import (
 )
 
 func runCleanupTasks(store *storage.Storage) {
-	nbSessions := store.CleanOldSessions(config.Opts.CleanupRemoveSessionsDays())
-	nbUserSessions := store.CleanOldUserSessions(config.Opts.CleanupRemoveSessionsDays())
+	nbSessions := store.CleanOldSessions(config.Opts.CleanupRemoveSessionsInterval())
+	nbUserSessions := store.CleanOldUserSessions(config.Opts.CleanupRemoveSessionsInterval())
 	slog.Info("Sessions cleanup completed",
 		slog.Int64("application_sessions_removed", nbSessions),
 		slog.Int64("user_sessions_removed", nbUserSessions),
 	)
 
 	startTime := time.Now()
-	if rowsAffected, err := store.ArchiveEntries(model.EntryStatusRead, config.Opts.CleanupArchiveReadDays(), config.Opts.CleanupArchiveBatchSize()); err != nil {
+	if rowsAffected, err := store.ArchiveEntries(model.EntryStatusRead, config.Opts.CleanupArchiveReadInterval(), config.Opts.CleanupArchiveBatchSize()); err != nil {
 		slog.Error("Unable to archive read entries", slog.Any("error", err))
 	} else {
 		slog.Info("Archiving read entries completed",
@@ -35,7 +35,7 @@ func runCleanupTasks(store *storage.Storage) {
 	}
 
 	startTime = time.Now()
-	if rowsAffected, err := store.ArchiveEntries(model.EntryStatusUnread, config.Opts.CleanupArchiveUnreadDays(), config.Opts.CleanupArchiveBatchSize()); err != nil {
+	if rowsAffected, err := store.ArchiveEntries(model.EntryStatusUnread, config.Opts.CleanupArchiveUnreadInterval(), config.Opts.CleanupArchiveBatchSize()); err != nil {
 		slog.Error("Unable to archive unread entries", slog.Any("error", err))
 	} else {
 		slog.Info("Archiving unread entries completed",
@@ -46,4 +46,18 @@ func runCleanupTasks(store *storage.Storage) {
 			metric.ArchiveEntriesDuration.WithLabelValues(model.EntryStatusUnread).Observe(time.Since(startTime).Seconds())
 		}
 	}
+
+	if enclosuresAffected, err := store.DeleteRemovedEntriesEnclosures(); err != nil {
+		slog.Error("Unable to delete enclosures from removed entries", slog.Any("error", err))
+	} else {
+		slog.Info("Deleting enclosures from removed entries completed",
+			slog.Int64("removed_entries_enclosures_deleted", enclosuresAffected))
+	}
+
+	if contentAffected, err := store.ClearRemovedEntriesContent(config.Opts.CleanupArchiveBatchSize()); err != nil {
+		slog.Error("Unable to clear content from removed entries", slog.Any("error", err))
+	} else {
+		slog.Info("Clearing content from removed entries completed",
+			slog.Int64("removed_entries_content_cleared", contentAffected))
+	}
 }

internal/cli/cli.go

@@ -78,7 +78,7 @@ func Parse() {
 	flag.StringVar(&flagExportUserFeeds, "export-user-feeds", "", flagExportUserFeedsHelp)
 	flag.Parse()
 
-	cfg := config.NewParser()
+	cfg := config.NewConfigParser()
 
 	if flagConfigFile != "" {
 		config.Opts, err = cfg.ParseFile(flagConfigFile)
@@ -156,16 +156,16 @@ func Parse() {
 		slog.Info("The default value for DATABASE_URL is used")
 	}
 
-	if err := static.CalculateBinaryFileChecksums(); err != nil {
-		printErrorAndExit(fmt.Errorf("unable to calculate binary file checksums: %v", err))
+	if err := static.GenerateBinaryBundles(); err != nil {
+		printErrorAndExit(fmt.Errorf("unable to generate binary files bundle: %v", err))
 	}
 
 	if err := static.GenerateStylesheetsBundles(); err != nil {
-		printErrorAndExit(fmt.Errorf("unable to generate stylesheets bundles: %v", err))
+		printErrorAndExit(fmt.Errorf("unable to generate stylesheets bundle: %v", err))
 	}
 
-	if err := static.GenerateJavascriptBundles(); err != nil {
-		printErrorAndExit(fmt.Errorf("unable to generate javascript bundles: %v", err))
+	if err := static.GenerateJavascriptBundles(config.Opts.WebAuthn()); err != nil {
+		printErrorAndExit(fmt.Errorf("unable to generate javascript bundle: %v", err))
 	}
 
 	db, err := database.NewConnectionPool(
@@ -263,6 +263,6 @@ func Parse() {
 }
 
 func printErrorAndExit(err error) {
-	fmt.Fprintf(os.Stderr, "%v\n", err)
+	fmt.Fprintln(os.Stderr, err)
 	os.Exit(1)
 }

internal/cli/daemon.go

@@ -13,7 +13,7 @@ import (
 	"time"
 
 	"miniflux.app/v2/internal/config"
-	httpd "miniflux.app/v2/internal/http/server"
+	"miniflux.app/v2/internal/http/server"
 	"miniflux.app/v2/internal/metric"
 	"miniflux.app/v2/internal/storage"
 	"miniflux.app/v2/internal/systemd"
@@ -33,9 +33,9 @@ func startDaemon(store *storage.Storage) {
 		runScheduler(store, pool)
 	}
 
-	var httpServer *http.Server
+	var httpServers []*http.Server
 	if config.Opts.HasHTTPService() {
-		httpServer = httpd.StartWebServer(store, pool)
+		httpServers = server.StartWebServer(store, pool)
 	}
 
 	if config.Opts.HasMetricsCollector() {
@@ -78,8 +78,18 @@ func startDaemon(store *storage.Storage) {
 	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
 	defer cancel()
 
-	if httpServer != nil {
-		httpServer.Shutdown(ctx)
+	if len(httpServers) > 0 {
+		slog.Debug("Shutting down HTTP servers...")
+		for _, server := range httpServers {
+			if server != nil {
+				if err := server.Shutdown(ctx); err != nil {
+					slog.Error("HTTP server shutdown error", slog.Any("error", err), slog.String("addr", server.Addr))
+				}
+			}
+		}
+		slog.Debug("All HTTP servers shut down.")
+	} else {
+		slog.Debug("No HTTP servers to shut down.")
 	}
 
 	slog.Debug("Process gracefully stopped")

internal/cli/health_check.go

@@ -14,7 +14,7 @@ import (
 
 func doHealthCheck(healthCheckEndpoint string) {
 	if healthCheckEndpoint == "auto" {
-		healthCheckEndpoint = "http://" + config.Opts.ListenAddr() + config.Opts.BasePath() + "/healthcheck"
+		healthCheckEndpoint = "http://" + config.Opts.ListenAddr()[0] + config.Opts.BasePath() + "/healthcheck"
 	}
 
 	slog.Debug("Executing health check request", slog.String("endpoint", healthCheckEndpoint))

internal/cli/refresh_feeds.go

@@ -25,6 +25,7 @@ func refreshFeeds(store *storage.Storage) {
 	batchBuilder.WithErrorLimit(config.Opts.PollingParsingErrorLimit())
 	batchBuilder.WithoutDisabledFeeds()
 	batchBuilder.WithNextCheckExpired()
+	batchBuilder.WithLimitPerHost(config.Opts.PollingLimitPerHost())
 
 	jobs, err := batchBuilder.FetchJobs()
 	if err != nil {
@@ -32,13 +33,9 @@ func refreshFeeds(store *storage.Storage) {
 		return
 	}
 
+	slog.Debug("Feed URLs in this batch", slog.Any("feed_urls", jobs.FeedURLs()))
+
 	nbJobs := len(jobs)
-
-	slog.Info("Created a batch of feeds",
-		slog.Int("nb_jobs", nbJobs),
-		slog.Int("batch_size", config.Opts.BatchSize()),
-	)
-
 	var jobQueue = make(chan model.Job, nbJobs)
 
 	slog.Info("Starting a pool of workers",

internal/cli/reset_password.go

@@ -4,6 +4,7 @@
 package cli // import "miniflux.app/v2/internal/cli"
 
 import (
+	"errors"
 	"fmt"
 
 	"miniflux.app/v2/internal/model"
@@ -19,7 +20,7 @@ func resetPassword(store *storage.Storage) {
 	}
 
 	if user == nil {
-		printErrorAndExit(fmt.Errorf("user not found"))
+		printErrorAndExit(errors.New("user not found"))
 	}
 
 	userModificationRequest := &model.UserModificationRequest{

internal/cli/scheduler.go

@@ -21,36 +21,36 @@ func runScheduler(store *storage.Storage, pool *worker.Pool) {
 		config.Opts.PollingFrequency(),
 		config.Opts.BatchSize(),
 		config.Opts.PollingParsingErrorLimit(),
+		config.Opts.PollingLimitPerHost(),
 	)
 
 	go cleanupScheduler(
 		store,
-		config.Opts.CleanupFrequencyHours(),
+		config.Opts.CleanupFrequency(),
 	)
 }
 
-func feedScheduler(store *storage.Storage, pool *worker.Pool, frequency, batchSize, errorLimit int) {
-	for range time.Tick(time.Duration(frequency) * time.Minute) {
+func feedScheduler(store *storage.Storage, pool *worker.Pool, frequency time.Duration, batchSize, errorLimit, limitPerHost int) {
+	for range time.Tick(frequency) {
 		// Generate a batch of feeds for any user that has feeds to refresh.
 		batchBuilder := store.NewBatchBuilder()
 		batchBuilder.WithBatchSize(batchSize)
 		batchBuilder.WithErrorLimit(errorLimit)
 		batchBuilder.WithoutDisabledFeeds()
 		batchBuilder.WithNextCheckExpired()
+		batchBuilder.WithLimitPerHost(limitPerHost)
 
 		if jobs, err := batchBuilder.FetchJobs(); err != nil {
 			slog.Error("Unable to fetch jobs from database", slog.Any("error", err))
 		} else if len(jobs) > 0 {
-			slog.Info("Created a batch of feeds",
-				slog.Int("nb_jobs", len(jobs)),
-			)
+			slog.Debug("Feed URLs in this batch", slog.Any("feed_urls", jobs.FeedURLs()))
 			pool.Push(jobs)
 		}
 	}
 }
 
-func cleanupScheduler(store *storage.Storage, frequency int) {
-	for range time.Tick(time.Duration(frequency) * time.Hour) {
+func cleanupScheduler(store *storage.Storage, frequency time.Duration) {
+	for range time.Tick(frequency) {
 		runCleanupTasks(store)
 	}
 }

internal/config/config.go

@@ -3,5 +3,9 @@
 
 package config // import "miniflux.app/v2/internal/config"
 
+import "miniflux.app/v2/internal/version"
+
 // Opts holds parsed configuration options.
-var Opts *Options
+var Opts *configOptions
+
+var defaultHTTPClientUserAgent = "Mozilla/5.0 (compatible; Miniflux/" + version.Version + "; +https://miniflux.app)"

internal/config/parser.go

@@ -10,335 +10,212 @@ import (
 	"errors"
 	"fmt"
 	"io"
-	"log/slog"
 	"net/url"
 	"os"
 	"strconv"
 	"strings"
+	"time"
 )
 
-// Parser handles configuration parsing.
-type Parser struct {
-	opts *Options
+type configParser struct {
+	options *configOptions
 }
 
-// NewParser returns a new Parser.
-func NewParser() *Parser {
-	return &Parser{
-		opts: NewOptions(),
+func NewConfigParser() *configParser {
+	return &configParser{
+		options: NewConfigOptions(),
 	}
 }
 
-// ParseEnvironmentVariables loads configuration values from environment variables.
-func (p *Parser) ParseEnvironmentVariables() (*Options, error) {
-	err := p.parseLines(os.Environ())
-	if err != nil {
+func (cp *configParser) ParseEnvironmentVariables() (*configOptions, error) {
+	if err := cp.parseLines(os.Environ()); err != nil {
 		return nil, err
 	}
-	return p.opts, nil
+
+	return cp.options, nil
 }
 
-// ParseFile loads configuration values from a local file.
-func (p *Parser) ParseFile(filename string) (*Options, error) {
+func (cp *configParser) ParseFile(filename string) (*configOptions, error) {
 	fp, err := os.Open(filename)
 	if err != nil {
 		return nil, err
 	}
 	defer fp.Close()
 
-	err = p.parseLines(p.parseFileContent(fp))
-	if err != nil {
+	if err := cp.parseLines(parseFileContent(fp)); err != nil {
 		return nil, err
 	}
-	return p.opts, nil
+
+	return cp.options, nil
 }
 
-func (p *Parser) parseFileContent(r io.Reader) (lines []string) {
-	scanner := bufio.NewScanner(r)
-	for scanner.Scan() {
-		line := strings.TrimSpace(scanner.Text())
-		if !strings.HasPrefix(line, "#") && strings.Index(line, "=") > 0 {
-			lines = append(lines, line)
-		}
-	}
-	return lines
-}
+func (cp *configParser) postParsing() error {
+	// Parse basePath and rootURL based on BASE_URL
+	baseURL := cp.options.options["BASE_URL"].ParsedStringValue
+	baseURL = strings.TrimSuffix(baseURL, "/")
 
-func (p *Parser) parseLines(lines []string) (err error) {
-	var port string
-
-	for _, line := range lines {
-		fields := strings.SplitN(line, "=", 2)
-		key := strings.TrimSpace(fields[0])
-		value := strings.TrimSpace(fields[1])
-
-		switch key {
-		case "LOG_FILE":
-			p.opts.logFile = parseString(value, defaultLogFile)
-		case "LOG_DATE_TIME":
-			p.opts.logDateTime = parseBool(value, defaultLogDateTime)
-		case "LOG_LEVEL":
-			parsedValue := parseString(value, defaultLogLevel)
-			if parsedValue == "debug" || parsedValue == "info" || parsedValue == "warning" || parsedValue == "error" {
-				p.opts.logLevel = parsedValue
-			}
-		case "LOG_FORMAT":
-			parsedValue := parseString(value, defaultLogFormat)
-			if parsedValue == "json" || parsedValue == "text" {
-				p.opts.logFormat = parsedValue
-			}
-		case "DEBUG":
-			slog.Warn("The DEBUG environment variable is deprecated, use LOG_LEVEL instead")
-			parsedValue := parseBool(value, defaultDebug)
-			if parsedValue {
-				p.opts.logLevel = "debug"
-			}
-		case "SERVER_TIMING_HEADER":
-			p.opts.serverTimingHeader = parseBool(value, defaultTiming)
-		case "BASE_URL":
-			p.opts.baseURL, p.opts.rootURL, p.opts.basePath, err = parseBaseURL(value)
-			if err != nil {
-				return err
-			}
-		case "PORT":
-			port = value
-		case "LISTEN_ADDR":
-			p.opts.listenAddr = parseString(value, defaultListenAddr)
-		case "DATABASE_URL":
-			p.opts.databaseURL = parseString(value, defaultDatabaseURL)
-		case "DATABASE_URL_FILE":
-			p.opts.databaseURL = readSecretFile(value, defaultDatabaseURL)
-		case "DATABASE_MAX_CONNS":
-			p.opts.databaseMaxConns = parseInt(value, defaultDatabaseMaxConns)
-		case "DATABASE_MIN_CONNS":
-			p.opts.databaseMinConns = parseInt(value, defaultDatabaseMinConns)
-		case "DATABASE_CONNECTION_LIFETIME":
-			p.opts.databaseConnectionLifetime = parseInt(value, defaultDatabaseConnectionLifetime)
-		case "FILTER_ENTRY_MAX_AGE_DAYS":
-			p.opts.filterEntryMaxAgeDays = parseInt(value, defaultFilterEntryMaxAgeDays)
-		case "RUN_MIGRATIONS":
-			p.opts.runMigrations = parseBool(value, defaultRunMigrations)
-		case "DISABLE_HSTS":
-			p.opts.hsts = !parseBool(value, defaultHSTS)
-		case "HTTPS":
-			p.opts.HTTPS = parseBool(value, defaultHTTPS)
-		case "DISABLE_SCHEDULER_SERVICE":
-			p.opts.schedulerService = !parseBool(value, defaultSchedulerService)
-		case "DISABLE_HTTP_SERVICE":
-			p.opts.httpService = !parseBool(value, defaultHTTPService)
-		case "CERT_FILE":
-			p.opts.certFile = parseString(value, defaultCertFile)
-		case "KEY_FILE":
-			p.opts.certKeyFile = parseString(value, defaultKeyFile)
-		case "CERT_DOMAIN":
-			p.opts.certDomain = parseString(value, defaultCertDomain)
-		case "CLEANUP_FREQUENCY_HOURS":
-			p.opts.cleanupFrequencyHours = parseInt(value, defaultCleanupFrequencyHours)
-		case "CLEANUP_ARCHIVE_READ_DAYS":
-			p.opts.cleanupArchiveReadDays = parseInt(value, defaultCleanupArchiveReadDays)
-		case "CLEANUP_ARCHIVE_UNREAD_DAYS":
-			p.opts.cleanupArchiveUnreadDays = parseInt(value, defaultCleanupArchiveUnreadDays)
-		case "CLEANUP_ARCHIVE_BATCH_SIZE":
-			p.opts.cleanupArchiveBatchSize = parseInt(value, defaultCleanupArchiveBatchSize)
-		case "CLEANUP_REMOVE_SESSIONS_DAYS":
-			p.opts.cleanupRemoveSessionsDays = parseInt(value, defaultCleanupRemoveSessionsDays)
-		case "WORKER_POOL_SIZE":
-			p.opts.workerPoolSize = parseInt(value, defaultWorkerPoolSize)
-		case "POLLING_FREQUENCY":
-			p.opts.pollingFrequency = parseInt(value, defaultPollingFrequency)
-		case "FORCE_REFRESH_INTERVAL":
-			p.opts.forceRefreshInterval = parseInt(value, defaultForceRefreshInterval)
-		case "BATCH_SIZE":
-			p.opts.batchSize = parseInt(value, defaultBatchSize)
-		case "POLLING_SCHEDULER":
-			p.opts.pollingScheduler = strings.ToLower(parseString(value, defaultPollingScheduler))
-		case "SCHEDULER_ENTRY_FREQUENCY_MAX_INTERVAL":
-			p.opts.schedulerEntryFrequencyMaxInterval = parseInt(value, defaultSchedulerEntryFrequencyMaxInterval)
-		case "SCHEDULER_ENTRY_FREQUENCY_MIN_INTERVAL":
-			p.opts.schedulerEntryFrequencyMinInterval = parseInt(value, defaultSchedulerEntryFrequencyMinInterval)
-		case "SCHEDULER_ENTRY_FREQUENCY_FACTOR":
-			p.opts.schedulerEntryFrequencyFactor = parseInt(value, defaultSchedulerEntryFrequencyFactor)
-		case "SCHEDULER_ROUND_ROBIN_MIN_INTERVAL":
-			p.opts.schedulerRoundRobinMinInterval = parseInt(value, defaultSchedulerRoundRobinMinInterval)
-		case "SCHEDULER_ROUND_ROBIN_MAX_INTERVAL":
-			p.opts.schedulerRoundRobinMaxInterval = parseInt(value, defaultSchedulerRoundRobinMaxInterval)
-		case "POLLING_PARSING_ERROR_LIMIT":
-			p.opts.pollingParsingErrorLimit = parseInt(value, defaultPollingParsingErrorLimit)
-		case "PROXY_IMAGES":
-			slog.Warn("The PROXY_IMAGES environment variable is deprecated, use MEDIA_PROXY_MODE instead")
-			p.opts.mediaProxyMode = parseString(value, defaultMediaProxyMode)
-		case "PROXY_HTTP_CLIENT_TIMEOUT":
-			slog.Warn("The PROXY_HTTP_CLIENT_TIMEOUT environment variable is deprecated, use MEDIA_PROXY_HTTP_CLIENT_TIMEOUT instead")
-			p.opts.mediaProxyHTTPClientTimeout = parseInt(value, defaultMediaProxyHTTPClientTimeout)
-		case "MEDIA_PROXY_HTTP_CLIENT_TIMEOUT":
-			p.opts.mediaProxyHTTPClientTimeout = parseInt(value, defaultMediaProxyHTTPClientTimeout)
-		case "PROXY_OPTION":
-			slog.Warn("The PROXY_OPTION environment variable is deprecated, use MEDIA_PROXY_MODE instead")
-			p.opts.mediaProxyMode = parseString(value, defaultMediaProxyMode)
-		case "MEDIA_PROXY_MODE":
-			p.opts.mediaProxyMode = parseString(value, defaultMediaProxyMode)
-		case "PROXY_MEDIA_TYPES":
-			slog.Warn("The PROXY_MEDIA_TYPES environment variable is deprecated, use MEDIA_PROXY_RESOURCE_TYPES instead")
-			p.opts.mediaProxyResourceTypes = parseStringList(value, []string{defaultMediaResourceTypes})
-		case "MEDIA_PROXY_RESOURCE_TYPES":
-			p.opts.mediaProxyResourceTypes = parseStringList(value, []string{defaultMediaResourceTypes})
-		case "PROXY_IMAGE_URL":
-			slog.Warn("The PROXY_IMAGE_URL environment variable is deprecated, use MEDIA_PROXY_CUSTOM_URL instead")
-			p.opts.mediaProxyCustomURL = parseString(value, defaultMediaProxyURL)
-		case "PROXY_URL":
-			slog.Warn("The PROXY_URL environment variable is deprecated, use MEDIA_PROXY_CUSTOM_URL instead")
-			p.opts.mediaProxyCustomURL = parseString(value, defaultMediaProxyURL)
-		case "PROXY_PRIVATE_KEY":
-			slog.Warn("The PROXY_PRIVATE_KEY environment variable is deprecated, use MEDIA_PROXY_PRIVATE_KEY instead")
-			randomKey := make([]byte, 16)
-			if _, err := rand.Read(randomKey); err != nil {
-				return fmt.Errorf("config: unable to generate random key: %w", err)
-			}
-			p.opts.mediaProxyPrivateKey = parseBytes(value, randomKey)
-		case "MEDIA_PROXY_PRIVATE_KEY":
-			randomKey := make([]byte, 16)
-			if _, err := rand.Read(randomKey); err != nil {
-				return fmt.Errorf("config: unable to generate random key: %w", err)
-			}
-			p.opts.mediaProxyPrivateKey = parseBytes(value, randomKey)
-		case "MEDIA_PROXY_CUSTOM_URL":
-			p.opts.mediaProxyCustomURL = parseString(value, defaultMediaProxyURL)
-		case "CREATE_ADMIN":
-			p.opts.createAdmin = parseBool(value, defaultCreateAdmin)
-		case "ADMIN_USERNAME":
-			p.opts.adminUsername = parseString(value, defaultAdminUsername)
-		case "ADMIN_USERNAME_FILE":
-			p.opts.adminUsername = readSecretFile(value, defaultAdminUsername)
-		case "ADMIN_PASSWORD":
-			p.opts.adminPassword = parseString(value, defaultAdminPassword)
-		case "ADMIN_PASSWORD_FILE":
-			p.opts.adminPassword = readSecretFile(value, defaultAdminPassword)
-		case "POCKET_CONSUMER_KEY":
-			p.opts.pocketConsumerKey = parseString(value, defaultPocketConsumerKey)
-		case "POCKET_CONSUMER_KEY_FILE":
-			p.opts.pocketConsumerKey = readSecretFile(value, defaultPocketConsumerKey)
-		case "OAUTH2_USER_CREATION":
-			p.opts.oauth2UserCreationAllowed = parseBool(value, defaultOAuth2UserCreation)
-		case "OAUTH2_CLIENT_ID":
-			p.opts.oauth2ClientID = parseString(value, defaultOAuth2ClientID)
-		case "OAUTH2_CLIENT_ID_FILE":
-			p.opts.oauth2ClientID = readSecretFile(value, defaultOAuth2ClientID)
-		case "OAUTH2_CLIENT_SECRET":
-			p.opts.oauth2ClientSecret = parseString(value, defaultOAuth2ClientSecret)
-		case "OAUTH2_CLIENT_SECRET_FILE":
-			p.opts.oauth2ClientSecret = readSecretFile(value, defaultOAuth2ClientSecret)
-		case "OAUTH2_REDIRECT_URL":
-			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":
-			p.opts.httpClientMaxBodySize = int64(parseInt(value, defaultHTTPClientMaxBodySize) * 1024 * 1024)
-		case "HTTP_CLIENT_PROXY":
-			p.opts.httpClientProxyURL, err = url.Parse(parseString(value, defaultHTTPClientProxy))
-			if err != nil {
-				return fmt.Errorf("config: invalid HTTP_CLIENT_PROXY value: %w", err)
-			}
-		case "HTTP_CLIENT_PROXIES":
-			p.opts.httpClientProxies = parseStringList(value, []string{})
-		case "HTTP_CLIENT_USER_AGENT":
-			p.opts.httpClientUserAgent = parseString(value, defaultHTTPClientUserAgent)
-		case "HTTP_SERVER_TIMEOUT":
-			p.opts.httpServerTimeout = parseInt(value, defaultHTTPServerTimeout)
-		case "AUTH_PROXY_HEADER":
-			p.opts.authProxyHeader = parseString(value, defaultAuthProxyHeader)
-		case "AUTH_PROXY_USER_CREATION":
-			p.opts.authProxyUserCreation = parseBool(value, defaultAuthProxyUserCreation)
-		case "MAINTENANCE_MODE":
-			p.opts.maintenanceMode = parseBool(value, defaultMaintenanceMode)
-		case "MAINTENANCE_MESSAGE":
-			p.opts.maintenanceMessage = parseString(value, defaultMaintenanceMessage)
-		case "METRICS_COLLECTOR":
-			p.opts.metricsCollector = parseBool(value, defaultMetricsCollector)
-		case "METRICS_REFRESH_INTERVAL":
-			p.opts.metricsRefreshInterval = parseInt(value, defaultMetricsRefreshInterval)
-		case "METRICS_ALLOWED_NETWORKS":
-			p.opts.metricsAllowedNetworks = parseStringList(value, []string{defaultMetricsAllowedNetworks})
-		case "METRICS_USERNAME":
-			p.opts.metricsUsername = parseString(value, defaultMetricsUsername)
-		case "METRICS_USERNAME_FILE":
-			p.opts.metricsUsername = readSecretFile(value, defaultMetricsUsername)
-		case "METRICS_PASSWORD":
-			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":
-			p.opts.watchdog = parseBool(value, defaultWatchdog)
-		case "INVIDIOUS_INSTANCE":
-			p.opts.invidiousInstance = parseString(value, defaultInvidiousInstance)
-		case "WEBAUTHN":
-			p.opts.webAuthn = parseBool(value, defaultWebAuthn)
-		}
-	}
-
-	if port != "" {
-		p.opts.listenAddr = ":" + port
-	}
-	return nil
-}
-
-func parseBaseURL(value string) (string, string, string, error) {
-	if value == "" {
-		return defaultBaseURL, defaultRootURL, "", nil
-	}
-
-	if value[len(value)-1:] == "/" {
-		value = value[:len(value)-1]
-	}
-
-	parsedURL, err := url.Parse(value)
+	parsedURL, err := url.Parse(baseURL)
 	if err != nil {
-		return "", "", "", fmt.Errorf("config: invalid BASE_URL: %w", err)
+		return fmt.Errorf("invalid BASE_URL: %v", err)
 	}
 
 	scheme := strings.ToLower(parsedURL.Scheme)
 	if scheme != "https" && scheme != "http" {
-		return "", "", "", errors.New("config: invalid BASE_URL: scheme must be http or https")
+		return errors.New("BASE_URL scheme must be http or https")
 	}
 
-	basePath := parsedURL.Path
+	cp.options.options["BASE_URL"].ParsedStringValue = baseURL
+	cp.options.basePath = parsedURL.Path
+
 	parsedURL.Path = ""
-	return value, parsedURL.String(), basePath, nil
+	cp.options.rootURL = parsedURL.String()
+
+	// Parse YouTube embed domain based on YOUTUBE_EMBED_URL_OVERRIDE
+	youTubeEmbedURLOverride := cp.options.options["YOUTUBE_EMBED_URL_OVERRIDE"].ParsedStringValue
+	if youTubeEmbedURLOverride != "" {
+		parsedYouTubeEmbedURL, err := url.Parse(youTubeEmbedURLOverride)
+		if err != nil {
+			return fmt.Errorf("invalid YOUTUBE_EMBED_URL_OVERRIDE: %v", err)
+		}
+		cp.options.youTubeEmbedDomain = parsedYouTubeEmbedURL.Hostname()
+	}
+
+	// Generate a media proxy private key if not set
+	if len(cp.options.options["MEDIA_PROXY_PRIVATE_KEY"].ParsedBytesValue) == 0 {
+		randomKey := make([]byte, 16)
+		rand.Read(randomKey)
+		cp.options.options["MEDIA_PROXY_PRIVATE_KEY"].ParsedBytesValue = randomKey
+	}
+
+	// Override LISTEN_ADDR with PORT if set (for compatibility reasons)
+	if cp.options.Port() != "" {
+		cp.options.options["LISTEN_ADDR"].ParsedStringList = []string{":" + cp.options.Port()}
+		cp.options.options["LISTEN_ADDR"].RawValue = ":" + cp.options.Port()
+	}
+
+	return nil
 }
 
-func parseBool(value string, fallback bool) bool {
+func (cp *configParser) parseLines(lines []string) error {
+	for lineNum, line := range lines {
+		key, value, ok := strings.Cut(line, "=")
+		if !ok {
+			return fmt.Errorf("unable to parse configuration, invalid format on line %d", lineNum)
+		}
+
+		key, value = strings.TrimSpace(key), strings.TrimSpace(value)
+		if err := cp.parseLine(key, value); err != nil {
+			return err
+		}
+	}
+
+	if err := cp.postParsing(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (cp *configParser) parseLine(key, value string) error {
+	field, exists := cp.options.options[key]
+	if !exists {
+		// Ignore unknown configuration keys to avoid parsing unrelated environment variables.
+		return nil
+	}
+
+	// Validate the option if a validator is provided
+	if field.Validator != nil {
+		if err := field.Validator(value); err != nil {
+			return fmt.Errorf("invalid value for key %s: %v", key, err)
+		}
+	}
+
+	// Convert the raw value based on its type
+	switch field.ValueType {
+	case stringType:
+		field.ParsedStringValue = parseStringValue(value, field.ParsedStringValue)
+		field.RawValue = value
+	case stringListType:
+		field.ParsedStringList = parseStringListValue(value, field.ParsedStringList)
+		field.RawValue = value
+	case boolType:
+		parsedValue, err := parseBoolValue(value, field.ParsedBoolValue)
+		if err != nil {
+			return fmt.Errorf("invalid boolean value for key %s: %v", key, err)
+		}
+		field.ParsedBoolValue = parsedValue
+		field.RawValue = value
+	case intType:
+		field.ParsedIntValue = parseIntValue(value, field.ParsedIntValue)
+		field.RawValue = value
+	case int64Type:
+		field.ParsedInt64Value = ParsedInt64Value(value, field.ParsedInt64Value)
+		field.RawValue = value
+	case secondType:
+		field.ParsedDuration = parseDurationValue(value, time.Second, field.ParsedDuration)
+		field.RawValue = value
+	case minuteType:
+		field.ParsedDuration = parseDurationValue(value, time.Minute, field.ParsedDuration)
+		field.RawValue = value
+	case hourType:
+		field.ParsedDuration = parseDurationValue(value, time.Hour, field.ParsedDuration)
+		field.RawValue = value
+	case dayType:
+		field.ParsedDuration = parseDurationValue(value, time.Hour*24, field.ParsedDuration)
+		field.RawValue = value
+	case urlType:
+		parsedURL, err := parseURLValue(value, field.ParsedURLValue)
+		if err != nil {
+			return fmt.Errorf("invalid URL for key %s: %v", key, err)
+		}
+		field.ParsedURLValue = parsedURL
+		field.RawValue = value
+	case secretFileType:
+		secretValue, err := readSecretFileValue(value)
+		if err != nil {
+			return fmt.Errorf("error reading secret file for key %s: %v", key, err)
+		}
+		if field.TargetKey != "" {
+			if targetField, ok := cp.options.options[field.TargetKey]; ok {
+				targetField.ParsedStringValue = secretValue
+				targetField.RawValue = secretValue
+			}
+		}
+		field.RawValue = value
+	case bytesType:
+		if value != "" {
+			field.ParsedBytesValue = []byte(value)
+			field.RawValue = value
+		}
+	}
+
+	return nil
+}
+
+func parseStringValue(value string, fallback string) string {
 	if value == "" {
 		return fallback
 	}
+	return value
+}
+
+func parseBoolValue(value string, fallback bool) (bool, error) {
+	if value == "" {
+		return fallback, nil
+	}
 
 	value = strings.ToLower(value)
 	if value == "1" || value == "yes" || value == "true" || value == "on" {
-		return true
+		return true, nil
+	}
+	if value == "0" || value == "no" || value == "false" || value == "off" {
+		return false, nil
 	}
 
-	return false
+	return false, fmt.Errorf("invalid boolean value: %q", value)
 }
 
-func parseInt(value string, fallback int) int {
+func parseIntValue(value string, fallback int) int {
 	if value == "" {
 		return fallback
 	}
@@ -351,52 +228,86 @@ func parseInt(value string, fallback int) int {
 	return v
 }
 
-func parseString(value string, fallback string) string {
+func ParsedInt64Value(value string, fallback int64) int64 {
 	if value == "" {
 		return fallback
 	}
-	return value
+
+	v, err := strconv.ParseInt(value, 10, 64)
+	if err != nil {
+		return fallback
+	}
+
+	return v
 }
 
-func parseStringList(value string, fallback []string) []string {
+func parseStringListValue(value string, fallback []string) []string {
 	if value == "" {
 		return fallback
 	}
 
 	var strList []string
-	strMap := make(map[string]bool)
+	present := make(map[string]bool)
 
-	items := strings.Split(value, ",")
-	for _, item := range items {
-		itemValue := strings.TrimSpace(item)
-
-		if _, found := strMap[itemValue]; !found {
-			strMap[itemValue] = true
-			strList = append(strList, itemValue)
+	for item := range strings.SplitSeq(value, ",") {
+		if itemValue := strings.TrimSpace(item); itemValue != "" {
+			if !present[itemValue] {
+				present[itemValue] = true
+				strList = append(strList, itemValue)
+			}
 		}
 	}
 
 	return strList
 }
 
-func parseBytes(value string, fallback []byte) []byte {
+func parseDurationValue(value string, unit time.Duration, fallback time.Duration) time.Duration {
 	if value == "" {
 		return fallback
 	}
 
-	return []byte(value)
-}
-
-func readSecretFile(filename, fallback string) string {
-	data, err := os.ReadFile(filename)
+	v, err := strconv.Atoi(value)
 	if err != nil {
 		return fallback
 	}
 
-	value := string(bytes.TrimSpace(data))
+	return time.Duration(v) * unit
+}
+
+func parseURLValue(value string, fallback *url.URL) (*url.URL, error) {
 	if value == "" {
-		return fallback
+		return fallback, nil
 	}
 
-	return value
+	parsedURL, err := url.Parse(value)
+	if err != nil {
+		return fallback, err
+	}
+
+	return parsedURL, nil
+}
+
+func readSecretFileValue(filename string) (string, error) {
+	data, err := os.ReadFile(filename)
+	if err != nil {
+		return "", err
+	}
+
+	value := string(bytes.TrimSpace(data))
+	if value == "" {
+		return "", errors.New("secret file is empty")
+	}
+
+	return value, nil
+}
+
+func parseFileContent(r io.Reader) (lines []string) {
+	scanner := bufio.NewScanner(r)
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if !strings.HasPrefix(line, "#") && strings.Index(line, "=") > 0 {
+			lines = append(lines, line)
+		}
+	}
+	return lines
 }

internal/config/parser_test.go

@@ -4,57 +4,432 @@
 package config // import "miniflux.app/v2/internal/config"
 
 import (
+	"net/url"
+	"os"
+	"reflect"
 	"testing"
+	"time"
 )
 
-func TestParseBoolValue(t *testing.T) {
-	scenarios := map[string]bool{
-		"":        true,
-		"1":       true,
-		"Yes":     true,
-		"yes":     true,
-		"True":    true,
-		"true":    true,
-		"on":      true,
-		"false":   false,
-		"off":     false,
-		"invalid": false,
+func TestParseStringValue(t *testing.T) {
+	// Test with non-empty value
+	result := parseStringValue("test", "fallback")
+	if result != "test" {
+		t.Errorf("Expected 'test', got '%s'", result)
 	}
 
-	for input, expected := range scenarios {
-		result := parseBool(input, true)
-		if result != expected {
-			t.Errorf(`Unexpected result for %q, got %v instead of %v`, input, result, expected)
+	// Test with empty value
+	result = parseStringValue("", "fallback")
+	if result != "fallback" {
+		t.Errorf("Expected 'fallback', got '%s'", result)
+	}
+
+	// Test with empty value and empty fallback
+	result = parseStringValue("", "")
+	if result != "" {
+		t.Errorf("Expected empty string, got '%s'", result)
+	}
+}
+
+func TestParseBoolValue(t *testing.T) {
+	// Test with empty value - should return fallback
+	result, err := parseBoolValue("", true)
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != true {
+		t.Errorf("Expected true, got %v", result)
+	}
+
+	// Test true values
+	trueValues := []string{"1", "yes", "true", "on", "YES", "TRUE", "ON"}
+	for _, value := range trueValues {
+		result, err := parseBoolValue(value, false)
+		if err != nil {
+			t.Errorf("Unexpected error for value '%s': %v", value, err)
+		}
+		if result != true {
+			t.Errorf("Expected true for '%s', got %v", value, result)
 		}
 	}
-}
 
-func TestParseStringValueWithUnsetVariable(t *testing.T) {
-	if parseString("", "defaultValue") != "defaultValue" {
-		t.Errorf(`Unset variables should returns the default value`)
+	// Test false values
+	falseValues := []string{"0", "no", "false", "off", "NO", "FALSE", "OFF"}
+	for _, value := range falseValues {
+		result, err := parseBoolValue(value, true)
+		if err != nil {
+			t.Errorf("Unexpected error for value '%s': %v", value, err)
+		}
+		if result != false {
+			t.Errorf("Expected false for '%s', got %v", value, result)
+		}
 	}
-}
 
-func TestParseStringValue(t *testing.T) {
-	if parseString("test", "defaultValue") != "test" {
-		t.Errorf(`Defined variables should returns the specified value`)
-	}
-}
-
-func TestParseIntValueWithUnsetVariable(t *testing.T) {
-	if parseInt("", 42) != 42 {
-		t.Errorf(`Unset variables should returns the default value`)
-	}
-}
-
-func TestParseIntValueWithInvalidInput(t *testing.T) {
-	if parseInt("invalid integer", 42) != 42 {
-		t.Errorf(`Invalid integer should returns the default value`)
+	// Test invalid value - should return error
+	_, err = parseBoolValue("invalid", false)
+	if err == nil {
+		t.Error("Expected error for invalid boolean value")
 	}
 }
 
 func TestParseIntValue(t *testing.T) {
-	if parseInt("2018", 42) != 2018 {
-		t.Errorf(`Defined variables should returns the specified value`)
+	// Test with empty value - should return fallback
+	result := parseIntValue("", 42)
+	if result != 42 {
+		t.Errorf("Expected 42, got %d", result)
+	}
+
+	// Test with valid integer
+	result = parseIntValue("123", 42)
+	if result != 123 {
+		t.Errorf("Expected 123, got %d", result)
+	}
+
+	// Test with invalid integer - should return fallback
+	result = parseIntValue("invalid", 42)
+	if result != 42 {
+		t.Errorf("Expected 42, got %d", result)
+	}
+
+	// Test with zero
+	result = parseIntValue("0", 42)
+	if result != 0 {
+		t.Errorf("Expected 0, got %d", result)
+	}
+}
+
+func TestParsedInt64Value(t *testing.T) {
+	// Test with empty value - should return fallback
+	result := ParsedInt64Value("", 42)
+	if result != 42 {
+		t.Errorf("Expected 42, got %d", result)
+	}
+
+	// Test with valid int64
+	result = ParsedInt64Value("9223372036854775807", 42)
+	if result != 9223372036854775807 {
+		t.Errorf("Expected 9223372036854775807, got %d", result)
+	}
+
+	// Test with invalid int64 - should return fallback
+	result = ParsedInt64Value("invalid", 42)
+	if result != 42 {
+		t.Errorf("Expected 42, got %d", result)
+	}
+}
+
+func TestParseStringListValue(t *testing.T) {
+	// Test with empty value - should return fallback
+	fallback := []string{"a", "b"}
+	result := parseStringListValue("", fallback)
+	if !reflect.DeepEqual(result, fallback) {
+		t.Errorf("Expected %v, got %v", fallback, result)
+	}
+
+	// Test with single value
+	result = parseStringListValue("item1", nil)
+	expected := []string{"item1"}
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+
+	// Test with multiple values
+	result = parseStringListValue("item1,item2,item3", nil)
+	expected = []string{"item1", "item2", "item3"}
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+
+	// Test with duplicates - should remove duplicates
+	result = parseStringListValue("item1,item2,item1", nil)
+	expected = []string{"item1", "item2"}
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+
+	// Test with spaces
+	result = parseStringListValue(" item1 , item2 , item3 ", nil)
+	expected = []string{"item1", "item2", "item3"}
+	if !reflect.DeepEqual(result, expected) {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+}
+
+func TestParseDurationValue(t *testing.T) {
+	// Test with empty value - should return fallback
+	fallback := 5 * time.Second
+	result := parseDurationValue("", time.Second, fallback)
+	if result != fallback {
+		t.Errorf("Expected %v, got %v", fallback, result)
+	}
+
+	// Test with valid duration
+	result = parseDurationValue("30", time.Second, fallback)
+	expected := 30 * time.Second
+	if result != expected {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+
+	// Test with minutes
+	result = parseDurationValue("5", time.Minute, fallback)
+	expected = 5 * time.Minute
+	if result != expected {
+		t.Errorf("Expected %v, got %v", expected, result)
+	}
+
+	// Test with invalid value - should return fallback
+	result = parseDurationValue("invalid", time.Second, fallback)
+	if result != fallback {
+		t.Errorf("Expected %v, got %v", fallback, result)
+	}
+}
+
+func TestParseURLValue(t *testing.T) {
+	// Test with empty value - should return fallback
+	fallbackURL, _ := url.Parse("https://fallback.com")
+	result, err := parseURLValue("", fallbackURL)
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result != fallbackURL {
+		t.Errorf("Expected %v, got %v", fallbackURL, result)
+	}
+
+	// Test with valid URL
+	result, err = parseURLValue("https://example.com", nil)
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+	if result.String() != "https://example.com" {
+		t.Errorf("Expected https://example.com, got %s", result.String())
+	}
+
+	// Test with invalid URL - should return fallback and error
+	result, err = parseURLValue("://invalid", fallbackURL)
+	if err == nil {
+		t.Error("Expected error for invalid URL")
+	}
+	if result != fallbackURL {
+		t.Errorf("Expected fallback URL, got %v", result)
+	}
+}
+
+func TestConfigFileParsing(t *testing.T) {
+	fileContent := `
+		# This is a comment
+		LOG_FILE=miniflux.log
+		LOG_DATE_TIME=1
+		LOG_FORMAT=json
+		LISTEN_ADDR=:8080,:8443
+	`
+
+	// Write a temporary config file and parse it
+	tmpFile, err := os.CreateTemp("", "miniflux-*.txt")
+	if err != nil {
+		t.Fatalf("Failed to create temporary file: %v", err)
+	}
+
+	defer os.Remove(tmpFile.Name())
+	defer tmpFile.Close()
+
+	filename := tmpFile.Name()
+	if _, err := tmpFile.WriteString(fileContent); err != nil {
+		t.Fatalf("Failed to write to temporary file: %v", err)
+	}
+
+	configParser := NewConfigParser()
+	configOptions, err := configParser.ParseFile(filename)
+	if err != nil {
+		t.Fatalf("Unexpected parsing error: %v", err)
+	}
+
+	if configOptions.LogFile() != "miniflux.log" {
+		t.Fatalf("Unexpected log file, got %q", configOptions.LogFile())
+	}
+
+	if configOptions.LogDateTime() != true {
+		t.Fatalf("Unexpected log datetime, got %v", configOptions.LogDateTime())
+	}
+
+	if configOptions.LogFormat() != "json" {
+		t.Fatalf("Unexpected log format, got %q", configOptions.LogFormat())
+	}
+
+	if configOptions.LogLevel() != "info" {
+		t.Fatalf("Unexpected log level, got %q", configOptions.LogLevel())
+	}
+
+	if len(configOptions.ListenAddr()) != 2 || configOptions.ListenAddr()[0] != ":8080" || configOptions.ListenAddr()[1] != ":8443" {
+		t.Fatalf("Unexpected listen addresses, got %v", configOptions.ListenAddr())
+	}
+}
+
+func TestConfigFileParsingWithIncorrectKeyValuePair(t *testing.T) {
+	fileContent := `
+		LOG_FILE=miniflux.log
+		INVALID_LINE
+	`
+
+	// Write a temporary config file and parse it
+	tmpFile, err := os.CreateTemp("", "miniflux-*.txt")
+	if err != nil {
+		t.Fatalf("Failed to create temporary file: %v", err)
+	}
+
+	defer os.Remove(tmpFile.Name())
+	defer tmpFile.Close()
+
+	filename := tmpFile.Name()
+	if _, err := tmpFile.WriteString(fileContent); err != nil {
+		t.Fatalf("Failed to write to temporary file: %v", err)
+	}
+
+	configParser := NewConfigParser()
+	_, err = configParser.ParseFile(filename)
+	if err != nil {
+		t.Fatal("Invalid lines should be ignored, but got error:", err)
+	}
+}
+
+func TestParseAdminPasswordFileOption(t *testing.T) {
+	tmpFile, err := os.CreateTemp("", "password-*.txt")
+	if err != nil {
+		t.Fatalf("Failed to create temporary file: %v", err)
+	}
+	defer os.Remove(tmpFile.Name())
+	defer tmpFile.Close()
+
+	password := "supersecret"
+	if _, err := tmpFile.WriteString(password); err != nil {
+		t.Fatalf("Failed to write to temporary file: %v", err)
+	}
+
+	os.Clearenv()
+	os.Setenv("ADMIN_PASSWORD_FILE", tmpFile.Name())
+
+	configParser := NewConfigParser()
+	configOptions, err := configParser.ParseEnvironmentVariables()
+	if err != nil {
+		t.Fatalf("Unexpected parsing error: %v", err)
+	}
+
+	if configOptions.AdminPassword() != password {
+		t.Fatalf("Unexpected admin password, got %q", configOptions.AdminPassword())
+	}
+}
+
+func TestParseAdminPasswordFileOptionWithEmptyFile(t *testing.T) {
+	tmpFile, err := os.CreateTemp("", "empty-password-*.txt")
+	if err != nil {
+		t.Fatalf("Failed to create temporary file: %v", err)
+	}
+	defer os.Remove(tmpFile.Name())
+	defer tmpFile.Close()
+
+	os.Clearenv()
+	os.Setenv("ADMIN_PASSWORD_FILE", tmpFile.Name())
+
+	configParser := NewConfigParser()
+	_, err = configParser.ParseEnvironmentVariables()
+	if err == nil {
+		t.Fatal("Expected error due to empty password file, but got none")
+	}
+}
+
+func TestParseLogFileOptionDefaultValue(t *testing.T) {
+	os.Clearenv()
+
+	configParser := NewConfigParser()
+	configOptions, err := configParser.ParseEnvironmentVariables()
+	if err != nil {
+		t.Fatalf("Unexpected parsing error: %v", err)
+	}
+
+	if configOptions.LogFile() != "stderr" {
+		t.Fatalf("Unexpected default log file, got %q", configOptions.LogFile())
+	}
+}
+
+func TestParseLogFileOptionWithCustomFilename(t *testing.T) {
+	os.Clearenv()
+	os.Setenv("LOG_FILE", "miniflux.log")
+
+	configParser := NewConfigParser()
+	configOptions, err := configParser.ParseEnvironmentVariables()
+	if err != nil {
+		t.Fatalf("Unexpected parsing error: %v", err)
+	}
+
+	if configOptions.LogFile() != "miniflux.log" {
+		t.Fatalf("Unexpected log file, got %q", configOptions.LogFile())
+	}
+}
+
+func TestParseLogFileOptionWithEmptyValue(t *testing.T) {
+	os.Clearenv()
+	os.Setenv("LOG_FILE", "")
+
+	configParser := NewConfigParser()
+	configOptions, err := configParser.ParseEnvironmentVariables()
+	if err != nil {
+		t.Fatalf("Unexpected parsing error: %v", err)
+	}
+
+	if configOptions.LogFile() != "stderr" {
+		t.Fatalf("Unexpected log file, got %q", configOptions.LogFile())
+	}
+}
+
+func TestParseLogDateTimeOptionDefaultValue(t *testing.T) {
+	os.Clearenv()
+
+	configParser := NewConfigParser()
+	configOptions, err := configParser.ParseEnvironmentVariables()
+	if err != nil {
+		t.Fatalf("Unexpected parsing error: %v", err)
+	}
+
+	if configOptions.LogDateTime() != false {
+		t.Fatalf("Unexpected default log datetime, got %v", configOptions.LogDateTime())
+	}
+}
+
+func TestParseLogDateTimeOptionWithCustomValue(t *testing.T) {
+	os.Clearenv()
+	os.Setenv("LOG_DATE_TIME", "true")
+
+	configParser := NewConfigParser()
+	configOptions, err := configParser.ParseEnvironmentVariables()
+	if err != nil {
+		t.Fatalf("Unexpected parsing error: %v", err)
+	}
+
+	if configOptions.LogDateTime() != true {
+		t.Fatalf("Unexpected log datetime, got %v", configOptions.LogDateTime())
+	}
+}
+
+func TestParseLogDateTimeOptionWithEmptyValue(t *testing.T) {
+	os.Clearenv()
+	os.Setenv("LOG_DATE_TIME", "")
+
+	configParser := NewConfigParser()
+	configOptions, err := configParser.ParseEnvironmentVariables()
+	if err != nil {
+		t.Fatalf("Unexpected parsing error: %v", err)
+	}
+
+	if configOptions.LogDateTime() != false {
+		t.Fatalf("Unexpected log datetime, got %v", configOptions.LogDateTime())
+	}
+}
+
+func TestParseLogDateTimeOptionWithIncorrectValue(t *testing.T) {
+	os.Clearenv()
+	os.Setenv("LOG_DATE_TIME", "invalid")
+
+	configParser := NewConfigParser()
+	if _, err := configParser.ParseEnvironmentVariables(); err == nil {
+		t.Fatal("Expected parsing error, got nil")
 	}
 }

internal/config/validators.go

@@ -0,0 +1,61 @@
+// SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package config // import "miniflux.app/v2/internal/config"
+
+import (
+	"errors"
+	"fmt"
+	"slices"
+	"strconv"
+	"strings"
+)
+
+func validateChoices(rawValue string, choices []string) error {
+	if !slices.Contains(choices, rawValue) {
+		return fmt.Errorf("value must be one of: %v", strings.Join(choices, ", "))
+	}
+	return nil
+}
+
+func validateListChoices(inputValues, choices []string) error {
+	for _, value := range inputValues {
+		if !slices.Contains(choices, value) {
+			return fmt.Errorf("value must be one of: %v", strings.Join(choices, ", "))
+		}
+	}
+	return nil
+}
+
+func validateGreaterThan(rawValue string, min int) error {
+	intValue, err := strconv.Atoi(rawValue)
+	if err != nil {
+		return errors.New("value must be an integer")
+	}
+	if intValue > min {
+		return nil
+	}
+	return fmt.Errorf("value must be at least %d", min)
+}
+
+func validateGreaterOrEqualThan(rawValue string, min int) error {
+	intValue, err := strconv.Atoi(rawValue)
+	if err != nil {
+		return errors.New("value must be an integer")
+	}
+	if intValue >= min {
+		return nil
+	}
+	return fmt.Errorf("value must be greater or equal than %d", min)
+}
+
+func validateRange(rawValue string, min, max int) error {
+	intValue, err := strconv.Atoi(rawValue)
+	if err != nil {
+		return errors.New("value must be an integer")
+	}
+	if intValue < min || intValue > max {
+		return fmt.Errorf("value must be between %d and %d", min, max)
+	}
+	return nil
+}

internal/config/validators_test.go

@@ -0,0 +1,372 @@
+// SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package config // import "miniflux.app/v2/internal/config"
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestValidateChoices(t *testing.T) {
+	tests := []struct {
+		name        string
+		rawValue    string
+		choices     []string
+		expectError bool
+	}{
+		{
+			name:        "valid choice",
+			rawValue:    "option1",
+			choices:     []string{"option1", "option2", "option3"},
+			expectError: false,
+		},
+		{
+			name:        "valid choice from middle",
+			rawValue:    "option2",
+			choices:     []string{"option1", "option2", "option3"},
+			expectError: false,
+		},
+		{
+			name:        "valid choice from end",
+			rawValue:    "option3",
+			choices:     []string{"option1", "option2", "option3"},
+			expectError: false,
+		},
+		{
+			name:        "invalid choice",
+			rawValue:    "invalid",
+			choices:     []string{"option1", "option2", "option3"},
+			expectError: true,
+		},
+		{
+			name:        "empty value with non-empty choices",
+			rawValue:    "",
+			choices:     []string{"option1", "option2"},
+			expectError: true,
+		},
+		{
+			name:        "case sensitive - different case",
+			rawValue:    "OPTION1",
+			choices:     []string{"option1", "option2"},
+			expectError: true,
+		},
+		{
+			name:        "single choice valid",
+			rawValue:    "only",
+			choices:     []string{"only"},
+			expectError: false,
+		},
+		{
+			name:        "empty choices list",
+			rawValue:    "anything",
+			choices:     []string{},
+			expectError: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := validateChoices(tt.rawValue, tt.choices)
+			if tt.expectError {
+				if err == nil {
+					t.Errorf("expected error but got none")
+				} else {
+					// Verify error message format
+					expectedPrefix := "value must be one of:"
+					if !strings.Contains(err.Error(), expectedPrefix) {
+						t.Errorf("error message should contain '%s', got: %s", expectedPrefix, err.Error())
+					}
+				}
+			} else {
+				if err != nil {
+					t.Errorf("expected no error but got: %v", err)
+				}
+			}
+		})
+	}
+}
+
+func TestValidateListChoices(t *testing.T) {
+	tests := []struct {
+		name        string
+		inputValues []string
+		choices     []string
+		expectError bool
+	}{
+		{
+			name:        "all valid choices",
+			inputValues: []string{"option1", "option2"},
+			choices:     []string{"option1", "option2", "option3"},
+			expectError: false,
+		},
+		{
+			name:        "single valid choice",
+			inputValues: []string{"option1"},
+			choices:     []string{"option1", "option2", "option3"},
+			expectError: false,
+		},
+		{
+			name:        "empty input list",
+			inputValues: []string{},
+			choices:     []string{"option1", "option2", "option3"},
+			expectError: false,
+		},
+		{
+			name:        "all choices from available list",
+			inputValues: []string{"option1", "option2", "option3"},
+			choices:     []string{"option1", "option2", "option3"},
+			expectError: false,
+		},
+		{
+			name:        "duplicate valid choices",
+			inputValues: []string{"option1", "option1", "option2"},
+			choices:     []string{"option1", "option2", "option3"},
+			expectError: false,
+		},
+		{
+			name:        "one invalid choice",
+			inputValues: []string{"option1", "invalid"},
+			choices:     []string{"option1", "option2", "option3"},
+			expectError: true,
+		},
+		{
+			name:        "all invalid choices",
+			inputValues: []string{"invalid1", "invalid2"},
+			choices:     []string{"option1", "option2", "option3"},
+			expectError: true,
+		},
+		{
+			name:        "case sensitive - different case",
+			inputValues: []string{"OPTION1"},
+			choices:     []string{"option1", "option2"},
+			expectError: true,
+		},
+		{
+			name:        "empty string in input",
+			inputValues: []string{""},
+			choices:     []string{"option1", "option2"},
+			expectError: true,
+		},
+		{
+			name:        "empty choices list with non-empty input",
+			inputValues: []string{"anything"},
+			choices:     []string{},
+			expectError: true,
+		},
+		{
+			name:        "mixed valid and invalid choices",
+			inputValues: []string{"option1", "invalid", "option2"},
+			choices:     []string{"option1", "option2", "option3"},
+			expectError: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := validateListChoices(tt.inputValues, tt.choices)
+			if tt.expectError {
+				if err == nil {
+					t.Errorf("expected error but got none")
+				} else {
+					// Verify error message format
+					expectedPrefix := "value must be one of:"
+					if !strings.Contains(err.Error(), expectedPrefix) {
+						t.Errorf("error message should contain '%s', got: %s", expectedPrefix, err.Error())
+					}
+				}
+			} else {
+				if err != nil {
+					t.Errorf("expected no error but got: %v", err)
+				}
+			}
+		})
+	}
+}
+
+func TestValidateGreaterThan(t *testing.T) {
+	if err := validateGreaterThan("10", 5); err != nil {
+		t.Errorf("expected no error, got: %v", err)
+	}
+
+	if err := validateGreaterThan("5", 5); err == nil {
+		t.Errorf("expected error, got none")
+	}
+
+	if err := validateGreaterThan("abc", 5); err == nil {
+		t.Errorf("expected error for non-integer input, got none")
+	}
+
+	if err := validateGreaterThan("-1", 0); err == nil {
+		t.Errorf("expected error for value below minimum, got none")
+	}
+}
+
+func TestValidateGreaterOrEqualThan(t *testing.T) {
+	if err := validateGreaterOrEqualThan("10", 5); err != nil {
+		t.Errorf("expected no error, got: %v", err)
+	}
+
+	if err := validateGreaterOrEqualThan("5", 5); err != nil {
+		t.Errorf("expected no error for equal value, got: %v", err)
+	}
+
+	if err := validateGreaterOrEqualThan("abc", 5); err == nil {
+		t.Errorf("expected error for non-integer input, got none")
+	}
+
+	if err := validateGreaterOrEqualThan("-1", 0); err == nil {
+		t.Errorf("expected error for value below minimum, got none")
+	}
+}
+
+func TestValidateRange(t *testing.T) {
+	tests := []struct {
+		name        string
+		rawValue    string
+		min         int
+		max         int
+		expectError bool
+		errorMsg    string
+	}{
+		{
+			name:        "valid integer within range",
+			rawValue:    "5",
+			min:         1,
+			max:         10,
+			expectError: false,
+		},
+		{
+			name:        "valid integer at minimum",
+			rawValue:    "1",
+			min:         1,
+			max:         10,
+			expectError: false,
+		},
+		{
+			name:        "valid integer at maximum",
+			rawValue:    "10",
+			min:         1,
+			max:         10,
+			expectError: false,
+		},
+		{
+			name:        "valid zero in range",
+			rawValue:    "0",
+			min:         -5,
+			max:         5,
+			expectError: false,
+		},
+		{
+			name:        "valid negative in range",
+			rawValue:    "-3",
+			min:         -5,
+			max:         5,
+			expectError: false,
+		},
+		{
+			name:        "integer below minimum",
+			rawValue:    "0",
+			min:         1,
+			max:         10,
+			expectError: true,
+			errorMsg:    "value must be between 1 and 10",
+		},
+		{
+			name:        "integer above maximum",
+			rawValue:    "11",
+			min:         1,
+			max:         10,
+			expectError: true,
+			errorMsg:    "value must be between 1 and 10",
+		},
+		{
+			name:        "integer far below minimum",
+			rawValue:    "-100",
+			min:         1,
+			max:         10,
+			expectError: true,
+			errorMsg:    "value must be between 1 and 10",
+		},
+		{
+			name:        "integer far above maximum",
+			rawValue:    "100",
+			min:         1,
+			max:         10,
+			expectError: true,
+			errorMsg:    "value must be between 1 and 10",
+		},
+		{
+			name:        "non-integer string",
+			rawValue:    "abc",
+			min:         1,
+			max:         10,
+			expectError: true,
+			errorMsg:    "value must be an integer",
+		},
+		{
+			name:        "empty string",
+			rawValue:    "",
+			min:         1,
+			max:         10,
+			expectError: true,
+			errorMsg:    "value must be an integer",
+		},
+		{
+			name:        "float string",
+			rawValue:    "5.5",
+			min:         1,
+			max:         10,
+			expectError: true,
+			errorMsg:    "value must be an integer",
+		},
+		{
+			name:        "string with spaces",
+			rawValue:    " 5 ",
+			min:         1,
+			max:         10,
+			expectError: true,
+			errorMsg:    "value must be an integer",
+		},
+		{
+			name:        "single value range",
+			rawValue:    "5",
+			min:         5,
+			max:         5,
+			expectError: false,
+		},
+		{
+			name:        "single value range - below",
+			rawValue:    "4",
+			min:         5,
+			max:         5,
+			expectError: true,
+			errorMsg:    "value must be between 5 and 5",
+		},
+		{
+			name:        "single value range - above",
+			rawValue:    "6",
+			min:         5,
+			max:         5,
+			expectError: true,
+			errorMsg:    "value must be between 5 and 5",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			err := validateRange(tt.rawValue, tt.min, tt.max)
+			if tt.expectError {
+				if err == nil {
+					t.Errorf("expected error but got none")
+				} else if tt.errorMsg != "" && err.Error() != tt.errorMsg {
+					t.Errorf("expected error message '%s', got '%s'", tt.errorMsg, err.Error())
+				}
+			} else {
+				if err != nil {
+					t.Errorf("expected no error but got: %v", err)
+				}
+			}
+		})
+	}
+}

internal/crypto/crypto.go

@@ -8,38 +8,33 @@ import (
 	"crypto/rand"
 	"crypto/sha256"
 	"crypto/subtle"
-	"encoding/base64"
 	"encoding/hex"
 	"fmt"
+	"hash/fnv"
 
 	"golang.org/x/crypto/bcrypt"
 )
 
-// HashFromBytes returns a SHA-256 checksum of the input.
+// HashFromBytes returns a non-cryptographic checksum of the input.
 func HashFromBytes(value []byte) string {
-	return fmt.Sprintf("%x", sha256.Sum256(value))
+	h := fnv.New128a()
+	h.Write(value)
+	return hex.EncodeToString(h.Sum(nil))
 }
 
-// Hash returns a SHA-256 checksum of a string.
-func Hash(value string) string {
-	return HashFromBytes([]byte(value))
+// SHA256 returns a SHA-256 checksum of a string.
+func SHA256(value string) string {
+	h := sha256.Sum256([]byte(value))
+	return hex.EncodeToString(h[:])
 }
 
 // GenerateRandomBytes returns random bytes.
 func GenerateRandomBytes(size int) []byte {
 	b := make([]byte, size)
-	if _, err := rand.Read(b); err != nil {
-		panic(err)
-	}
-
+	rand.Read(b)
 	return b
 }
 
-// GenerateRandomString returns a random string.
-func GenerateRandomString(size int) string {
-	return base64.URLEncoding.EncodeToString(GenerateRandomBytes(size))
-}
-
 // GenerateRandomStringHex returns a random hexadecimal string.
 func GenerateRandomStringHex(size int) string {
 	return hex.EncodeToString(GenerateRandomBytes(size))

internal/database/database.go

@@ -14,11 +14,9 @@ func Migrate(db *sql.DB) error {
 	var currentVersion int
 	db.QueryRow(`SELECT version FROM schema_version`).Scan(&currentVersion)
 
-	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++ {
@@ -29,12 +27,12 @@ func Migrate(db *sql.DB) error {
 			return fmt.Errorf("[Migration v%d] %v", newVersion, err)
 		}
 
-		if err := migrations[version](tx, driver); err != nil {
+		if err := migrations[version](tx); err != nil {
 			tx.Rollback()
 			return fmt.Errorf("[Migration v%d] %v", newVersion, err)
 		}
 
-		if _, err := tx.Exec(`DELETE FROM schema_version`); err != nil {
+		if _, err := tx.Exec(`TRUNCATE schema_version`); err != nil {
 			tx.Rollback()
 			return fmt.Errorf("[Migration v%d] %v", newVersion, err)
 		}

internal/database/postgresql.go

@@ -1,5 +1,3 @@
-//go:build !sqlite
-
 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
 // SPDX-License-Identifier: Apache-2.0
 
@@ -25,7 +23,3 @@ func NewConnectionPool(dsn string, minConnections, maxConnections int, connectio
 
 	return db, nil
 }
-
-func getDriverStr() string {
-	return "postgresql"
-}

internal/database/sqlite.go

@@ -1,26 +0,0 @@
-//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

@@ -143,9 +143,9 @@ func (h *handler) handleFeeds(w http.ResponseWriter, r *http.Request) {
 	}
 
 	var result feedsResponse
-	result.Feeds = make([]feed, 0)
+	result.Feeds = make([]feed, 0, len(feeds))
 	for _, f := range feeds {
-		subscripion := feed{
+		subscription := feed{
 			ID:          f.ID,
 			Title:       f.Title,
 			URL:         f.FeedURL,
@@ -155,10 +155,10 @@ func (h *handler) handleFeeds(w http.ResponseWriter, r *http.Request) {
 		}
 
 		if f.Icon != nil {
-			subscripion.FaviconID = f.Icon.IconID
+			subscription.FaviconID = f.Icon.IconID
 		}
 
-		result.Feeds = append(result.Feeds, subscripion)
+		result.Feeds = append(result.Feeds, subscription)
 	}
 
 	result.FeedsGroups = h.buildFeedGroups(feeds)
@@ -307,7 +307,7 @@ func (h *handler) handleItems(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	result.Items = make([]item, 0)
+	result.Items = make([]item, 0, len(entries))
 	for _, entry := range entries {
 		isRead := 0
 		if entry.Status == model.EntryStatusRead {
@@ -358,7 +358,7 @@ func (h *handler) handleUnreadItems(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	var itemIDs []string
+	itemIDs := make([]string, 0, len(rawEntryIDs))
 	for _, entryID := range rawEntryIDs {
 		itemIDs = append(itemIDs, strconv.FormatInt(entryID, 10))
 	}
@@ -392,7 +392,7 @@ func (h *handler) handleSavedItems(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	var itemsIDs []string
+	itemsIDs := make([]string, 0, len(entryIDs))
 	for _, entryID := range entryIDs {
 		itemsIDs = append(itemsIDs, strconv.FormatInt(entryID, 10))
 	}
@@ -455,7 +455,7 @@ func (h *handler) handleWriteItems(w http.ResponseWriter, r *http.Request) {
 			slog.Int64("user_id", userID),
 			slog.Int64("entry_id", entryID),
 		)
-		if err := h.store.ToggleBookmark(userID, entryID); err != nil {
+		if err := h.store.ToggleStarred(userID, entryID); err != nil {
 			json.ServerError(w, r, err)
 			return
 		}
@@ -474,7 +474,7 @@ func (h *handler) handleWriteItems(w http.ResponseWriter, r *http.Request) {
 			slog.Int64("user_id", userID),
 			slog.Int64("entry_id", entryID),
 		)
-		if err := h.store.ToggleBookmark(userID, entryID); err != nil {
+		if err := h.store.ToggleStarred(userID, entryID); err != nil {
 			json.ServerError(w, r, err)
 			return
 		}
@@ -568,12 +568,12 @@ A feeds_group object has the following members:
 	feed_ids (string/comma-separated list of positive integers)
 */
 func (h *handler) buildFeedGroups(feeds model.Feeds) []feedsGroups {
-	feedsGroupedByCategory := make(map[int64][]string)
+	feedsGroupedByCategory := make(map[int64][]string, len(feeds))
 	for _, feed := range feeds {
 		feedsGroupedByCategory[feed.Category.ID] = append(feedsGroupedByCategory[feed.Category.ID], strconv.FormatInt(feed.ID, 10))
 	}
 
-	result := make([]feedsGroups, 0)
+	result := make([]feedsGroups, 0, len(feedsGroupedByCategory))
 	for categoryID, feedIDs := range feedsGroupedByCategory {
 		result = append(result, feedsGroups{
 			GroupID: categoryID,

internal/googlereader/handler.go

@@ -71,12 +71,12 @@ func checkAndSimplifyTags(addTags []Stream, removeTags []Stream) (map[StreamType
 		switch s.Type {
 		case ReadStream:
 			if _, ok := tags[KeptUnreadStream]; ok {
-				return nil, fmt.Errorf("googlereader: %s and %s should not be supplied simultaneously", KeptUnread, Read)
+				return nil, fmt.Errorf("googlereader: %s and %s should not be supplied simultaneously", keptUnreadStreamSuffix, readStreamSuffix)
 			}
 			tags[ReadStream] = true
 		case KeptUnreadStream:
 			if _, ok := tags[ReadStream]; ok {
-				return nil, fmt.Errorf("googlereader: %s and %s should not be supplied simultaneously", KeptUnread, Read)
+				return nil, fmt.Errorf("googlereader: %s and %s should not be supplied simultaneously", keptUnreadStreamSuffix, readStreamSuffix)
 			}
 			tags[ReadStream] = false
 		case StarredStream:
@@ -91,17 +91,17 @@ func checkAndSimplifyTags(addTags []Stream, removeTags []Stream) (map[StreamType
 		switch s.Type {
 		case ReadStream:
 			if _, ok := tags[ReadStream]; ok {
-				return nil, fmt.Errorf("googlereader: %s and %s should not be supplied simultaneously", KeptUnread, Read)
+				return nil, fmt.Errorf("googlereader: %s and %s should not be supplied simultaneously", keptUnreadStreamSuffix, readStreamSuffix)
 			}
 			tags[ReadStream] = false
 		case KeptUnreadStream:
 			if _, ok := tags[ReadStream]; ok {
-				return nil, fmt.Errorf("googlereader: %s and %s should not be supplied simultaneously", KeptUnread, Read)
+				return nil, fmt.Errorf("googlereader: %s and %s should not be supplied simultaneously", keptUnreadStreamSuffix, readStreamSuffix)
 			}
 			tags[ReadStream] = true
 		case StarredStream:
 			if _, ok := tags[StarredStream]; ok {
-				return nil, fmt.Errorf("googlereader: %s should not be supplied for add and remove simultaneously", Starred)
+				return nil, fmt.Errorf("googlereader: %s should not be supplied for add and remove simultaneously", starredStreamSuffix)
 			}
 			tags[StarredStream] = false
 		case BroadcastStream, LikeStream:
@@ -126,8 +126,7 @@ func checkOutputFormat(r *http.Request) error {
 		output = request.QueryStringParam(r, "output", "")
 	}
 	if output != "json" {
-		err := fmt.Errorf("googlereader: only json output is supported")
-		return err
+		return errors.New("googlereader: only json output is supported")
 	}
 	return nil
 }
@@ -200,7 +199,7 @@ func (h *handler) clientLoginHandler(w http.ResponseWriter, r *http.Request) {
 		slog.String("username", username),
 	)
 
-	result := login{SID: token, LSID: token, Auth: token}
+	result := loginResponse{SID: token, LSID: token, Auth: token}
 	if output == "json" {
 		json.OK(w, r, result)
 		return
@@ -230,7 +229,7 @@ func (h *handler) tokenHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	token := request.GoolgeReaderToken(r)
+	token := request.GoogleReaderToken(r)
 	if token == "" {
 		slog.Warn("[GoogleReader] User does not have token",
 			slog.String("client_ip", clientIP),
@@ -269,18 +268,18 @@ func (h *handler) editTagHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	addTags, err := getStreams(r.PostForm[ParamTagsAdd], userID)
+	addTags, err := getStreams(r.PostForm[paramTagsAdd], userID)
 	if err != nil {
 		json.ServerError(w, r, err)
 		return
 	}
-	removeTags, err := getStreams(r.PostForm[ParamTagsRemove], userID)
+	removeTags, err := getStreams(r.PostForm[paramTagsRemove], userID)
 	if err != nil {
 		json.ServerError(w, r, err)
 		return
 	}
 	if len(addTags) == 0 && len(removeTags) == 0 {
-		err = fmt.Errorf("googlreader: add or/and remove tags should be supplied")
+		err = errors.New("googlreader: add or/and remove tags should be supplied")
 		json.ServerError(w, r, err)
 		return
 	}
@@ -357,7 +356,7 @@ func (h *handler) editTagHandler(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if len(unstarredEntryIDs) > 0 {
-		err = h.store.SetEntriesBookmarkedState(userID, unstarredEntryIDs, false)
+		err = h.store.SetEntriesStarredState(userID, unstarredEntryIDs, false)
 		if err != nil {
 			json.ServerError(w, r, err)
 			return
@@ -365,7 +364,7 @@ func (h *handler) editTagHandler(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if len(starredEntryIDs) > 0 {
-		err = h.store.SetEntriesBookmarkedState(userID, starredEntryIDs, true)
+		err = h.store.SetEntriesStarredState(userID, starredEntryIDs, true)
 		if err != nil {
 			json.ServerError(w, r, err)
 			return
@@ -387,7 +386,7 @@ func (h *handler) editTagHandler(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	OK(w, r)
+	sendOkayResponse(w)
 }
 
 func (h *handler) quickAddHandler(w http.ResponseWriter, r *http.Request) {
@@ -407,7 +406,7 @@ func (h *handler) quickAddHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	feedURL := r.Form.Get(ParamQuickAdd)
+	feedURL := r.Form.Get(paramQuickAdd)
 	if !validator.IsValidURL(feedURL) {
 		json.BadRequest(w, r, fmt.Errorf("googlereader: invalid URL: %s", feedURL))
 		return
@@ -456,7 +455,7 @@ func (h *handler) quickAddHandler(w http.ResponseWriter, r *http.Request) {
 	json.OK(w, r, quickAddResponse{
 		NumResults: 1,
 		Query:      newFeed.FeedURL,
-		StreamID:   fmt.Sprintf(FeedPrefix+"%d", newFeed.ID),
+		StreamID:   fmt.Sprintf(feedPrefix+"%d", newFeed.ID),
 		StreamName: newFeed.Title,
 	})
 }
@@ -609,20 +608,20 @@ func (h *handler) editSubscriptionHandler(w http.ResponseWriter, r *http.Request
 		return
 	}
 
-	streamIds, err := getStreams(r.Form[ParamStreamID], userID)
+	streamIds, err := getStreams(r.Form[paramStreamID], userID)
 	if err != nil || len(streamIds) == 0 {
 		json.BadRequest(w, r, errors.New("googlereader: no valid stream IDs provided"))
 		return
 	}
 
-	newLabel, err := getStream(r.Form.Get(ParamTagsAdd), userID)
+	newLabel, err := getStream(r.Form.Get(paramTagsAdd), userID)
 	if err != nil {
-		json.BadRequest(w, r, fmt.Errorf("googlereader: invalid data in %s", ParamTagsAdd))
+		json.BadRequest(w, r, fmt.Errorf("googlereader: invalid data in %s", paramTagsAdd))
 		return
 	}
 
-	title := r.Form.Get(ParamTitle)
-	action := r.Form.Get(ParamSubscribeAction)
+	title := r.Form.Get(paramTitle)
+	action := r.Form.Get(paramSubscribeAction)
 
 	switch action {
 	case "subscribe":
@@ -649,7 +648,7 @@ func (h *handler) editSubscriptionHandler(w http.ResponseWriter, r *http.Request
 			}
 		}
 
-		if r.Form.Has(ParamTagsAdd) {
+		if r.Form.Has(paramTagsAdd) {
 			if newLabel.Type != LabelStream {
 				json.BadRequest(w, r, errors.New("destination must be a label"))
 				return
@@ -669,7 +668,7 @@ func (h *handler) editSubscriptionHandler(w http.ResponseWriter, r *http.Request
 		return
 	}
 
-	OK(w, r)
+	sendOkayResponse(w)
 }
 
 func (h *handler) streamItemContentsHandler(w http.ResponseWriter, r *http.Request) {
@@ -701,9 +700,9 @@ func (h *handler) streamItemContentsHandler(w http.ResponseWriter, r *http.Reque
 		return
 	}
 
-	userReadingList := fmt.Sprintf(UserStreamPrefix, userID) + ReadingList
-	userRead := fmt.Sprintf(UserStreamPrefix, userID) + Read
-	userStarred := fmt.Sprintf(UserStreamPrefix, userID) + Starred
+	userReadingList := fmt.Sprintf(userStreamPrefix, userID) + readingListStreamSuffix
+	userRead := fmt.Sprintf(userStreamPrefix, userID) + readStreamSuffix
+	userStarred := fmt.Sprintf(userStreamPrefix, userID) + starredStreamSuffix
 
 	itemIDs, err := parseItemIDsFromRequest(r)
 	if err != nil {
@@ -731,19 +730,18 @@ func (h *handler) streamItemContentsHandler(w http.ResponseWriter, r *http.Reque
 		return
 	}
 
-	result := streamContentItems{
+	result := streamContentItemsResponse{
 		Direction: "ltr",
 		ID:        "user/-/state/com.google/reading-list",
 		Title:     "Reading List",
 		Updated:   time.Now().Unix(),
-		Self: []contentHREF{
-			{
-				HREF: config.Opts.RootURL() + route.Path(h.router, "StreamItemsContents"),
-			},
-		},
+		Self: []contentHREF{{
+			HREF: config.Opts.RootURL() + route.Path(h.router, "StreamItemsContents"),
+		}},
 		Author: userName,
+		Items:  make([]contentItem, len(entries)),
 	}
-	contentItems := make([]contentItem, len(entries))
+
 	for i, entry := range entries {
 		enclosures := make([]contentItemEnclosure, 0, len(entry.Enclosures))
 		for _, enclosure := range entry.Enclosures {
@@ -752,7 +750,7 @@ func (h *handler) streamItemContentsHandler(w http.ResponseWriter, r *http.Reque
 		categories := make([]string, 0)
 		categories = append(categories, userReadingList)
 		if entry.Feed.Category.Title != "" {
-			categories = append(categories, fmt.Sprintf(UserLabelPrefix, userID)+entry.Feed.Category.Title)
+			categories = append(categories, fmt.Sprintf(userLabelPrefix, userID)+entry.Feed.Category.Title)
 		}
 		if entry.Status == model.EntryStatusRead {
 			categories = append(categories, userRead)
@@ -763,15 +761,14 @@ func (h *handler) streamItemContentsHandler(w http.ResponseWriter, r *http.Reque
 		}
 
 		entry.Content = mediaproxy.RewriteDocumentWithAbsoluteProxyURL(h.router, entry.Content)
+		entry.Enclosures.ProxifyEnclosureURL(h.router, config.Opts.MediaProxyMode(), config.Opts.MediaProxyResourceTypes())
 
-		entry.Enclosures.ProxifyEnclosureURL(h.router)
-
-		contentItems[i] = contentItem{
+		result.Items[i] = contentItem{
 			ID:            convertEntryIDToLongFormItemID(entry.ID),
 			Title:         entry.Title,
 			Author:        entry.Author,
-			TimestampUsec: fmt.Sprintf("%d", entry.Date.UnixMicro()),
-			CrawlTimeMsec: fmt.Sprintf("%d", entry.CreatedAt.UnixMilli()),
+			TimestampUsec: strconv.FormatInt(entry.Date.UnixMicro(), 10),
+			CrawlTimeMsec: strconv.FormatInt(entry.CreatedAt.UnixMilli(), 10),
 			Published:     entry.Date.Unix(),
 			Updated:       entry.ChangedAt.Unix(),
 			Categories:    categories,
@@ -795,14 +792,14 @@ func (h *handler) streamItemContentsHandler(w http.ResponseWriter, r *http.Reque
 				Content:   entry.Content,
 			},
 			Origin: contentItemOrigin{
-				StreamID: fmt.Sprintf("feed/%d", entry.FeedID),
+				StreamID: fmt.Sprintf(feedPrefix+"%d", entry.FeedID),
 				Title:    entry.Feed.Title,
 				HTMLUrl:  entry.Feed.SiteURL,
 			},
 			Enclosure: enclosures,
 		}
 	}
-	result.Items = contentItems
+
 	json.OK(w, r, result)
 }
 
@@ -823,9 +820,9 @@ func (h *handler) disableTagHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	streams, err := getStreams(r.Form[ParamStreamID], userID)
+	streams, err := getStreams(r.Form[paramStreamID], userID)
 	if err != nil {
-		json.BadRequest(w, r, fmt.Errorf("googlereader: invalid data in %s", ParamStreamID))
+		json.BadRequest(w, r, fmt.Errorf("googlereader: invalid data in %s", paramStreamID))
 		return
 	}
 
@@ -844,7 +841,7 @@ func (h *handler) disableTagHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	OK(w, r)
+	sendOkayResponse(w)
 }
 
 func (h *handler) renameTagHandler(w http.ResponseWriter, r *http.Request) {
@@ -863,15 +860,15 @@ func (h *handler) renameTagHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	source, err := getStream(r.Form.Get(ParamStreamID), userID)
+	source, err := getStream(r.Form.Get(paramStreamID), userID)
 	if err != nil {
-		json.BadRequest(w, r, fmt.Errorf("googlereader: invalid data in %s", ParamStreamID))
+		json.BadRequest(w, r, fmt.Errorf("googlereader: invalid data in %s", paramStreamID))
 		return
 	}
 
-	destination, err := getStream(r.Form.Get(ParamDestination), userID)
+	destination, err := getStream(r.Form.Get(paramDestination), userID)
 	if err != nil {
-		json.BadRequest(w, r, fmt.Errorf("googlereader: invalid data in %s", ParamDestination))
+		json.BadRequest(w, r, fmt.Errorf("googlereader: invalid data in %s", paramDestination))
 		return
 	}
 
@@ -911,7 +908,7 @@ func (h *handler) renameTagHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	OK(w, r)
+	sendOkayResponse(w)
 }
 
 func (h *handler) tagListHandler(w http.ResponseWriter, r *http.Request) {
@@ -935,13 +932,13 @@ func (h *handler) tagListHandler(w http.ResponseWriter, r *http.Request) {
 		json.ServerError(w, r, err)
 		return
 	}
-	result.Tags = make([]subscriptionCategory, 0)
-	result.Tags = append(result.Tags, subscriptionCategory{
-		ID: fmt.Sprintf(UserStreamPrefix, userID) + Starred,
+	result.Tags = make([]subscriptionCategoryResponse, 0)
+	result.Tags = append(result.Tags, subscriptionCategoryResponse{
+		ID: fmt.Sprintf(userStreamPrefix, userID) + starredStreamSuffix,
 	})
 	for _, category := range categories {
-		result.Tags = append(result.Tags, subscriptionCategory{
-			ID:    fmt.Sprintf(UserLabelPrefix, userID) + category.Title,
+		result.Tags = append(result.Tags, subscriptionCategoryResponse{
+			ID:    fmt.Sprintf(userLabelPrefix, userID) + category.Title,
 			Label: category.Title,
 			Type:  "folder",
 		})
@@ -971,13 +968,13 @@ func (h *handler) subscriptionListHandler(w http.ResponseWriter, r *http.Request
 		return
 	}
 
-	result.Subscriptions = make([]subscription, 0)
+	result.Subscriptions = make([]subscriptionResponse, 0)
 	for _, feed := range feeds {
-		result.Subscriptions = append(result.Subscriptions, subscription{
-			ID:         fmt.Sprintf(FeedPrefix+"%d", feed.ID),
+		result.Subscriptions = append(result.Subscriptions, subscriptionResponse{
+			ID:         fmt.Sprintf(feedPrefix+"%d", feed.ID),
 			Title:      feed.Title,
 			URL:        feed.FeedURL,
-			Categories: []subscriptionCategory{{fmt.Sprintf(UserLabelPrefix, userID) + feed.Category.Title, feed.Category.Title, "folder"}},
+			Categories: []subscriptionCategoryResponse{{fmt.Sprintf(userLabelPrefix, userID) + feed.Category.Title, feed.Category.Title, "folder"}},
 			HTMLURL:    feed.SiteURL,
 			IconURL:    h.feedIconURL(feed),
 		})
@@ -1016,7 +1013,7 @@ func (h *handler) userInfoHandler(w http.ResponseWriter, r *http.Request) {
 		json.ServerError(w, r, err)
 		return
 	}
-	userInfo := userInfo{UserID: fmt.Sprint(user.ID), UserName: user.Username, UserProfileID: fmt.Sprint(user.ID), UserEmail: user.Username}
+	userInfo := userInfoResponse{UserID: strconv.FormatInt(user.ID, 10), UserName: user.Username, UserProfileID: strconv.FormatInt(user.ID, 10), UserEmail: user.Username}
 	json.OK(w, r, userInfo)
 }
 
@@ -1050,7 +1047,7 @@ func (h *handler) streamItemIDsHandler(w http.ResponseWriter, r *http.Request) {
 	)
 
 	if len(rm.Streams) != 1 {
-		json.ServerError(w, r, fmt.Errorf("googlereader: only one stream type expected"))
+		json.ServerError(w, r, errors.New("googlereader: only one stream type expected"))
 		return
 	}
 	switch rm.Streams[0].Type {
@@ -1092,7 +1089,7 @@ func (h *handler) handleReadingListStreamHandler(w http.ResponseWriter, r *http.
 				slog.String("handler", "handleReadingListStreamHandler"),
 				slog.String("client_ip", clientIP),
 				slog.String("user_agent", r.UserAgent()),
-				slog.Any("filter_type", s.Type),
+				slog.Int("filter_type", int(s.Type)),
 			)
 		}
 	}
@@ -1279,14 +1276,14 @@ func (h *handler) markAllAsReadHandler(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	stream, err := getStream(r.Form.Get(ParamStreamID), userID)
+	stream, err := getStream(r.Form.Get(paramStreamID), userID)
 	if err != nil {
 		json.BadRequest(w, r, err)
 		return
 	}
 
 	var before time.Time
-	if timestampParamValue := r.Form.Get(ParamTimestamp); timestampParamValue != "" {
+	if timestampParamValue := r.Form.Get(paramTimestamp); timestampParamValue != "" {
 		timestampParsedValue, err := strconv.ParseInt(timestampParamValue, 10, 64)
 		if err != nil {
 			json.BadRequest(w, r, err)
@@ -1340,5 +1337,5 @@ func (h *handler) markAllAsReadHandler(w http.ResponseWriter, r *http.Request) {
 		}
 	}
 
-	OK(w, r)
+	sendOkayResponse(w)
 }

internal/googlereader/item.go

@@ -4,6 +4,7 @@
 package googlereader // import "miniflux.app/v2/internal/googlereader"
 
 import (
+	"errors"
 	"fmt"
 	"net/http"
 	"strconv"
@@ -56,9 +57,9 @@ func parseItemID(itemIDValue string) (int64, error) {
 }
 
 func parseItemIDsFromRequest(r *http.Request) ([]int64, error) {
-	items := r.Form[ParamItemIDs]
+	items := r.Form[paramItemIDs]
 	if len(items) == 0 {
-		return nil, fmt.Errorf("googlereader: no items requested")
+		return nil, errors.New("googlereader: no items requested")
 	}
 
 	itemIDs := make([]int64, len(items))

internal/googlereader/middleware.go

@@ -51,7 +51,7 @@ func (m *middleware) apiKeyAuth(next http.Handler) http.Handler {
 					slog.String("user_agent", r.UserAgent()),
 					slog.Any("error", err),
 				)
-				Unauthorized(w, r)
+				sendUnauthorizedResponse(w)
 				return
 			}
 
@@ -62,7 +62,7 @@ func (m *middleware) apiKeyAuth(next http.Handler) http.Handler {
 					slog.String("client_ip", clientIP),
 					slog.String("user_agent", r.UserAgent()),
 				)
-				Unauthorized(w, r)
+				sendUnauthorizedResponse(w)
 				return
 			}
 		} else {
@@ -74,7 +74,7 @@ func (m *middleware) apiKeyAuth(next http.Handler) http.Handler {
 					slog.String("client_ip", clientIP),
 					slog.String("user_agent", r.UserAgent()),
 				)
-				Unauthorized(w, r)
+				sendUnauthorizedResponse(w)
 				return
 			}
 			fields := strings.Fields(authorization)
@@ -84,7 +84,7 @@ func (m *middleware) apiKeyAuth(next http.Handler) http.Handler {
 					slog.String("client_ip", clientIP),
 					slog.String("user_agent", r.UserAgent()),
 				)
-				Unauthorized(w, r)
+				sendUnauthorizedResponse(w)
 				return
 			}
 			if fields[0] != "GoogleLogin" {
@@ -93,7 +93,7 @@ func (m *middleware) apiKeyAuth(next http.Handler) http.Handler {
 					slog.String("client_ip", clientIP),
 					slog.String("user_agent", r.UserAgent()),
 				)
-				Unauthorized(w, r)
+				sendUnauthorizedResponse(w)
 				return
 			}
 			auths := strings.Split(fields[1], "=")
@@ -103,7 +103,7 @@ func (m *middleware) apiKeyAuth(next http.Handler) http.Handler {
 					slog.String("client_ip", clientIP),
 					slog.String("user_agent", r.UserAgent()),
 				)
-				Unauthorized(w, r)
+				sendUnauthorizedResponse(w)
 				return
 			}
 			if auths[0] != "auth" {
@@ -112,7 +112,7 @@ func (m *middleware) apiKeyAuth(next http.Handler) http.Handler {
 					slog.String("client_ip", clientIP),
 					slog.String("user_agent", r.UserAgent()),
 				)
-				Unauthorized(w, r)
+				sendUnauthorizedResponse(w)
 				return
 			}
 			token = auths[1]
@@ -126,7 +126,7 @@ func (m *middleware) apiKeyAuth(next http.Handler) http.Handler {
 				slog.String("user_agent", r.UserAgent()),
 				slog.String("token", token),
 			)
-			Unauthorized(w, r)
+			sendUnauthorizedResponse(w)
 			return
 		}
 		var integration *model.Integration
@@ -139,7 +139,7 @@ func (m *middleware) apiKeyAuth(next http.Handler) http.Handler {
 				slog.String("user_agent", r.UserAgent()),
 				slog.Any("error", err),
 			)
-			Unauthorized(w, r)
+			sendUnauthorizedResponse(w)
 			return
 		}
 		expectedToken := getAuthToken(integration.GoogleReaderUsername, integration.GoogleReaderPassword)
@@ -149,7 +149,7 @@ func (m *middleware) apiKeyAuth(next http.Handler) http.Handler {
 				slog.String("client_ip", clientIP),
 				slog.String("user_agent", r.UserAgent()),
 			)
-			Unauthorized(w, r)
+			sendUnauthorizedResponse(w)
 			return
 		}
 		if user, err = m.store.UserByID(integration.UserID); err != nil {
@@ -159,7 +159,7 @@ func (m *middleware) apiKeyAuth(next http.Handler) http.Handler {
 				slog.String("user_agent", r.UserAgent()),
 				slog.Any("error", err),
 			)
-			Unauthorized(w, r)
+			sendUnauthorizedResponse(w)
 			return
 		}
 
@@ -169,7 +169,7 @@ func (m *middleware) apiKeyAuth(next http.Handler) http.Handler {
 				slog.String("client_ip", clientIP),
 				slog.String("user_agent", r.UserAgent()),
 			)
-			Unauthorized(w, r)
+			sendUnauthorizedResponse(w)
 			return
 		}
 
@@ -181,7 +181,7 @@ func (m *middleware) apiKeyAuth(next http.Handler) http.Handler {
 		ctx = context.WithValue(ctx, request.UserTimezoneContextKey, user.Timezone)
 		ctx = context.WithValue(ctx, request.IsAdminUserContextKey, user.IsAdmin)
 		ctx = context.WithValue(ctx, request.IsAuthenticatedContextKey, true)
-		ctx = context.WithValue(ctx, request.GoogleReaderToken, token)
+		ctx = context.WithValue(ctx, request.GoogleReaderTokenKey, token)
 
 		next.ServeHTTP(w, r.WithContext(ctx))
 	})

internal/googlereader/parameters.go

@@ -4,36 +4,36 @@
 package googlereader // import "miniflux.app/v2/internal/googlereader"
 
 const (
-	// ParamItemIDs - name of the parameter with the item ids
-	ParamItemIDs = "i"
-	// ParamStreamID - name of the parameter containing the stream to be included
-	ParamStreamID = "s"
-	// ParamStreamExcludes - name of the parameter containing streams to be excluded
-	ParamStreamExcludes = "xt"
-	// ParamStreamFilters - name of the parameter containing streams to be included
-	ParamStreamFilters = "it"
-	// ParamStreamMaxItems - name of the parameter containing number of items per page/max items returned
-	ParamStreamMaxItems = "n"
-	// ParamStreamOrder - name of the parameter containing the sort criteria
-	ParamStreamOrder = "r"
-	// ParamStreamStartTime - name of the parameter containing epoch timestamp, filtering items older than
-	ParamStreamStartTime = "ot"
-	// ParamStreamStopTime - name of the parameter containing epoch timestamp, filtering items newer than
-	ParamStreamStopTime = "nt"
-	// ParamTagsRemove - name of the parameter containing tags (streams) to be removed
-	ParamTagsRemove = "r"
-	// ParamTagsAdd - name of the parameter containing tags (streams) to be added
-	ParamTagsAdd = "a"
-	// ParamSubscribeAction - name of the parameter indicating the action to take for subscription/edit
-	ParamSubscribeAction = "ac"
-	// ParamTitle - name of the parameter for the title of the subscription
-	ParamTitle = "t"
-	// ParamQuickAdd - name of the parameter for a URL being quick subscribed to
-	ParamQuickAdd = "quickadd"
-	// ParamDestination - name of the parameter for the new name of a tag
-	ParamDestination = "dest"
-	// ParamContinuation -  name of the parameter for callers to pass to receive the next page of results
-	ParamContinuation = "c"
-	// ParamStreamType - name of the parameter for unix timestamp
-	ParamTimestamp = "ts"
+	// paramItemIDs - name of the parameter with the item ids
+	paramItemIDs = "i"
+	// paramStreamID - name of the parameter containing the stream to be included
+	paramStreamID = "s"
+	// paramStreamExcludes - name of the parameter containing streams to be excluded
+	paramStreamExcludes = "xt"
+	// paramStreamFilters - name of the parameter containing streams to be included
+	paramStreamFilters = "it"
+	// paramStreamMaxItems - name of the parameter containing number of items per page/max items returned
+	paramStreamMaxItems = "n"
+	// paramStreamOrder - name of the parameter containing the sort criteria
+	paramStreamOrder = "r"
+	// paramStreamStartTime - name of the parameter containing epoch timestamp, filtering items older than
+	paramStreamStartTime = "ot"
+	// paramStreamStopTime - name of the parameter containing epoch timestamp, filtering items newer than
+	paramStreamStopTime = "nt"
+	// paramTagsRemove - name of the parameter containing tags (streams) to be removed
+	paramTagsRemove = "r"
+	// paramTagsAdd - name of the parameter containing tags (streams) to be added
+	paramTagsAdd = "a"
+	// paramSubscribeAction - name of the parameter indicating the action to take for subscription/edit
+	paramSubscribeAction = "ac"
+	// paramTitle - name of the parameter for the title of the subscription
+	paramTitle = "t"
+	// paramQuickAdd - name of the parameter for a URL being quick subscribed to
+	paramQuickAdd = "quickadd"
+	// paramDestination - name of the parameter for the new name of a tag
+	paramDestination = "dest"
+	// paramContinuation -  name of the parameter for callers to pass to receive the next page of results
+	paramContinuation = "c"
+	// paramTimestamp - name of the parameter for unix timestamp
+	paramTimestamp = "ts"
 )

internal/googlereader/prefix_suffix.go

@@ -4,28 +4,28 @@
 package googlereader // import "miniflux.app/v2/internal/googlereader"
 
 const (
-	// StreamPrefix is the prefix for astreams (read/starred/reading list and so on)
-	StreamPrefix = "user/-/state/com.google/"
-	// UserStreamPrefix is the user specific prefix for streams (read/starred/reading list and so on)
-	UserStreamPrefix = "user/%d/state/com.google/"
-	// LabelPrefix is the prefix for a label stream
-	LabelPrefix = "user/-/label/"
-	// UserLabelPrefix is the user specific prefix prefix for a label stream
-	UserLabelPrefix = "user/%d/label/"
-	// FeedPrefix is the prefix for a feed stream
-	FeedPrefix = "feed/"
-	// Read is the suffix for read stream
-	Read = "read"
-	// Starred is the suffix for starred stream
-	Starred = "starred"
-	// ReadingList is the suffix for reading list stream
-	ReadingList = "reading-list"
-	// KeptUnread is the suffix for kept unread stream
-	KeptUnread = "kept-unread"
-	// Broadcast is the suffix for broadcast stream
-	Broadcast = "broadcast"
-	// BroadcastFriends is the suffix for broadcast friends stream
-	BroadcastFriends = "broadcast-friends"
-	// Like is the suffix for like stream
-	Like = "like"
+	// streamPrefix is the prefix for streams (read/starred/reading list and so on)
+	streamPrefix = "user/-/state/com.google/"
+	// userStreamPrefix is the user specific prefix for streams (read/starred/reading list and so on)
+	userStreamPrefix = "user/%d/state/com.google/"
+	// labelPrefix is the prefix for a label stream
+	labelPrefix = "user/-/label/"
+	// userLabelPrefix is the user specific prefix prefix for a label stream
+	userLabelPrefix = "user/%d/label/"
+	// feedPrefix is the prefix for a feed stream
+	feedPrefix = "feed/"
+	// readStreamSuffix is the suffix for read stream
+	readStreamSuffix = "read"
+	// starredStreamSuffix is the suffix for starred stream
+	starredStreamSuffix = "starred"
+	// readingListStreamSuffix is the suffix for reading list stream
+	readingListStreamSuffix = "reading-list"
+	// keptUnreadStreamSuffix is the suffix for kept unread stream
+	keptUnreadStreamSuffix = "kept-unread"
+	// broadcastStreamSuffix is the suffix for broadcast stream
+	broadcastStreamSuffix = "broadcast"
+	// broadcastFriendsStreamSuffix is the suffix for broadcast friends stream
+	broadcastFriendsStreamSuffix = "broadcast-friends"
+	// likeStreamSuffix is the suffix for like stream
+	likeStreamSuffix = "like"
 )

internal/googlereader/request_modifier.go

@@ -29,19 +29,19 @@ func (r RequestModifiers) String() string {
 
 	results = append(results, fmt.Sprintf("UserID: %d", r.UserID))
 
-	var streamStr []string
+	streamStr := make([]string, 0, len(r.Streams))
 	for _, s := range r.Streams {
 		streamStr = append(streamStr, s.String())
 	}
 	results = append(results, fmt.Sprintf("Streams: [%s]", strings.Join(streamStr, ", ")))
 
-	var exclusions []string
+	exclusions := make([]string, 0, len(r.ExcludeTargets))
 	for _, s := range r.ExcludeTargets {
 		exclusions = append(exclusions, s.String())
 	}
 	results = append(results, fmt.Sprintf("Exclusions: [%s]", strings.Join(exclusions, ", ")))
 
-	var filters []string
+	filters := make([]string, 0, len(r.FilterTargets))
 	for _, s := range r.FilterTargets {
 		filters = append(filters, s.String())
 	}
@@ -49,8 +49,8 @@ func (r RequestModifiers) String() string {
 
 	results = append(results, fmt.Sprintf("Count: %d", r.Count))
 	results = append(results, fmt.Sprintf("Offset: %d", r.Offset))
-	results = append(results, fmt.Sprintf("Sort Direction: %s", r.SortDirection))
-	results = append(results, fmt.Sprintf("Continuation Token: %s", r.ContinuationToken))
+	results = append(results, "Sort Direction: "+r.SortDirection)
+	results = append(results, "Continuation Token: "+r.ContinuationToken)
 	results = append(results, fmt.Sprintf("Start Time: %d", r.StartTime))
 	results = append(results, fmt.Sprintf("Stop Time: %d", r.StopTime))
 
@@ -64,28 +64,28 @@ func parseStreamFilterFromRequest(r *http.Request) (RequestModifiers, error) {
 		UserID:        userID,
 	}
 
-	streamOrder := request.QueryStringParam(r, ParamStreamOrder, "d")
+	streamOrder := request.QueryStringParam(r, paramStreamOrder, "d")
 	if streamOrder == "o" {
 		result.SortDirection = "asc"
 	}
 	var err error
-	result.Streams, err = getStreams(request.QueryStringParamList(r, ParamStreamID), userID)
+	result.Streams, err = getStreams(request.QueryStringParamList(r, paramStreamID), userID)
 	if err != nil {
 		return RequestModifiers{}, err
 	}
-	result.ExcludeTargets, err = getStreams(request.QueryStringParamList(r, ParamStreamExcludes), userID)
+	result.ExcludeTargets, err = getStreams(request.QueryStringParamList(r, paramStreamExcludes), userID)
 	if err != nil {
 		return RequestModifiers{}, err
 	}
 
-	result.FilterTargets, err = getStreams(request.QueryStringParamList(r, ParamStreamFilters), userID)
+	result.FilterTargets, err = getStreams(request.QueryStringParamList(r, paramStreamFilters), userID)
 	if err != nil {
 		return RequestModifiers{}, err
 	}
 
-	result.Count = request.QueryIntParam(r, ParamStreamMaxItems, 0)
-	result.Offset = request.QueryIntParam(r, ParamContinuation, 0)
-	result.StartTime = request.QueryInt64Param(r, ParamStreamStartTime, int64(0))
-	result.StopTime = request.QueryInt64Param(r, ParamStreamStopTime, int64(0))
+	result.Count = request.QueryIntParam(r, paramStreamMaxItems, 0)
+	result.Offset = request.QueryIntParam(r, paramContinuation, 0)
+	result.StartTime = request.QueryInt64Param(r, paramStreamStartTime, int64(0))
+	result.StopTime = request.QueryInt64Param(r, paramStreamStopTime, int64(0))
 	return result, nil
 }

internal/googlereader/response.go

@@ -6,34 +6,36 @@ package googlereader // import "miniflux.app/v2/internal/googlereader"
 import (
 	"fmt"
 	"net/http"
-
-	"miniflux.app/v2/internal/http/response"
 )
 
-type login struct {
+type loginResponse struct {
 	SID  string `json:"SID,omitempty"`
 	LSID string `json:"LSID,omitempty"`
 	Auth string `json:"Auth,omitempty"`
 }
 
-func (l login) String() string {
+func (l loginResponse) String() string {
 	return fmt.Sprintf("SID=%s\nLSID=%s\nAuth=%s\n", l.SID, l.LSID, l.Auth)
 }
 
-type userInfo struct {
+type userInfoResponse struct {
 	UserID        string `json:"userId"`
 	UserName      string `json:"userName"`
 	UserProfileID string `json:"userProfileId"`
 	UserEmail     string `json:"userEmail"`
 }
 
-type subscription struct {
-	ID         string                 `json:"id"`
-	Title      string                 `json:"title"`
-	Categories []subscriptionCategory `json:"categories"`
-	URL        string                 `json:"url"`
-	HTMLURL    string                 `json:"htmlUrl"`
-	IconURL    string                 `json:"iconUrl"`
+type subscriptionResponse struct {
+	ID         string                         `json:"id"`
+	Title      string                         `json:"title"`
+	Categories []subscriptionCategoryResponse `json:"categories"`
+	URL        string                         `json:"url"`
+	HTMLURL    string                         `json:"htmlUrl"`
+	IconURL    string                         `json:"iconUrl"`
+}
+
+type subscriptionsResponse struct {
+	Subscriptions []subscriptionResponse `json:"subscriptions"`
 }
 
 type quickAddResponse struct {
@@ -43,14 +45,11 @@ type quickAddResponse struct {
 	StreamName string `json:"streamName,omitempty"`
 }
 
-type subscriptionCategory struct {
+type subscriptionCategoryResponse struct {
 	ID    string `json:"id"`
 	Label string `json:"label,omitempty"`
 	Type  string `json:"type,omitempty"`
 }
-type subscriptionsResponse struct {
-	Subscriptions []subscription `json:"subscriptions"`
-}
 
 type itemRef struct {
 	ID              string `json:"id"`
@@ -64,10 +63,10 @@ type streamIDResponse struct {
 }
 
 type tagsResponse struct {
-	Tags []subscriptionCategory `json:"tags"`
+	Tags []subscriptionCategoryResponse `json:"tags"`
 }
 
-type streamContentItems struct {
+type streamContentItemsResponse struct {
 	Direction string        `json:"direction"`
 	ID        string        `json:"id"`
 	Title     string        `json:"title"`
@@ -118,21 +117,15 @@ type contentItemOrigin struct {
 	HTMLUrl  string `json:"htmlUrl"`
 }
 
-// Unauthorized sends a not authorized error to the client.
-func Unauthorized(w http.ResponseWriter, r *http.Request) {
-	builder := response.New(w, r)
-	builder.WithStatus(http.StatusUnauthorized)
-	builder.WithHeader("Content-Type", "text/plain")
-	builder.WithHeader("X-Reader-Google-Bad-Token", "true")
-	builder.WithBody("Unauthorized")
-	builder.Write()
+func sendUnauthorizedResponse(w http.ResponseWriter) {
+	w.Header().Set("Content-Type", "text/plain")
+	w.Header().Set("X-Reader-Google-Bad-Token", "true")
+	w.WriteHeader(http.StatusUnauthorized)
+	w.Write([]byte("Unauthorized"))
 }
 
-// OK sends a ok response to the client.
-func OK(w http.ResponseWriter, r *http.Request) {
-	builder := response.New(w, r)
-	builder.WithStatus(http.StatusOK)
-	builder.WithHeader("Content-Type", "text/plain")
-	builder.WithBody("OK")
-	builder.Write()
+func sendOkayResponse(w http.ResponseWriter) {
+	w.Header().Set("Content-Type", "text/plain")
+	w.WriteHeader(http.StatusOK)
+	w.Write([]byte("OK"))
 }

internal/googlereader/stream.go

@@ -72,32 +72,32 @@ func (st StreamType) String() string {
 
 func getStream(streamID string, userID int64) (Stream, error) {
 	switch {
-	case strings.HasPrefix(streamID, FeedPrefix):
-		return Stream{Type: FeedStream, ID: strings.TrimPrefix(streamID, FeedPrefix)}, nil
-	case strings.HasPrefix(streamID, fmt.Sprintf(UserStreamPrefix, userID)) || strings.HasPrefix(streamID, StreamPrefix):
-		id := strings.TrimPrefix(streamID, fmt.Sprintf(UserStreamPrefix, userID))
-		id = strings.TrimPrefix(id, StreamPrefix)
+	case strings.HasPrefix(streamID, feedPrefix):
+		return Stream{Type: FeedStream, ID: strings.TrimPrefix(streamID, feedPrefix)}, nil
+	case strings.HasPrefix(streamID, fmt.Sprintf(userStreamPrefix, userID)), strings.HasPrefix(streamID, streamPrefix):
+		id := strings.TrimPrefix(streamID, fmt.Sprintf(userStreamPrefix, userID))
+		id = strings.TrimPrefix(id, streamPrefix)
 		switch id {
-		case Read:
+		case readStreamSuffix:
 			return Stream{ReadStream, ""}, nil
-		case Starred:
+		case starredStreamSuffix:
 			return Stream{StarredStream, ""}, nil
-		case ReadingList:
+		case readingListStreamSuffix:
 			return Stream{ReadingListStream, ""}, nil
-		case KeptUnread:
+		case keptUnreadStreamSuffix:
 			return Stream{KeptUnreadStream, ""}, nil
-		case Broadcast:
+		case broadcastStreamSuffix:
 			return Stream{BroadcastStream, ""}, nil
-		case BroadcastFriends:
+		case broadcastFriendsStreamSuffix:
 			return Stream{BroadcastFriendsStream, ""}, nil
-		case Like:
+		case likeStreamSuffix:
 			return Stream{LikeStream, ""}, nil
 		default:
 			return Stream{NoStream, ""}, fmt.Errorf("googlereader: unknown stream with id: %s", id)
 		}
-	case strings.HasPrefix(streamID, fmt.Sprintf(UserLabelPrefix, userID)) || strings.HasPrefix(streamID, LabelPrefix):
-		id := strings.TrimPrefix(streamID, fmt.Sprintf(UserLabelPrefix, userID))
-		id = strings.TrimPrefix(id, LabelPrefix)
+	case strings.HasPrefix(streamID, fmt.Sprintf(userLabelPrefix, userID)), strings.HasPrefix(streamID, labelPrefix):
+		id := strings.TrimPrefix(streamID, fmt.Sprintf(userLabelPrefix, userID))
+		id = strings.TrimPrefix(id, labelPrefix)
 		return Stream{LabelStream, id}, nil
 	case streamID == "":
 		return Stream{NoStream, ""}, nil
@@ -107,7 +107,7 @@ func getStream(streamID string, userID int64) (Stream, error) {
 }
 
 func getStreams(streamIDs []string, userID int64) ([]Stream, error) {
-	streams := make([]Stream, 0)
+	streams := make([]Stream, 0, len(streamIDs))
 	for _, streamID := range streamIDs {
 		stream, err := getStream(streamID, userID)
 		if err != nil {

internal/http/cookie/cookie.go

@@ -24,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(time.Duration(config.Opts.CleanupRemoveSessionsDays()) * 24 * time.Hour),
+		Expires:  time.Now().Add(config.Opts.CleanupRemoveSessionsInterval()),
 		SameSite: http.SameSiteLaxMode,
 	}
 }

internal/http/request/client_ip.go

@@ -11,7 +11,7 @@ import (
 
 // FindClientIP returns the client real IP address based on trusted Reverse-Proxy HTTP headers.
 func FindClientIP(r *http.Request) string {
-	headers := []string{"X-Forwarded-For", "X-Real-Ip"}
+	headers := [...]string{"X-Forwarded-For", "X-Real-Ip"}
 	for _, header := range headers {
 		value := r.Header.Get(header)
 

internal/http/request/context.go

@@ -6,6 +6,7 @@ package request // import "miniflux.app/v2/internal/http/request"
 import (
 	"net/http"
 	"strconv"
+	"time"
 
 	"miniflux.app/v2/internal/model"
 )
@@ -29,10 +30,9 @@ const (
 	OAuth2CodeVerifierContextKey
 	FlashMessageContextKey
 	FlashErrorMessageContextKey
-	PocketRequestTokenContextKey
 	LastForceRefreshContextKey
 	ClientIPContextKey
-	GoogleReaderToken
+	GoogleReaderTokenKey
 	WebAuthnDataContextKey
 )
 
@@ -45,9 +45,9 @@ func WebAuthnSessionData(r *http.Request) *model.WebAuthnSession {
 	return nil
 }
 
-// GoolgeReaderToken returns the google reader token if it exists.
-func GoolgeReaderToken(r *http.Request) string {
-	return getContextStringValue(r, GoogleReaderToken)
+// GoogleReaderToken returns the google reader token if it exists.
+func GoogleReaderToken(r *http.Request) string {
+	return getContextStringValue(r, GoogleReaderTokenKey)
 }
 
 // IsAdminUser checks if the logged user is administrator.
@@ -135,19 +135,14 @@ func FlashErrorMessage(r *http.Request) string {
 	return getContextStringValue(r, FlashErrorMessageContextKey)
 }
 
-// PocketRequestToken returns the Pocket Request Token if any.
-func PocketRequestToken(r *http.Request) string {
-	return getContextStringValue(r, PocketRequestTokenContextKey)
-}
-
 // LastForceRefresh returns the last force refresh timestamp.
-func LastForceRefresh(r *http.Request) int64 {
+func LastForceRefresh(r *http.Request) time.Time {
 	jsonStringValue := getContextStringValue(r, LastForceRefreshContextKey)
 	timestamp, err := strconv.ParseInt(jsonStringValue, 10, 64)
 	if err != nil {
-		return 0
+		return time.Time{}
 	}
-	return timestamp
+	return time.Unix(timestamp, 0)
 }
 
 // ClientIP returns the client IP address stored in the context.

internal/http/request/context_test.go

@@ -390,28 +390,6 @@ func TestFlashErrorMessage(t *testing.T) {
 	}
 }
 
-func TestPocketRequestToken(t *testing.T) {
-	r, _ := http.NewRequest("GET", "http://example.org", nil)
-
-	result := PocketRequestToken(r)
-	expected := ""
-
-	if result != expected {
-		t.Errorf(`Unexpected context value, got %q instead of %q`, result, expected)
-	}
-
-	ctx := r.Context()
-	ctx = context.WithValue(ctx, PocketRequestTokenContextKey, "request token")
-	r = r.WithContext(ctx)
-
-	result = PocketRequestToken(r)
-	expected = "request token"
-
-	if result != expected {
-		t.Errorf(`Unexpected context value, got %q instead of %q`, result, expected)
-	}
-}
-
 func TestClientIP(t *testing.T) {
 	r, _ := http.NewRequest("GET", "http://example.org", nil)
 

internal/http/response/builder.go

@@ -6,7 +6,6 @@ package response // import "miniflux.app/v2/internal/http/response"
 import (
 	"compress/flate"
 	"compress/gzip"
-	"fmt"
 	"io"
 	"log/slog"
 	"net/http"
@@ -48,7 +47,7 @@ func (b *Builder) WithBody(body any) *Builder {
 
 // WithAttachment forces the document to be downloaded by the web browser.
 func (b *Builder) WithAttachment(filename string) *Builder {
-	b.headers["Content-Disposition"] = fmt.Sprintf("attachment; filename=%s", filename)
+	b.headers["Content-Disposition"] = "attachment; filename=" + filename
 	return b
 }
 
@@ -85,8 +84,6 @@ func (b *Builder) Write() {
 		b.compress(v)
 	case string:
 		b.compress([]byte(v))
-	case error:
-		b.compress([]byte(v.Error()))
 	case io.Reader:
 		// Compression not implemented in this case
 		b.writeHeaders()
@@ -118,24 +115,24 @@ func (b *Builder) compress(data []byte) {
 			b.writeHeaders()
 
 			brotliWriter := brotli.NewWriterV2(b.w, brotli.DefaultCompression)
-			defer brotliWriter.Close()
 			brotliWriter.Write(data)
+			brotliWriter.Close()
 			return
 		case strings.Contains(acceptEncoding, "gzip"):
 			b.headers["Content-Encoding"] = "gzip"
 			b.writeHeaders()
 
 			gzipWriter := gzip.NewWriter(b.w)
-			defer gzipWriter.Close()
 			gzipWriter.Write(data)
+			gzipWriter.Close()
 			return
 		case strings.Contains(acceptEncoding, "deflate"):
 			b.headers["Content-Encoding"] = "deflate"
 			b.writeHeaders()
 
 			flateWriter, _ := flate.NewWriter(b.w, -1)
-			defer flateWriter.Close()
 			flateWriter.Write(data)
+			flateWriter.Close()
 			return
 		}
 	}

internal/http/response/builder_test.go

@@ -4,7 +4,6 @@
 package response // import "miniflux.app/v2/internal/http/response"
 
 import (
-	"errors"
 	"net/http"
 	"net/http/httptest"
 	"strings"
@@ -105,27 +104,6 @@ func TestBuildResponseWithAttachment(t *testing.T) {
 	}
 }
 
-func TestBuildResponseWithError(t *testing.T) {
-	r, err := http.NewRequest("GET", "/", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	w := httptest.NewRecorder()
-
-	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		New(w, r).WithBody(errors.New("Some error")).Write()
-	})
-
-	handler.ServeHTTP(w, r)
-
-	expectedBody := `Some error`
-	actualBody := w.Body.String()
-	if actualBody != expectedBody {
-		t.Fatalf(`Unexpected body, got %s instead of %s`, actualBody, expectedBody)
-	}
-}
-
 func TestBuildResponseWithByteBody(t *testing.T) {
 	r, err := http.NewRequest("GET", "/", nil)
 	if err != nil {

internal/http/response/html/html.go

@@ -13,7 +13,7 @@ import (
 )
 
 // OK creates a new HTML response with a 200 status code.
-func OK(w http.ResponseWriter, r *http.Request, body interface{}) {
+func OK[T []byte | string](w http.ResponseWriter, r *http.Request, body T) {
 	builder := response.New(w, r)
 	builder.WithHeader("Content-Type", "text/html; charset=utf-8")
 	builder.WithHeader("Cache-Control", "no-cache, max-age=0, must-revalidate, no-store")

internal/http/response/xml/xml.go

@@ -10,7 +10,7 @@ import (
 )
 
 // OK writes a standard XML response with a status 200 OK.
-func OK(w http.ResponseWriter, r *http.Request, body interface{}) {
+func OK[T []byte | string](w http.ResponseWriter, r *http.Request, body T) {
 	builder := response.New(w, r)
 	builder.WithHeader("Content-Type", "text/xml; charset=utf-8")
 	builder.WithBody(body)
@@ -18,7 +18,7 @@ func OK(w http.ResponseWriter, r *http.Request, body interface{}) {
 }
 
 // Attachment forces the XML document to be downloaded by the web browser.
-func Attachment(w http.ResponseWriter, r *http.Request, filename string, body interface{}) {
+func Attachment[T []byte | string](w http.ResponseWriter, r *http.Request, filename string, body T) {
 	builder := response.New(w, r)
 	builder.WithHeader("Content-Type", "text/xml; charset=utf-8")
 	builder.WithAttachment(filename)

internal/http/server/httpd.go

@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-package httpd // import "miniflux.app/v2/internal/http/server"
+package server // import "miniflux.app/v2/internal/http/server"
 
 import (
 	"crypto/tls"
@@ -12,7 +12,6 @@ import (
 	"os"
 	"strconv"
 	"strings"
-	"time"
 
 	"miniflux.app/v2/internal/api"
 	"miniflux.app/v2/internal/config"
@@ -30,36 +29,84 @@ import (
 	"golang.org/x/crypto/acme/autocert"
 )
 
-func StartWebServer(store *storage.Storage, pool *worker.Pool) *http.Server {
+func StartWebServer(store *storage.Storage, pool *worker.Pool) []*http.Server {
+	listenAddresses := config.Opts.ListenAddr()
+	var httpServers []*http.Server
+
 	certFile := config.Opts.CertFile()
 	keyFile := config.Opts.CertKeyFile()
 	certDomain := config.Opts.CertDomain()
-	listenAddr := config.Opts.ListenAddr()
-	server := &http.Server{
-		ReadTimeout:  time.Duration(config.Opts.HTTPServerTimeout()) * time.Second,
-		WriteTimeout: time.Duration(config.Opts.HTTPServerTimeout()) * time.Second,
-		IdleTimeout:  time.Duration(config.Opts.HTTPServerTimeout()) * time.Second,
-		Handler:      setupHandler(store, pool),
+	var sharedAutocertTLSConfig *tls.Config
+
+	if certDomain != "" {
+		slog.Debug("Configuring autocert manager and shared TLS config", slog.String("domain", certDomain))
+		certManager := autocert.Manager{
+			Cache:      storage.NewCertificateCache(store),
+			Prompt:     autocert.AcceptTOS,
+			HostPolicy: autocert.HostWhitelist(certDomain),
+		}
+
+		sharedAutocertTLSConfig = &tls.Config{}
+		sharedAutocertTLSConfig.GetCertificate = certManager.GetCertificate
+		sharedAutocertTLSConfig.NextProtos = []string{"h2", "http/1.1", acme.ALPNProto}
+
+		challengeServer := &http.Server{
+			Handler: certManager.HTTPHandler(nil),
+			Addr:    ":http",
+		}
+		slog.Info("Starting ACME HTTP challenge server for autocert", slog.String("address", challengeServer.Addr))
+		go func() {
+			if err := challengeServer.ListenAndServe(); err != http.ErrServerClosed {
+				slog.Error("ACME HTTP challenge server failed", slog.Any("error", err))
+			}
+		}()
+		config.Opts.SetHTTPSValue(true)
+		httpServers = append(httpServers, challengeServer)
 	}
 
-	switch {
-	case os.Getenv("LISTEN_PID") == strconv.Itoa(os.Getpid()):
-		startSystemdSocketServer(server)
-	case strings.HasPrefix(listenAddr, "/"):
-		startUnixSocketServer(server, listenAddr)
-	case certDomain != "":
-		config.Opts.HTTPS = true
-		startAutoCertTLSServer(server, certDomain, store)
-	case certFile != "" && keyFile != "":
-		config.Opts.HTTPS = true
-		server.Addr = listenAddr
-		startTLSServer(server, certFile, keyFile)
-	default:
-		server.Addr = listenAddr
-		startHTTPServer(server)
+	for i, listenAddr := range listenAddresses {
+		server := &http.Server{
+			ReadTimeout:  config.Opts.HTTPServerTimeout(),
+			WriteTimeout: config.Opts.HTTPServerTimeout(),
+			IdleTimeout:  config.Opts.HTTPServerTimeout(),
+			Handler:      setupHandler(store, pool),
+		}
+
+		if !strings.HasPrefix(listenAddr, "/") && os.Getenv("LISTEN_PID") != strconv.Itoa(os.Getpid()) {
+			server.Addr = listenAddr
+		}
+
+		shouldAddServer := true
+
+		switch {
+		case os.Getenv("LISTEN_PID") == strconv.Itoa(os.Getpid()):
+			if i == 0 {
+				slog.Info("Starting server using systemd socket for the first listen address", slog.String("address_info", listenAddr))
+				startSystemdSocketServer(server)
+			} else {
+				slog.Warn("Systemd socket activation: Only the first listen address is used by systemd. Other addresses ignored.", slog.String("skipped_address", listenAddr))
+				shouldAddServer = false
+			}
+		case strings.HasPrefix(listenAddr, "/"): // Unix socket
+			startUnixSocketServer(server, listenAddr)
+		case certDomain != "" && (listenAddr == ":https" || (i == 0 && strings.Contains(listenAddr, ":"))):
+			server.Addr = listenAddr
+			startAutoCertTLSServer(server, sharedAutocertTLSConfig)
+		case certFile != "" && keyFile != "":
+			server.Addr = listenAddr
+			startTLSServer(server, certFile, keyFile)
+			config.Opts.SetHTTPSValue(true)
+		default:
+			server.Addr = listenAddr
+			startHTTPServer(server)
+		}
+
+		if shouldAddServer {
+			httpServers = append(httpServers, server)
+		}
 	}
 
-	return server
+	return httpServers
 }
 
 func startSystemdSocketServer(server *http.Server) {
@@ -72,83 +119,66 @@ func startSystemdSocketServer(server *http.Server) {
 
 		slog.Info(`Starting server using systemd socket`)
 		if err := server.Serve(listener); err != http.ErrServerClosed {
-			printErrorAndExit(`Server failed to start: %v`, err)
+			printErrorAndExit(`Systemd socket server failed to start: %v`, err)
 		}
 	}()
 }
 
 func startUnixSocketServer(server *http.Server, socketFile string) {
-	os.Remove(socketFile)
+	if err := os.Remove(socketFile); err != nil && !os.IsNotExist(err) {
+		printErrorAndExit("Unable to remove existing Unix socket %s: %v", socketFile, err)
+	}
+	listener, err := net.Listen("unix", socketFile)
+	if err != nil {
+		printErrorAndExit(`Server failed to listen on Unix socket %s: %v`, socketFile, err)
+	}
 
-	go func(sock string) {
-		listener, err := net.Listen("unix", sock)
-		if err != nil {
-			printErrorAndExit(`Server failed to start: %v`, err)
-		}
-		defer listener.Close()
+	if err := os.Chmod(socketFile, 0666); err != nil {
+		printErrorAndExit(`Unable to change socket permission for %s: %v`, socketFile, err)
+	}
 
-		if err := os.Chmod(sock, 0666); err != nil {
-			printErrorAndExit(`Unable to change socket permission: %v`, err)
-		}
+	go func() {
+		certFile := config.Opts.CertFile()
+		keyFile := config.Opts.CertKeyFile()
 
-		slog.Info("Starting server using a Unix socket", slog.String("socket", sock))
-		if err := server.Serve(listener); err != http.ErrServerClosed {
-			printErrorAndExit(`Server failed to start: %v`, err)
+		if certFile != "" && keyFile != "" {
+			slog.Info("Starting TLS server using a Unix socket",
+				slog.String("socket", socketFile),
+				slog.String("cert_file", certFile),
+				slog.String("key_file", keyFile),
+			)
+			// Ensure HTTPS is marked as true if any listener uses TLS
+			config.Opts.SetHTTPSValue(true)
+			if err := server.ServeTLS(listener, certFile, keyFile); err != http.ErrServerClosed {
+				printErrorAndExit("TLS Unix socket server failed to start on %s: %v", socketFile, err)
+			}
+		} else {
+			slog.Info("Starting server using a Unix socket", slog.String("socket", socketFile))
+			if err := server.Serve(listener); err != http.ErrServerClosed {
+				printErrorAndExit("Unix socket server failed to start on %s: %v", socketFile, err)
+			}
 		}
-	}(socketFile)
+	}()
 }
 
-func tlsConfig() *tls.Config {
-	// See https://blog.cloudflare.com/exposing-go-on-the-internet/
-	// And https://wiki.mozilla.org/Security/Server_Side_TLS
-	return &tls.Config{
-		MinVersion: tls.VersionTLS12,
-		CurvePreferences: []tls.CurveID{
-			tls.CurveP256,
-			tls.X25519,
-		},
-		CipherSuites: []uint16{
-			tls.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
-			tls.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384,
-			tls.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305,
-			tls.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305,
-			tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
-			tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
-		},
+func startAutoCertTLSServer(server *http.Server, autoTLSConfig *tls.Config) {
+	if server.TLSConfig == nil {
+		server.TLSConfig = &tls.Config{}
 	}
-}
-
-func startAutoCertTLSServer(server *http.Server, certDomain string, store *storage.Storage) {
-	server.Addr = ":https"
-	certManager := autocert.Manager{
-		Cache:      storage.NewCertificateCache(store),
-		Prompt:     autocert.AcceptTOS,
-		HostPolicy: autocert.HostWhitelist(certDomain),
-	}
-	server.TLSConfig = tlsConfig()
-	server.TLSConfig.GetCertificate = certManager.GetCertificate
-	server.TLSConfig.NextProtos = []string{"h2", "http/1.1", acme.ALPNProto}
-
-	// Handle http-01 challenge.
-	s := &http.Server{
-		Handler: certManager.HTTPHandler(nil),
-		Addr:    ":http",
-	}
-	go s.ListenAndServe()
+	server.TLSConfig.GetCertificate = autoTLSConfig.GetCertificate
+	server.TLSConfig.NextProtos = autoTLSConfig.NextProtos
 
 	go func() {
 		slog.Info("Starting TLS server using automatic certificate management",
 			slog.String("listen_address", server.Addr),
-			slog.String("domain", certDomain),
 		)
 		if err := server.ListenAndServeTLS("", ""); err != http.ErrServerClosed {
-			printErrorAndExit(`Server failed to start: %v`, err)
+			printErrorAndExit("Autocert server failed to start on %s: %v", server.Addr, err)
 		}
 	}()
 }
 
 func startTLSServer(server *http.Server, certFile, keyFile string) {
-	server.TLSConfig = tlsConfig()
 	go func() {
 		slog.Info("Starting TLS server using a certificate",
 			slog.String("listen_address", server.Addr),
@@ -156,7 +186,7 @@ func startTLSServer(server *http.Server, certFile, keyFile string) {
 			slog.String("key_file", keyFile),
 		)
 		if err := server.ListenAndServeTLS(certFile, keyFile); err != http.ErrServerClosed {
-			printErrorAndExit(`Server failed to start: %v`, err)
+			printErrorAndExit("TLS server failed to start on %s: %v", server.Addr, err)
 		}
 	}()
 }
@@ -167,7 +197,7 @@ func startHTTPServer(server *http.Server) {
 			slog.String("listen_address", server.Addr),
 		)
 		if err := server.ListenAndServe(); err != http.ErrServerClosed {
-			printErrorAndExit(`Server failed to start: %v`, err)
+			printErrorAndExit("HTTP server failed to start on %s: %v", server.Addr, err)
 		}
 	}()
 }

internal/http/server/middleware.go

@@ -1,7 +1,7 @@
 // SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-package httpd // import "miniflux.app/v2/internal/http/server"
+package server // import "miniflux.app/v2/internal/http/server"
 
 import (
 	"context"
@@ -20,7 +20,7 @@ func middleware(next http.Handler) http.Handler {
 		ctx = context.WithValue(ctx, request.ClientIPContextKey, clientIP)
 
 		if r.Header.Get("X-Forwarded-Proto") == "https" {
-			config.Opts.HTTPS = true
+			config.Opts.SetHTTPSValue(true)
 		}
 
 		t1 := time.Now()
@@ -36,7 +36,7 @@ func middleware(next http.Handler) http.Handler {
 			)
 		}()
 
-		if config.Opts.HTTPS && config.Opts.HasHSTS() {
+		if config.Opts.HTTPS() && config.Opts.HasHSTS() {
 			w.Header().Set("Strict-Transport-Security", "max-age=31536000")
 		}
 

internal/integration/apprise/apprise.go

@@ -6,6 +6,7 @@ package apprise
 import (
 	"bytes"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"log/slog"
 	"net/http"
@@ -29,7 +30,7 @@ func NewClient(serviceURL, baseURL string) *Client {
 
 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")
+		return errors.New("apprise: missing base URL or services URL")
 	}
 
 	for _, entry := range entries {

internal/integration/archiveorg/archiveorg.go

@@ -0,0 +1,43 @@
+// SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package archiveorg
+
+import (
+	"log/slog"
+	"net/http"
+	"net/url"
+)
+
+// See https://docs.google.com/document/d/1Nsv52MvSjbLb2PCpHlat0gkzw0EvtSgpKHu4mk0MnrA/edit?tab=t.0
+const options = "delay_wb_availability=1&if_not_archived_within=15d"
+
+type Client struct{}
+
+func NewClient() *Client {
+	return &Client{}
+}
+
+func (c *Client) SendURL(entryURL, title string) {
+	// We're using a goroutine here as submissions to archive.org might take a long time
+	// and trigger a timeout on miniflux' side.
+	go func(entryURL string) {
+		res, err := http.Get("https://web.archive.org/save/" + url.QueryEscape(entryURL) + "?" + options)
+		if err != nil {
+			slog.Error("archiveorg: unable to send request: %v",
+				slog.Any("err", err),
+				slog.String("title", title),
+				slog.String("url", entryURL),
+			)
+			return
+		}
+		if res.StatusCode > 299 {
+			slog.Error("archiveorg: failed with status code",
+				slog.String("title", title),
+				slog.String("url", entryURL),
+				slog.Int("code", res.StatusCode),
+			)
+		}
+		res.Body.Close()
+	}(entryURL)
+}

internal/integration/betula/betula.go

@@ -1,4 +1,7 @@
-package betula
+// SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package betula // import "miniflux.app/v2/internal/integration/betula"
 
 import (
 	"fmt"

internal/integration/espial/espial.go

@@ -6,6 +6,7 @@ package espial // import "miniflux.app/v2/internal/integration/espial"
 import (
 	"bytes"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net/http"
 	"time"
@@ -27,7 +28,7 @@ func NewClient(baseURL, apiKey string) *Client {
 
 func (c *Client) CreateLink(entryURL, entryTitle, espialTags string) error {
 	if c.baseURL == "" || c.apiKey == "" {
-		return fmt.Errorf("espial: missing base URL or API key")
+		return errors.New("espial: missing base URL or API key")
 	}
 
 	apiEndpoint, err := urllib.JoinBaseURLAndPath(c.baseURL, "/api/add")

internal/integration/instapaper/instapaper.go

@@ -4,6 +4,7 @@
 package instapaper // import "miniflux.app/v2/internal/integration/instapaper"
 
 import (
+	"errors"
 	"fmt"
 	"net/http"
 	"net/url"
@@ -25,7 +26,7 @@ func NewClient(username, password string) *Client {
 
 func (c *Client) AddURL(entryURL, entryTitle string) error {
 	if c.username == "" || c.password == "" {
-		return fmt.Errorf("instapaper: missing username or password")
+		return errors.New("instapaper: missing username or password")
 	}
 
 	values := url.Values{}

internal/integration/integration.go

@@ -6,15 +6,17 @@ package integration // import "miniflux.app/v2/internal/integration"
 import (
 	"log/slog"
 
-	"miniflux.app/v2/internal/config"
 	"miniflux.app/v2/internal/integration/apprise"
+	"miniflux.app/v2/internal/integration/archiveorg"
 	"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/karakeep"
 	"miniflux.app/v2/internal/integration/linkace"
 	"miniflux.app/v2/internal/integration/linkding"
+	"miniflux.app/v2/internal/integration/linktaco"
 	"miniflux.app/v2/internal/integration/linkwarden"
 	"miniflux.app/v2/internal/integration/matrixbot"
 	"miniflux.app/v2/internal/integration/notion"
@@ -22,7 +24,6 @@ import (
 	"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"
@@ -108,6 +109,7 @@ func SendEntry(entry *model.Entry, userIntegrations *model.Integration) {
 	if userIntegrations.WallabagEnabled {
 		slog.Debug("Sending entry to Wallabag",
 			slog.Int64("user_id", userIntegrations.UserID),
+			slog.String("user_tags", userIntegrations.WallabagTags),
 			slog.Int64("entry_id", entry.ID),
 			slog.String("entry_url", entry.URL),
 		)
@@ -118,12 +120,14 @@ func SendEntry(entry *model.Entry, userIntegrations *model.Integration) {
 			userIntegrations.WallabagClientSecret,
 			userIntegrations.WallabagUsername,
 			userIntegrations.WallabagPassword,
+			userIntegrations.WallabagTags,
 			userIntegrations.WallabagOnlyURL,
 		)
 
 		if err := client.CreateEntry(entry.URL, entry.Title, entry.Content); err != nil {
 			slog.Error("Unable to send entry to Wallabag",
 				slog.Int64("user_id", userIntegrations.UserID),
+				slog.String("user_tags", userIntegrations.WallabagTags),
 				slog.Int64("entry_id", entry.ID),
 				slog.String("entry_url", entry.URL),
 				slog.Any("error", err),
@@ -196,24 +200,6 @@ func SendEntry(entry *model.Entry, userIntegrations *model.Integration) {
 		}
 	}
 
-	if userIntegrations.PocketEnabled {
-		slog.Debug("Sending entry to Pocket",
-			slog.Int64("user_id", userIntegrations.UserID),
-			slog.Int64("entry_id", entry.ID),
-			slog.String("entry_url", entry.URL),
-		)
-
-		client := pocket.NewClient(config.Opts.PocketConsumerKey(userIntegrations.PocketConsumerKey), userIntegrations.PocketAccessToken)
-		if err := client.AddURL(entry.URL, entry.Title); err != nil {
-			slog.Error("Unable to send entry to Pocket",
-				slog.Int64("user_id", userIntegrations.UserID),
-				slog.Int64("entry_id", entry.ID),
-				slog.String("entry_url", entry.URL),
-				slog.Any("error", err),
-			)
-		}
-	}
-
 	if userIntegrations.LinkAceEnabled {
 		slog.Debug("Sending entry to LinkAce",
 			slog.Int64("user_id", userIntegrations.UserID),
@@ -261,6 +247,29 @@ func SendEntry(entry *model.Entry, userIntegrations *model.Integration) {
 		}
 	}
 
+	if userIntegrations.LinktacoEnabled {
+		slog.Debug("Sending entry to LinkTaco",
+			slog.Int64("user_id", userIntegrations.UserID),
+			slog.Int64("entry_id", entry.ID),
+			slog.String("entry_url", entry.URL),
+		)
+
+		client := linktaco.NewClient(
+			userIntegrations.LinktacoAPIToken,
+			userIntegrations.LinktacoOrgSlug,
+			userIntegrations.LinktacoTags,
+			userIntegrations.LinktacoVisibility,
+		)
+		if err := client.CreateBookmark(entry.URL, entry.Title, entry.Content); err != nil {
+			slog.Error("Unable to send entry to LinkTaco",
+				slog.Int64("user_id", userIntegrations.UserID),
+				slog.Int64("entry_id", entry.ID),
+				slog.String("entry_url", entry.URL),
+				slog.Any("error", err),
+			)
+		}
+	}
+
 	if userIntegrations.LinkwardenEnabled {
 		slog.Debug("Sending entry to linkwarden",
 			slog.Int64("user_id", userIntegrations.UserID),
@@ -390,21 +399,38 @@ func SendEntry(entry *model.Entry, userIntegrations *model.Integration) {
 		}
 	}
 
+	if userIntegrations.ArchiveorgEnabled {
+		slog.Debug("Sending entry to archive.org",
+			slog.Int64("user_id", userIntegrations.UserID),
+			slog.Int64("entry_id", entry.ID),
+			slog.String("entry_url", entry.URL),
+		)
+
+		archiveorg.NewClient().SendURL(entry.URL, entry.Title)
+	}
+
 	if userIntegrations.WebhookEnabled {
+		var webhookURL string
+		if entry.Feed != nil && entry.Feed.WebhookURL != "" {
+			webhookURL = entry.Feed.WebhookURL
+		} else {
+			webhookURL = userIntegrations.WebhookURL
+		}
+
 		slog.Debug("Sending entry to Webhook",
 			slog.Int64("user_id", userIntegrations.UserID),
 			slog.Int64("entry_id", entry.ID),
 			slog.String("entry_url", entry.URL),
-			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.SendSaveEntryWebhookEvent(entry); err != nil {
 			slog.Error("Unable to send entry to Webhook",
 				slog.Int64("user_id", userIntegrations.UserID),
 				slog.Int64("entry_id", entry.ID),
 				slog.String("entry_url", entry.URL),
-				slog.String("webhook_url", userIntegrations.WebhookURL),
+				slog.String("webhook_url", webhookURL),
 				slog.Any("error", err),
 			)
 		}
@@ -428,6 +454,30 @@ func SendEntry(entry *model.Entry, userIntegrations *model.Integration) {
 		}
 	}
 
+	if userIntegrations.KarakeepEnabled {
+		slog.Debug("Sending entry to Karakeep",
+			slog.Int64("user_id", userIntegrations.UserID),
+			slog.String("user_tags", userIntegrations.KarakeepTags),
+			slog.Int64("entry_id", entry.ID),
+			slog.String("entry_url", entry.URL),
+		)
+
+		client := karakeep.NewClient(
+			userIntegrations.KarakeepAPIKey,
+			userIntegrations.KarakeepURL,
+			userIntegrations.KarakeepTags,
+		)
+		if err := client.SaveURL(entry.URL); err != nil {
+			slog.Error("Unable to send entry to Karakeep",
+				slog.Int64("user_id", userIntegrations.UserID),
+				slog.String("user_tags", userIntegrations.KarakeepTags),
+				slog.Int64("entry_id", entry.ID),
+				slog.String("entry_url", entry.URL),
+				slog.Any("error", err),
+			)
+		}
+	}
+
 	if userIntegrations.RaindropEnabled {
 		slog.Debug("Sending entry to Raindrop",
 			slog.Int64("user_id", userIntegrations.UserID),
@@ -473,7 +523,6 @@ func PushEntries(feed *model.Feed, entries model.Entries, userIntegrations *mode
 			)
 		}
 	}
-
 	if userIntegrations.WebhookEnabled {
 		var webhookURL string
 		if feed.WebhookURL != "" {

internal/integration/karakeep/karakeep.go

@@ -0,0 +1,163 @@
+// SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package karakeep // import "miniflux.app/v2/internal/integration/karakeep"
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+
+	"miniflux.app/v2/internal/version"
+)
+
+const defaultClientTimeout = 10 * time.Second
+
+type Client struct {
+	wrapped     *http.Client
+	apiEndpoint string
+	apiToken    string
+	tags        string
+}
+
+type tagItem struct {
+	TagName string `json:"tagName"`
+}
+
+type saveURLPayload struct {
+	Type string `json:"type"`
+	URL  string `json:"url"`
+}
+
+type saveURLResponse struct {
+	ID string `json:"id"`
+}
+
+type attachTagsPayload struct {
+	Tags []tagItem `json:"tags"`
+}
+
+type errorResponse struct {
+	Code  string `json:"code"`
+	Error string `json:"error"`
+}
+
+func NewClient(apiToken string, apiEndpoint string, tags string) *Client {
+	return &Client{wrapped: &http.Client{Timeout: defaultClientTimeout}, apiEndpoint: apiEndpoint, apiToken: apiToken, tags: tags}
+}
+
+func (c *Client) attachTags(entryID string) error {
+	if c.tags == "" {
+		return nil
+	}
+
+	tagItems := make([]tagItem, 0)
+	for tag := range strings.SplitSeq(c.tags, ",") {
+		if trimmedTag := strings.TrimSpace(tag); trimmedTag != "" {
+			tagItems = append(tagItems, tagItem{TagName: trimmedTag})
+		}
+	}
+
+	if len(tagItems) == 0 {
+		return nil
+	}
+
+	tagRequestBody, err := json.Marshal(&attachTagsPayload{
+		Tags: tagItems,
+	})
+	if err != nil {
+		return fmt.Errorf("karakeep: unable to encode tag request body: %v", err)
+	}
+
+	tagRequest, err := http.NewRequest(http.MethodPost, fmt.Sprintf("%s/%s/tags", c.apiEndpoint, entryID), bytes.NewReader(tagRequestBody))
+	if err != nil {
+		return fmt.Errorf("karakeep: unable to create tag request: %v", err)
+	}
+
+	tagRequest.Header.Set("Authorization", "Bearer "+c.apiToken)
+	tagRequest.Header.Set("Content-Type", "application/json")
+	tagRequest.Header.Set("User-Agent", "Miniflux/"+version.Version)
+
+	tagResponse, err := c.wrapped.Do(tagRequest)
+	if err != nil {
+		return fmt.Errorf("karakeep: unable to send tag request: %v", err)
+	}
+	defer tagResponse.Body.Close()
+
+	if tagResponse.StatusCode != http.StatusOK && tagResponse.StatusCode != http.StatusCreated {
+		tagResponseBody, err := io.ReadAll(tagResponse.Body)
+		if err != nil {
+			return fmt.Errorf("karakeep: failed to parse tag response: %s", err)
+		}
+
+		var errResponse errorResponse
+		if err := json.Unmarshal(tagResponseBody, &errResponse); err != nil {
+			return fmt.Errorf("karakeep: unable to parse tag error response: status=%d body=%s", tagResponse.StatusCode, string(tagResponseBody))
+		}
+		return fmt.Errorf("karakeep: failed to attach tags: status=%d errorcode=%s %s", tagResponse.StatusCode, errResponse.Code, errResponse.Error)
+	}
+
+	return nil
+}
+
+func (c *Client) SaveURL(entryURL string) error {
+	requestBody, err := json.Marshal(&saveURLPayload{
+		Type: "link",
+		URL:  entryURL,
+	})
+	if err != nil {
+		return fmt.Errorf("karakeep: unable to encode request body: %v", err)
+	}
+
+	req, err := http.NewRequest(http.MethodPost, c.apiEndpoint, bytes.NewReader(requestBody))
+	if err != nil {
+		return fmt.Errorf("karakeep: unable to create request: %v", err)
+	}
+
+	req.Header.Set("Authorization", "Bearer "+c.apiToken)
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("User-Agent", "Miniflux/"+version.Version)
+
+	resp, err := c.wrapped.Do(req)
+	if err != nil {
+		return fmt.Errorf("karakeep: unable to send request: %v", err)
+	}
+	defer resp.Body.Close()
+
+	responseBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("karakeep: failed to parse response: %s", err)
+	}
+
+	if resp.Header.Get("Content-Type") != "application/json" {
+		return fmt.Errorf("karakeep: unexpected content type response: %s", resp.Header.Get("Content-Type"))
+	}
+
+	if resp.StatusCode != http.StatusCreated {
+		var errResponse errorResponse
+		if err := json.Unmarshal(responseBody, &errResponse); err != nil {
+			return fmt.Errorf("karakeep: unable to parse error response: status=%d body=%s", resp.StatusCode, string(responseBody))
+		}
+		return fmt.Errorf("karakeep: failed to save URL: status=%d errorcode=%s %s", resp.StatusCode, errResponse.Code, errResponse.Error)
+	}
+
+	var response saveURLResponse
+	if err := json.Unmarshal(responseBody, &response); err != nil {
+		return fmt.Errorf("karakeep: unable to parse response: %v", err)
+	}
+
+	if response.ID == "" {
+		return errors.New("karakeep: unable to get ID from response")
+	}
+
+	if err := c.attachTags(response.ID); err != nil {
+		return fmt.Errorf("karakeep: unable to attach tags: %v", err)
+	}
+
+	return nil
+}

internal/integration/linkace/linkace.go

@@ -1,8 +1,12 @@
-package linkace
+// SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package linkace // import "miniflux.app/v2/internal/integration/linkace"
 
 import (
 	"bytes"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net/http"
 	"strings"
@@ -28,7 +32,7 @@ func NewClient(baseURL, apiKey, tags string, private bool, checkDisabled bool) *
 
 func (c *Client) AddURL(entryURL, entryTitle string) error {
 	if c.baseURL == "" || c.apiKey == "" {
-		return fmt.Errorf("linkace: missing base URL or API key")
+		return errors.New("linkace: missing base URL or API key")
 	}
 
 	tagsSplitFn := func(c rune) bool {

internal/integration/linkding/linkding.go

@@ -6,6 +6,7 @@ package linkding // import "miniflux.app/v2/internal/integration/linkding"
 import (
 	"bytes"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net/http"
 	"strings"
@@ -30,7 +31,7 @@ func NewClient(baseURL, apiKey, tags string, unread bool) *Client {
 
 func (c *Client) CreateBookmark(entryURL, entryTitle string) error {
 	if c.baseURL == "" || c.apiKey == "" {
-		return fmt.Errorf("linkding: missing base URL or API key")
+		return errors.New("linkding: missing base URL or API key")
 	}
 
 	tagsSplitFn := func(c rune) bool {

internal/integration/linktaco/linktaco.go

@@ -0,0 +1,147 @@
+// SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package linktaco // import "miniflux.app/v2/internal/integration/linktaco"
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"strings"
+	"time"
+
+	"miniflux.app/v2/internal/version"
+)
+
+const (
+	defaultClientTimeout = 10 * time.Second
+	defaultGraphQLURL    = "https://api.linktaco.com/query"
+	maxTags              = 10
+	maxDescriptionLength = 500
+)
+
+type Client struct {
+	graphqlURL string
+	apiToken   string
+	orgSlug    string
+	tags       string
+	visibility string
+}
+
+func NewClient(apiToken, orgSlug, tags, visibility string) *Client {
+	if visibility == "" {
+		visibility = "PUBLIC"
+	}
+	return &Client{
+		graphqlURL: defaultGraphQLURL,
+		apiToken:   apiToken,
+		orgSlug:    orgSlug,
+		tags:       tags,
+		visibility: visibility,
+	}
+}
+
+func (c *Client) CreateBookmark(entryURL, entryTitle, entryContent string) error {
+	if c.apiToken == "" || c.orgSlug == "" {
+		return errors.New("linktaco: missing API token or organization slug")
+	}
+
+	description := entryContent
+	if len(description) > maxDescriptionLength {
+		description = description[:maxDescriptionLength]
+	}
+
+	// tags (limit to 10)
+	tags := strings.FieldsFunc(c.tags, func(c rune) bool {
+		return c == ',' || c == ' '
+	})
+	if len(tags) > maxTags {
+		tags = tags[:maxTags]
+	}
+	// tagsStr is used in GraphQL query to pass comma separated tags
+	tagsStr := strings.Join(tags, ",")
+
+	mutation := `
+		mutation AddLink($input: LinkInput!) {
+			addLink(input: $input) {
+				id
+				url
+				title
+			}
+		}
+	`
+
+	variables := map[string]any{
+		"input": map[string]any{
+			"url":         entryURL,
+			"title":       entryTitle,
+			"description": description,
+			"orgSlug":     c.orgSlug,
+			"visibility":  c.visibility,
+			"unread":      true,
+			"starred":     false,
+			"archive":     false,
+			"tags":        tagsStr,
+		},
+	}
+
+	requestBody, err := json.Marshal(map[string]any{
+		"query":     mutation,
+		"variables": variables,
+	})
+	if err != nil {
+		return fmt.Errorf("linktaco: unable to encode request body: %v", err)
+	}
+
+	request, err := http.NewRequest(http.MethodPost, c.graphqlURL, bytes.NewReader(requestBody))
+	if err != nil {
+		return fmt.Errorf("linktaco: 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.apiToken)
+
+	httpClient := &http.Client{Timeout: defaultClientTimeout}
+	response, err := httpClient.Do(request)
+	if err != nil {
+		return fmt.Errorf("linktaco: unable to send request: %v", err)
+	}
+	defer response.Body.Close()
+
+	if response.StatusCode >= 400 {
+		return fmt.Errorf("linktaco: unable to create bookmark: status=%d", response.StatusCode)
+	}
+
+	var graphqlResponse struct {
+		Data   json.RawMessage   `json:"data"`
+		Errors []json.RawMessage `json:"errors"`
+	}
+
+	if err := json.NewDecoder(response.Body).Decode(&graphqlResponse); err != nil {
+		return fmt.Errorf("linktaco: unable to decode response: %v", err)
+	}
+
+	if len(graphqlResponse.Errors) > 0 {
+		// Try to extract error message
+		var errorMsg string
+		for _, errJSON := range graphqlResponse.Errors {
+			var errObj struct {
+				Message string `json:"message"`
+			}
+			if json.Unmarshal(errJSON, &errObj) == nil && errObj.Message != "" {
+				errorMsg = errObj.Message
+				break
+			}
+		}
+		if errorMsg == "" {
+			// Fallback. Should never be reached.
+			errorMsg = "GraphQL error occurred (fallback message)"
+		}
+		return fmt.Errorf("linktaco: %s", errorMsg)
+	}
+
+	return nil
+}

internal/integration/linktaco/linktaco_test.go

@@ -0,0 +1,440 @@
+// SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+package linktaco
+
+import (
+	"encoding/json"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+func TestCreateBookmark(t *testing.T) {
+	tests := []struct {
+		name           string
+		apiToken       string
+		orgSlug        string
+		tags           string
+		visibility     string
+		entryURL       string
+		entryTitle     string
+		entryContent   string
+		serverResponse func(w http.ResponseWriter, r *http.Request)
+		wantErr        bool
+		errContains    string
+	}{
+		{
+			name:         "successful bookmark creation",
+			apiToken:     "test-token",
+			orgSlug:      "test-org",
+			tags:         "tag1, tag2",
+			visibility:   "PUBLIC",
+			entryURL:     "https://example.com",
+			entryTitle:   "Test Article",
+			entryContent: "Test content",
+			serverResponse: func(w http.ResponseWriter, r *http.Request) {
+				// Verify authorization header
+				auth := r.Header.Get("Authorization")
+				if auth != "Bearer test-token" {
+					t.Errorf("Expected Authorization header 'Bearer test-token', got %s", auth)
+				}
+
+				// Verify content type
+				contentType := r.Header.Get("Content-Type")
+				if contentType != "application/json" {
+					t.Errorf("Expected Content-Type 'application/json', got %s", contentType)
+				}
+
+				// Parse and verify request
+				body, _ := io.ReadAll(r.Body)
+				var req map[string]interface{}
+				if err := json.Unmarshal(body, &req); err != nil {
+					t.Errorf("Failed to parse request body: %v", err)
+				}
+
+				// Verify mutation exists
+				if _, ok := req["query"]; !ok {
+					t.Error("Missing 'query' field in request")
+				}
+
+				// Return success response
+				w.WriteHeader(http.StatusOK)
+				json.NewEncoder(w).Encode(map[string]interface{}{
+					"data": map[string]interface{}{
+						"addLink": map[string]interface{}{
+							"id":    "123",
+							"url":   "https://example.com",
+							"title": "Test Article",
+						},
+					},
+				})
+			},
+			wantErr: false,
+		},
+		{
+			name:         "missing API token",
+			apiToken:     "",
+			orgSlug:      "test-org",
+			entryURL:     "https://example.com",
+			entryTitle:   "Test",
+			entryContent: "Content",
+			serverResponse: func(w http.ResponseWriter, r *http.Request) {
+				// Should not be called
+				t.Error("Server should not be called when API token is missing")
+			},
+			wantErr:     true,
+			errContains: "missing API token or organization slug",
+		},
+		{
+			name:         "missing organization slug",
+			apiToken:     "test-token",
+			orgSlug:      "",
+			entryURL:     "https://example.com",
+			entryTitle:   "Test",
+			entryContent: "Content",
+			serverResponse: func(w http.ResponseWriter, r *http.Request) {
+				// Should not be called
+				t.Error("Server should not be called when org slug is missing")
+			},
+			wantErr:     true,
+			errContains: "missing API token or organization slug",
+		},
+		{
+			name:         "GraphQL error response",
+			apiToken:     "test-token",
+			orgSlug:      "test-org",
+			entryURL:     "https://example.com",
+			entryTitle:   "Test",
+			entryContent: "Content",
+			serverResponse: func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusOK)
+				json.NewEncoder(w).Encode(map[string]interface{}{
+					"errors": []interface{}{
+						map[string]interface{}{
+							"message": "Invalid input",
+						},
+					},
+				})
+			},
+			wantErr:     true,
+			errContains: "Invalid input",
+		},
+		{
+			name:         "HTTP error status",
+			apiToken:     "test-token",
+			orgSlug:      "test-org",
+			entryURL:     "https://example.com",
+			entryTitle:   "Test",
+			entryContent: "Content",
+			serverResponse: func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusUnauthorized)
+			},
+			wantErr:     true,
+			errContains: "status=401",
+		},
+		{
+			name:         "private visibility permission error",
+			apiToken:     "test-token",
+			orgSlug:      "test-org",
+			visibility:   "PRIVATE",
+			entryURL:     "https://example.com",
+			entryTitle:   "Test",
+			entryContent: "Content",
+			serverResponse: func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusOK)
+				json.NewEncoder(w).Encode(map[string]interface{}{
+					"errors": []interface{}{
+						map[string]interface{}{
+							"message": "PRIVATE visibility requires a paid LinkTaco account",
+						},
+					},
+				})
+			},
+			wantErr:     true,
+			errContains: "PRIVATE visibility requires a paid LinkTaco account",
+		},
+		{
+			name:         "content truncation",
+			apiToken:     "test-token",
+			orgSlug:      "test-org",
+			entryURL:     "https://example.com",
+			entryTitle:   "Test",
+			entryContent: strings.Repeat("a", 600), // Content longer than 500 chars
+			serverResponse: func(w http.ResponseWriter, r *http.Request) {
+				body, _ := io.ReadAll(r.Body)
+				var req map[string]interface{}
+				json.Unmarshal(body, &req)
+
+				// Check that description was truncated
+				variables := req["variables"].(map[string]interface{})
+				input := variables["input"].(map[string]interface{})
+				description := input["description"].(string)
+
+				if len(description) != maxDescriptionLength {
+					t.Errorf("Expected description length %d, got %d", maxDescriptionLength, len(description))
+				}
+
+				w.WriteHeader(http.StatusOK)
+				json.NewEncoder(w).Encode(map[string]interface{}{
+					"data": map[string]interface{}{
+						"addLink": map[string]interface{}{"id": "123"},
+					},
+				})
+			},
+			wantErr: false,
+		},
+		{
+			name:         "tag limiting",
+			apiToken:     "test-token",
+			orgSlug:      "test-org",
+			tags:         "tag1,tag2,tag3,tag4,tag5,tag6,tag7,tag8,tag9,tag10,tag11,tag12",
+			entryURL:     "https://example.com",
+			entryTitle:   "Test",
+			entryContent: "Content",
+			serverResponse: func(w http.ResponseWriter, r *http.Request) {
+				body, _ := io.ReadAll(r.Body)
+				var req map[string]interface{}
+				json.Unmarshal(body, &req)
+
+				// Check that only 10 tags were sent
+				variables := req["variables"].(map[string]interface{})
+				input := variables["input"].(map[string]interface{})
+				tags := input["tags"].(string)
+
+				tagCount := len(strings.Split(tags, ","))
+				if tagCount != maxTags {
+					t.Errorf("Expected %d tags, got %d", maxTags, tagCount)
+				}
+
+				w.WriteHeader(http.StatusOK)
+				json.NewEncoder(w).Encode(map[string]interface{}{
+					"data": map[string]interface{}{
+						"addLink": map[string]interface{}{"id": "123"},
+					},
+				})
+			},
+			wantErr: false,
+		},
+		{
+			name:         "invalid JSON response",
+			apiToken:     "test-token",
+			orgSlug:      "test-org",
+			entryURL:     "https://example.com",
+			entryTitle:   "Test",
+			entryContent: "Content",
+			serverResponse: func(w http.ResponseWriter, r *http.Request) {
+				w.WriteHeader(http.StatusOK)
+				w.Write([]byte("invalid json"))
+			},
+			wantErr:     true,
+			errContains: "unable to decode response",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Create test server if we have a server response function
+			var serverURL string
+			if tt.serverResponse != nil {
+				server := httptest.NewServer(http.HandlerFunc(tt.serverResponse))
+				defer server.Close()
+				serverURL = server.URL
+			}
+
+			// Create client with test server URL
+			client := &Client{
+				graphqlURL: serverURL,
+				apiToken:   tt.apiToken,
+				orgSlug:    tt.orgSlug,
+				tags:       tt.tags,
+				visibility: tt.visibility,
+			}
+
+			// Call CreateBookmark
+			err := client.CreateBookmark(tt.entryURL, tt.entryTitle, tt.entryContent)
+
+			// Check error expectations
+			if tt.wantErr {
+				if err == nil {
+					t.Errorf("Expected error but got none")
+				} else if tt.errContains != "" && !strings.Contains(err.Error(), tt.errContains) {
+					t.Errorf("Expected error containing '%s', got '%s'", tt.errContains, err.Error())
+				}
+			} else {
+				if err != nil {
+					t.Errorf("Unexpected error: %v", err)
+				}
+			}
+		})
+	}
+}
+
+func TestNewClient(t *testing.T) {
+	tests := []struct {
+		name               string
+		apiToken           string
+		orgSlug            string
+		tags               string
+		visibility         string
+		expectedVisibility string
+	}{
+		{
+			name:               "with all parameters",
+			apiToken:           "token",
+			orgSlug:            "org",
+			tags:               "tag1,tag2",
+			visibility:         "PRIVATE",
+			expectedVisibility: "PRIVATE",
+		},
+		{
+			name:               "empty visibility defaults to PUBLIC",
+			apiToken:           "token",
+			orgSlug:            "org",
+			tags:               "tag1",
+			visibility:         "",
+			expectedVisibility: "PUBLIC",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			client := NewClient(tt.apiToken, tt.orgSlug, tt.tags, tt.visibility)
+
+			if client.apiToken != tt.apiToken {
+				t.Errorf("Expected apiToken %s, got %s", tt.apiToken, client.apiToken)
+			}
+			if client.orgSlug != tt.orgSlug {
+				t.Errorf("Expected orgSlug %s, got %s", tt.orgSlug, client.orgSlug)
+			}
+			if client.tags != tt.tags {
+				t.Errorf("Expected tags %s, got %s", tt.tags, client.tags)
+			}
+			if client.visibility != tt.expectedVisibility {
+				t.Errorf("Expected visibility %s, got %s", tt.expectedVisibility, client.visibility)
+			}
+			if client.graphqlURL != defaultGraphQLURL {
+				t.Errorf("Expected graphqlURL %s, got %s", defaultGraphQLURL, client.graphqlURL)
+			}
+		})
+	}
+}
+
+func TestGraphQLMutation(t *testing.T) {
+	// Test that the GraphQL mutation is properly formatted
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		body, _ := io.ReadAll(r.Body)
+		var req map[string]interface{}
+		if err := json.Unmarshal(body, &req); err != nil {
+			t.Fatalf("Failed to parse request: %v", err)
+		}
+
+		// Verify mutation structure
+		query, ok := req["query"].(string)
+		if !ok {
+			t.Fatal("Missing query field")
+		}
+
+		// Check that mutation contains expected parts
+		if !strings.Contains(query, "mutation AddLink") {
+			t.Error("Mutation should contain 'mutation AddLink'")
+		}
+		if !strings.Contains(query, "$input: LinkInput!") {
+			t.Error("Mutation should contain input parameter")
+		}
+		if !strings.Contains(query, "addLink(input: $input)") {
+			t.Error("Mutation should contain addLink call")
+		}
+
+		// Verify variables structure
+		variables, ok := req["variables"].(map[string]interface{})
+		if !ok {
+			t.Fatal("Missing variables field")
+		}
+
+		input, ok := variables["input"].(map[string]interface{})
+		if !ok {
+			t.Fatal("Missing input in variables")
+		}
+
+		// Check all required fields
+		requiredFields := []string{"url", "title", "description", "orgSlug", "visibility", "unread", "starred", "archive", "tags"}
+		for _, field := range requiredFields {
+			if _, ok := input[field]; !ok {
+				t.Errorf("Missing required field: %s", field)
+			}
+		}
+
+		// Return success
+		w.WriteHeader(http.StatusOK)
+		json.NewEncoder(w).Encode(map[string]interface{}{
+			"data": map[string]interface{}{
+				"addLink": map[string]interface{}{
+					"id": "123",
+				},
+			},
+		})
+	}))
+	defer server.Close()
+
+	client := &Client{
+		graphqlURL: server.URL,
+		apiToken:   "test-token",
+		orgSlug:    "test-org",
+		tags:       "test",
+		visibility: "PUBLIC",
+	}
+
+	err := client.CreateBookmark("https://example.com", "Test Title", "Test Content")
+	if err != nil {
+		t.Errorf("Unexpected error: %v", err)
+	}
+}
+
+func BenchmarkCreateBookmark(b *testing.B) {
+	// Create a mock server that always returns success
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.WriteHeader(http.StatusOK)
+		json.NewEncoder(w).Encode(map[string]interface{}{
+			"data": map[string]interface{}{
+				"addLink": map[string]interface{}{
+					"id": "123",
+				},
+			},
+		})
+	}))
+	defer server.Close()
+
+	client := &Client{
+		graphqlURL: server.URL,
+		apiToken:   "test-token",
+		orgSlug:    "test-org",
+		tags:       "tag1,tag2,tag3",
+		visibility: "PUBLIC",
+	}
+
+	// Run benchmark
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		_ = client.CreateBookmark("https://example.com", "Test Title", "Test Content")
+	}
+}
+
+func BenchmarkTagProcessing(b *testing.B) {
+	// Benchmark tag splitting and limiting
+	tags := "tag1,tag2,tag3,tag4,tag5,tag6,tag7,tag8,tag9,tag10,tag11,tag12,tag13,tag14,tag15"
+
+	b.ResetTimer()
+	for i := 0; i < b.N; i++ {
+		tagsSplitFn := func(c rune) bool {
+			return c == ',' || c == ' '
+		}
+		splitTags := strings.FieldsFunc(tags, tagsSplitFn)
+		if len(splitTags) > maxTags {
+			splitTags = splitTags[:maxTags]
+		}
+		_ = strings.Join(splitTags, ",")
+	}
+}

internal/integration/linkwarden/linkwarden.go

@@ -6,6 +6,7 @@ package linkwarden // import "miniflux.app/v2/internal/integration/linkwarden"
 import (
 	"bytes"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net/http"
 	"time"
@@ -27,7 +28,7 @@ func NewClient(baseURL, apiKey string) *Client {
 
 func (c *Client) CreateBookmark(entryURL, entryTitle string) error {
 	if c.baseURL == "" || c.apiKey == "" {
-		return fmt.Errorf("linkwarden: missing base URL or API key")
+		return errors.New("linkwarden: missing base URL or API key")
 	}
 
 	apiEndpoint, err := urllib.JoinBaseURLAndPath(c.baseURL, "/api/v1/links")
@@ -35,12 +36,9 @@ func (c *Client) CreateBookmark(entryURL, entryTitle string) error {
 		return fmt.Errorf(`linkwarden: invalid API endpoint: %v`, err)
 	}
 
-	requestBody, err := json.Marshal(&linkwardenBookmark{
-		Url:         entryURL,
-		Name:        "",
-		Description: "",
-		Tags:        []string{},
-		Collection:  map[string]interface{}{},
+	requestBody, err := json.Marshal(map[string]string{
+		"url":  entryURL,
+		"name": entryTitle,
 	})
 
 	if err != nil {
@@ -54,8 +52,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.AddCookie(&http.Cookie{Name: "__Secure-next-auth.session-token", Value: c.apiKey})
-	request.AddCookie(&http.Cookie{Name: "next-auth.session-token", Value: c.apiKey})
+	request.Header.Set("Authorization", "Bearer "+c.apiKey)
 
 	httpClient := &http.Client{Timeout: defaultClientTimeout}
 	response, err := httpClient.Do(request)
@@ -70,11 +67,3 @@ func (c *Client) CreateBookmark(entryURL, entryTitle string) error {
 
 	return nil
 }
-
-type linkwardenBookmark struct {
-	Url         string                 `json:"url"`
-	Name        string                 `json:"name"`
-	Description string                 `json:"description"`
-	Tags        []string               `json:"tags"`
-	Collection  map[string]interface{} `json:"collection"`
-}

internal/integration/matrixbot/matrixbot.go

@@ -23,8 +23,8 @@ func PushEntries(feed *model.Feed, entries model.Entries, matrixBaseURL, matrixU
 		return err
 	}
 
-	var textMessages []string
-	var formattedTextMessages []string
+	textMessages := make([]string, 0, len(entries))
+	formattedTextMessages := make([]string, 0, len(entries))
 
 	for _, entry := range entries {
 		textMessages = append(textMessages, fmt.Sprintf(`[%s] %s - %s`, feed.Title, entry.Title, entry.URL))

internal/integration/notion/notion.go

@@ -6,6 +6,7 @@ package notion
 import (
 	"bytes"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net/http"
 	"time"
@@ -26,7 +27,7 @@ func NewClient(apiToken, pageID string) *Client {
 
 func (c *Client) UpdateDocument(entryURL string, entryTitle string) error {
 	if c.apiToken == "" || c.pageID == "" {
-		return fmt.Errorf("notion: missing API token or page ID")
+		return errors.New("notion: missing API token or page ID")
 	}
 
 	apiEndpoint := "https://api.notion.com/v1/blocks/" + c.pageID + "/children"

internal/integration/ntfy/ntfy.go

@@ -90,7 +90,7 @@ func (c *Client) makeRequest(payload any) error {
 
 	// See https://docs.ntfy.sh/publish/#access-tokens
 	if c.ntfyApiToken != "" {
-		request.Header.Set("Authorization", fmt.Sprintf("Bearer %s", c.ntfyApiToken))
+		request.Header.Set("Authorization", "Bearer "+c.ntfyApiToken)
 	}
 
 	// See https://docs.ntfy.sh/publish/#username-password

internal/integration/nunuxkeeper/nunuxkeeper.go

@@ -6,6 +6,7 @@ package nunuxkeeper // import "miniflux.app/v2/internal/integration/nunuxkeeper"
 import (
 	"bytes"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net/http"
 	"time"
@@ -27,7 +28,7 @@ func NewClient(baseURL, apiKey string) *Client {
 
 func (c *Client) AddEntry(entryURL, entryTitle, entryContent string) error {
 	if c.baseURL == "" || c.apiKey == "" {
-		return fmt.Errorf("nunux-keeper: missing base URL or API key")
+		return errors.New("nunux-keeper: missing base URL or API key")
 	}
 
 	apiEndpoint, err := urllib.JoinBaseURLAndPath(c.baseURL, "/v2/documents")

internal/integration/omnivore/omnivore.go

@@ -74,10 +74,10 @@ func NewClient(apiToken string, apiEndpoint string) Client {
 }
 
 func (c *client) SaveUrl(url string) error {
-	var payload = map[string]interface{}{
+	var payload = map[string]any{
 		"query": mutation,
-		"variables": map[string]interface{}{
-			"input": map[string]interface{}{
+		"variables": map[string]any{
+			"input": map[string]any{
 				"clientRequestId": crypto.GenerateUUID(),
 				"source":          "api",
 				"url":             url,

internal/integration/pinboard/pinboard.go

@@ -14,8 +14,8 @@ import (
 	"miniflux.app/v2/internal/version"
 )
 
-var errPostNotFound = fmt.Errorf("pinboard: post not found")
-var errMissingCredentials = fmt.Errorf("pinboard: missing auth token")
+var errPostNotFound = errors.New("pinboard: post not found")
+var errMissingCredentials = errors.New("pinboard: missing auth token")
 
 const defaultClientTimeout = 10 * time.Second
 

internal/integration/pocket/connector.go

@@ -1,132 +0,0 @@
-// SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package pocket // import "miniflux.app/v2/internal/integration/pocket"
-
-import (
-	"bytes"
-	"encoding/json"
-	"errors"
-	"fmt"
-	"net/http"
-
-	"miniflux.app/v2/internal/version"
-)
-
-// Connector manages the authorization flow with Pocket to get a personal access token.
-type Connector struct {
-	consumerKey string
-}
-
-// NewConnector returns a new Pocket Connector.
-func NewConnector(consumerKey string) *Connector {
-	return &Connector{consumerKey}
-}
-
-// RequestToken fetches a new request token from Pocket API.
-func (c *Connector) RequestToken(redirectURL string) (string, error) {
-	apiEndpoint := "https://getpocket.com/v3/oauth/request"
-	requestBody, err := json.Marshal(&createTokenRequest{ConsumerKey: c.consumerKey, RedirectURI: redirectURL})
-	if err != nil {
-		return "", fmt.Errorf("pocket: unable to encode request body: %v", err)
-	}
-
-	request, err := http.NewRequest(http.MethodPost, apiEndpoint, bytes.NewReader(requestBody))
-	if err != nil {
-		return "", fmt.Errorf("pocket: unable to create request: %v", err)
-	}
-
-	request.Header.Set("Content-Type", "application/json")
-	request.Header.Set("X-Accept", "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("pocket: unable to send request: %v", err)
-	}
-	defer response.Body.Close()
-
-	if response.StatusCode >= 400 {
-		return "", fmt.Errorf("pocket: unable get request token: url=%s status=%d", apiEndpoint, response.StatusCode)
-	}
-
-	var result createTokenResponse
-	if err := json.NewDecoder(response.Body).Decode(&result); err != nil {
-		return "", fmt.Errorf("pocket: unable to decode response: %v", err)
-	}
-
-	if result.Code == "" {
-		return "", errors.New("pocket: request token is empty")
-	}
-
-	return result.Code, nil
-}
-
-// AccessToken fetches a new access token once the end-user authorized the application.
-func (c *Connector) AccessToken(requestToken string) (string, error) {
-	apiEndpoint := "https://getpocket.com/v3/oauth/authorize"
-	requestBody, err := json.Marshal(&authorizeRequest{ConsumerKey: c.consumerKey, Code: requestToken})
-	if err != nil {
-		return "", fmt.Errorf("pocket: unable to encode request body: %v", err)
-	}
-
-	request, err := http.NewRequest(http.MethodPost, apiEndpoint, bytes.NewReader(requestBody))
-	if err != nil {
-		return "", fmt.Errorf("pocket: unable to create request: %v", err)
-	}
-
-	request.Header.Set("Content-Type", "application/json")
-	request.Header.Set("X-Accept", "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("pocket: unable to send request: %v", err)
-	}
-	defer response.Body.Close()
-
-	if response.StatusCode >= 400 {
-		return "", fmt.Errorf("pocket: unable get access token: url=%s status=%d", apiEndpoint, response.StatusCode)
-	}
-
-	var result authorizeReponse
-	if err := json.NewDecoder(response.Body).Decode(&result); err != nil {
-		return "", fmt.Errorf("pocket: unable to decode response: %v", err)
-	}
-
-	if result.AccessToken == "" {
-		return "", errors.New("pocket: access token is empty")
-	}
-
-	return result.AccessToken, nil
-}
-
-// AuthorizationURL returns the authorization URL for the end-user.
-func (c *Connector) AuthorizationURL(requestToken, redirectURL string) string {
-	return fmt.Sprintf(
-		"https://getpocket.com/auth/authorize?request_token=%s&redirect_uri=%s",
-		requestToken,
-		redirectURL,
-	)
-}
-
-type createTokenRequest struct {
-	ConsumerKey string `json:"consumer_key"`
-	RedirectURI string `json:"redirect_uri"`
-}
-
-type createTokenResponse struct {
-	Code string `json:"code"`
-}
-
-type authorizeRequest struct {
-	ConsumerKey string `json:"consumer_key"`
-	Code        string `json:"code"`
-}
-
-type authorizeReponse struct {
-	AccessToken string `json:"access_token"`
-	Username    string `json:"username"`
-}

internal/integration/pocket/pocket.go

@@ -1,70 +0,0 @@
-// SPDX-FileCopyrightText: Copyright The Miniflux Authors. All rights reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-package pocket // import "miniflux.app/v2/internal/integration/pocket"
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"net/http"
-	"time"
-
-	"miniflux.app/v2/internal/version"
-)
-
-const defaultClientTimeout = 10 * time.Second
-
-type Client struct {
-	consumerKey string
-	accessToken string
-}
-
-func NewClient(consumerKey, accessToken string) *Client {
-	return &Client{consumerKey, accessToken}
-}
-
-func (c *Client) AddURL(entryURL, entryTitle string) error {
-	if c.consumerKey == "" || c.accessToken == "" {
-		return fmt.Errorf("pocket: missing consumer key or access token")
-	}
-
-	apiEndpoint := "https://getpocket.com/v3/add"
-	requestBody, err := json.Marshal(&createItemRequest{
-		AccessToken: c.accessToken,
-		ConsumerKey: c.consumerKey,
-		Title:       entryTitle,
-		URL:         entryURL,
-	})
-	if err != nil {
-		return fmt.Errorf("pocket: unable to encode request body: %v", err)
-	}
-
-	request, err := http.NewRequest(http.MethodPost, apiEndpoint, bytes.NewReader(requestBody))
-	if err != nil {
-		return fmt.Errorf("pocket: unable to create request: %v", err)
-	}
-
-	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("pocket: unable to send request: %v", err)
-	}
-	defer response.Body.Close()
-
-	if response.StatusCode >= 400 {
-		return fmt.Errorf("pocket: unable to create item: url=%s status=%d", apiEndpoint, response.StatusCode)
-	}
-
-	return nil
-}
-
-type createItemRequest struct {
-	AccessToken string `json:"access_token"`
-	ConsumerKey string `json:"consumer_key"`
-	Title       string `json:"title,omitempty"`
-	URL         string `json:"url"`
-}

internal/integration/pushover/pushover.go

@@ -5,6 +5,7 @@ package pushover // import "miniflux.app/v2/internal/integration/pushover"
 import (
 	"bytes"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"log/slog"
 	"net/http"
@@ -72,7 +73,7 @@ func New(user, token string, priority int, device, urlPrefix string) *Client {
 
 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")
+		return errors.New("pushover token and user are required")
 	}
 	for _, entry := range entries {
 		msg := &Message{

internal/integration/raindrop/raindrop.go

@@ -6,6 +6,7 @@ package raindrop // import "miniflux.app/v2/internal/integration/raindrop"
 import (
 	"bytes"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net/http"
 	"strings"
@@ -29,7 +30,7 @@ func NewClient(token, collectionID, tags string) *Client {
 // 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")
+		return errors.New("raindrop: missing token")
 	}
 
 	var request *http.Request

internal/integration/readeck/readeck.go

@@ -6,6 +6,7 @@ package readeck // import "miniflux.app/v2/internal/integration/readeck"
 import (
 	"bytes"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"mime/multipart"
 	"net/http"
@@ -31,7 +32,7 @@ func NewClient(baseURL, apiKey, labels string, onlyURL bool) *Client {
 
 func (c *Client) CreateBookmark(entryURL, entryTitle string, entryContent string) error {
 	if c.baseURL == "" || c.apiKey == "" {
-		return fmt.Errorf("readeck: missing base URL or API key")
+		return errors.New("readeck: missing base URL or API key")
 	}
 
 	apiEndpoint, err := urllib.JoinBaseURLAndPath(c.baseURL, "/api/bookmarks/")

internal/integration/readwise/readwise.go

@@ -8,6 +8,7 @@ package readwise // import "miniflux.app/v2/internal/integration/readwise"
 import (
 	"bytes"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net/http"
 	"time"
@@ -30,7 +31,7 @@ func NewClient(apiKey string) *Client {
 
 func (c *Client) CreateDocument(entryURL string) error {
 	if c.apiKey == "" {
-		return fmt.Errorf("readwise: missing API key")
+		return errors.New("readwise: missing API key")
 	}
 
 	requestBody, err := json.Marshal(&readwiseDocument{

internal/integration/shaarli/shaarli.go

@@ -9,6 +9,7 @@ import (
 	"crypto/sha512"
 	"encoding/base64"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net/http"
 	"time"
@@ -30,7 +31,7 @@ func NewClient(baseURL, apiSecret string) *Client {
 
 func (c *Client) CreateLink(entryURL, entryTitle string) error {
 	if c.baseURL == "" || c.apiSecret == "" {
-		return fmt.Errorf("shaarli: missing base URL or API secret")
+		return errors.New("shaarli: missing base URL or API secret")
 	}
 
 	apiEndpoint, err := urllib.JoinBaseURLAndPath(c.baseURL, "/api/v1/links")

internal/integration/shiori/shiori.go

@@ -6,6 +6,7 @@ package shiori // import "miniflux.app/v2/internal/integration/shiori"
 import (
 	"bytes"
 	"encoding/json"
+	"errors"
 	"fmt"
 	"net/http"
 	"time"
@@ -28,7 +29,7 @@ func NewClient(baseURL, username, password string) *Client {
 
 func (c *Client) CreateBookmark(entryURL, entryTitle string) error {
 	if c.baseURL == "" || c.username == "" || c.password == "" {
-		return fmt.Errorf("shiori: missing base URL, username or password")
+		return errors.New("shiori: missing base URL, username or password")
 	}
 
 	token, err := c.authenticate()