Calibre Web Epub Downloading + Calibre Wireless Device Syncing (#219)

## Summary

Adds support for browsing and downloading books from a Calibre-web
server via OPDS.
How it works
1. Configure server URL in Settings → Calibre Web URL (e.g.,
https://myserver.com:port I use Cloudflare tunnel to make my server
accessible anywhere fwiw)
2. "Calibre Library" will now show on the the home screen
3. Browse the catalog - navigate through categories like "By Newest",
"By Author", "By Series", etc.
4. Download books - select a book and press Confirm to download the EPUB
to your device
Navigation
- Up/Down - Move through entries
- Confirm - Open folder or download book
- Back - Go to parent catalog, or exit to home if at root
- Navigation entries show with > prefix, books show title and author
- Button hints update dynamically ("Open" for folders, "Download" for
books)
Technical details
- Fetches OPDS catalog from {server_url}/opds
- Parses both navigation feeds (catalog links) and acquisition feeds
(downloadable books)
- Maintains navigation history stack for back navigation
- Handles absolute paths in OPDS links correctly (e.g.,
/books/opds/navcatalog/...)
- Downloads EPUBs directly to the SD card root
Note
The server URL should be typed to include https:// if the server
requires it - HTTP→HTTPS redirects may cause SSL errors on ESP32.

## Additional Context

* I also changed the home titles to use uppercase for each word and
added a setting to change the size of the side margins

---------

Co-authored-by: Dave Allie <dave@daveallie.com>

src/util/StringUtils.cpp

@@ -0,0 +1,36 @@
+#include "StringUtils.h"
+
+namespace StringUtils {
+
+std::string sanitizeFilename(const std::string& name, size_t maxLength) {
+  std::string result;
+  result.reserve(name.size());
+
+  for (char c : name) {
+    // Replace invalid filename characters with underscore
+    if (c == '/' || c == '\\' || c == ':' || c == '*' || c == '?' || c == '"' || c == '<' || c == '>' || c == '|') {
+      result += '_';
+    } else if (c >= 32 && c < 127) {
+      // Keep printable ASCII characters
+      result += c;
+    }
+    // Skip non-printable characters
+  }
+
+  // Trim leading/trailing spaces and dots
+  size_t start = result.find_first_not_of(" .");
+  if (start == std::string::npos) {
+    return "book";  // Fallback if name is all invalid characters
+  }
+  size_t end = result.find_last_not_of(" .");
+  result = result.substr(start, end - start + 1);
+
+  // Limit filename length
+  if (result.length() > maxLength) {
+    result.resize(maxLength);
+  }
+
+  return result.empty() ? "book" : result;
+}
+
+}  // namespace StringUtils

src/util/StringUtils.h

@@ -0,0 +1,13 @@
+#pragma once
+#include <string>
+
+namespace StringUtils {
+
+/**
+ * Sanitize a string for use as a filename.
+ * Replaces invalid characters with underscores, trims spaces/dots,
+ * and limits length to maxLength characters.
+ */
+std::string sanitizeFilename(const std::string& name, size_t maxLength = 100);
+
+}  // namespace StringUtils

src/util/UrlUtils.cpp

@@ -0,0 +1,41 @@
+#include "UrlUtils.h"
+
+namespace UrlUtils {
+
+std::string ensureProtocol(const std::string& url) {
+  if (url.find("://") == std::string::npos) {
+    return "http://" + url;
+  }
+  return url;
+}
+
+std::string extractHost(const std::string& url) {
+  const size_t protocolEnd = url.find("://");
+  if (protocolEnd == std::string::npos) {
+    // No protocol, find first slash
+    const size_t firstSlash = url.find('/');
+    return firstSlash == std::string::npos ? url : url.substr(0, firstSlash);
+  }
+  // Find the first slash after the protocol
+  const size_t hostStart = protocolEnd + 3;
+  const size_t pathStart = url.find('/', hostStart);
+  return pathStart == std::string::npos ? url : url.substr(0, pathStart);
+}
+
+std::string buildUrl(const std::string& serverUrl, const std::string& path) {
+  const std::string urlWithProtocol = ensureProtocol(serverUrl);
+  if (path.empty()) {
+    return urlWithProtocol;
+  }
+  if (path[0] == '/') {
+    // Absolute path - use just the host
+    return extractHost(urlWithProtocol) + path;
+  }
+  // Relative path - append to server URL
+  if (urlWithProtocol.back() == '/') {
+    return urlWithProtocol + path;
+  }
+  return urlWithProtocol + "/" + path;
+}
+
+}  // namespace UrlUtils

src/util/UrlUtils.h

@@ -0,0 +1,23 @@
+#pragma once
+#include <string>
+
+namespace UrlUtils {
+
+/**
+ * Prepend http:// if no protocol specified (server will redirect to https if needed)
+ */
+std::string ensureProtocol(const std::string& url);
+
+/**
+ * Extract host with protocol from URL (e.g., "http://example.com" from "http://example.com/path")
+ */
+std::string extractHost(const std::string& url);
+
+/**
+ * Build full URL from server URL and path.
+ * If path starts with /, it's an absolute path from the host root.
+ * Otherwise, it's relative to the server URL.
+ */
+std::string buildUrl(const std::string& serverUrl, const std::string& path);
+
+}  // namespace UrlUtils