Feedpushr

Feedpushr is a lightweight, self‑hosted feed aggregation engine written in Go that exposes a fully documented REST API and a Web UI for managing subscriptions. At its core, it pulls RSS/Atom feeds, applies user‑defined transformations, and forwards new articles to configurable outputs such as HTTP endpoints, email addresses, or social media platforms. The application ships as a single binary with an embedded SQLite database, making it ideal for quick deployment or embedding into larger Go services. Its architecture is intentionally modular: the core pipeline (fetcher → filter → output) is split into separate packages, each of which can be swapped or extended through a pluggable system.

• Language: Go 1.22+ (static compilation, minimal runtime dependencies).
• Data Store: Embedded SQLite accessed via the database/sql driver, with optional external persistence through Docker volumes.
• Web Framework: Standard library net/http combined with the chi router for clean routing and middleware support.
• Configuration: Environment‑driven via flag parsing; defaults are documented in etc/default/feedpushr.env.
• API: OpenAPI 3.0 specification automatically generated from Go structs; Swagger UI is bundled for interactive exploration.
• Authentication: Supports OpenID Connect, JWT, and basic auth through middleware hooks.
• Metrics & Observability: Prometheus metrics exposed on /metrics; logs are structured JSON for easy ingestion.
• Concurrency: Uses Go routines and channels to parallelize feed fetching, with a configurable worker pool for rate‑limiting.

• Feed Management: CRUD operations for feeds, tags, and categories via REST endpoints.
• OPML Import/Export: Full support for OPML 2.0, including tag mapping via the category attribute.
• Pluggable Filters: Implement custom filters by creating Go plugins that expose a Filter interface; filters can manipulate article metadata or discard items.
• Output Providers: Built‑in outputs (stdout, http, email, readflow, twitter) plus a plugin API to add new destinations.
• Expression Language: A powerful DSL based on govaluate allows conditional routing and field transformation without code changes.
• WebSub Support: The server can act as a WebSub hub, subscribing to push endpoints and delivering updates instantly.
• Quota & Rate‑Limiting: Per‑user or per‑feed quotas are enforced via a pluggable policy engine.

Feedpushr can be run as a standalone binary, Docker container, or within Kubernetes. The Docker image is lightweight (under 50 MB) and exposes port 8080 by default. Persistent storage is achieved through a mounted volume (e.g., /var/opt/feedpushr), which holds the SQLite database and configuration files. For high availability, a reverse proxy (NGINX or Traefik) can be used to route traffic and terminate TLS. Horizontal scaling is possible by running multiple instances behind a load balancer; the embedded database can be swapped for PostgreSQL if cross‑instance consistency is required.

• Webhooks: Outgoing HTTP outputs support custom headers and payload templates, enabling integration with any REST API.
• Plugin System: Filters and outputs are discovered at runtime via Go plugin files (*.so), allowing developers to extend functionality without modifying the core.
• CLI & SDK: A command‑line interface mirrors API endpoints, and the generated Go client (go get github.com/ncarlier/feedpushr/v3) can be embedded into other services.
• Custom Pipelines: The expression language permits per‑feed or per‑tag pipelines, making it trivial to route certain articles to Slack while others go to a Kafka topic.

The project follows idiomatic Go conventions, with exhaustive unit tests and a continuous‑integration pipeline that verifies code quality on every push. Documentation is kept in Markdown within the repo and auto‑generated API docs are available at /docs. The community is active on GitHub issues, and the maintainers respond quickly to pull requests. Licensing under Apache 2.0 ensures freedom to modify and redistribute, which is a significant advantage over proprietary feed readers.

1. Enterprise Content Distribution – Pull internal RSS feeds and push new articles to a corporate intranet portal or email digest.
2. Social Media Automation – Filter and auto‑post news items to Twitter or Mastodon using the built‑in output providers.
3. Data Ingestion Pipelines – Use WebSub or HTTP outputs to stream articles into a data lake or message broker (Kafka, NATS).
4. Personal Knowledge Base – Export feeds to a static site generator or sync with Readflow for offline reading.
5. Compliance Monitoring – Continuously aggregate regulatory feeds and trigger alerts when specific keywords appear.

• Zero‑dependency Runtime: A single binary with an embedded DB simplifies deployment and reduces attack surface.
• Modular Extensibility: Go plugins enable custom logic without fork‑ing the repository.
• Open Standards: Full WebSub, OPML, and OpenAPI support ensures interoperability with existing tools.
• Performance: Go’s concurrency model delivers high throughput while keeping memory usage