feedkeeper 0.0.0-stage → 0.23.1

package/server/dist/db/migrations/0032_normalize_published_at.sql

@@ -0,0 +1,12 @@
+-- Migration 0032: publish dates that are not dates.
+--
+-- Entries whose feed gave a date that could not be read ("gestern", localised weekday names, an empty string) had
+-- the raw text stored. Compared as text it sorted above every real date and never aged. Dates before 1991 and
+-- dates more than a day ahead are placeholders (1970-01-01, year 9999). All of them become NULL, which makes the
+-- app use the time it stored the article.
+UPDATE items SET published_at = NULL
+WHERE published_at IS NOT NULL AND julianday(published_at) IS NULL;
+
+UPDATE items SET published_at = NULL
+WHERE published_at IS NOT NULL
+  AND (julianday(published_at) < julianday('1991-01-01') OR julianday(published_at) > julianday('now', '+1 day'));

package/server/dist/feedkeeper.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { HELP, UsageError, parseArgs, prepareEnvironment } from "./cli.js";
+import { APP_VERSION } from "./version.js";
+// Everything that reads the settings is imported only after the environment is complete: the configuration
+// module validates SESSION_SECRET the moment it loads.
+async function main() {
+    const options = parseArgs(process.argv.slice(2));
+    if (options.action === "help")
+        return void console.log(HELP);
+    if (options.action === "version")
+        return void console.log(APP_VERSION);
+    const envFile = resolve(process.cwd(), ".env");
+    if (existsSync(envFile))
+        process.loadEnvFile(envFile);
+    const prepared = prepareEnvironment(options, process.env);
+    if (options.action === "backup" || options.action === "restore") {
+        process.argv.splice(2, process.argv.length, ...options.forwarded);
+        await import("./backup-cli.js");
+        return;
+    }
+    console.log(`[feedkeeper] version ${APP_VERSION}, data in ${prepared.dataDir}`);
+    if (prepared.secretCreated)
+        console.log(`[feedkeeper] created a session secret at ${prepared.secretPath}; keep it with your backups`);
+    await import("./server.js");
+}
+main().catch((error) => {
+    if (error instanceof UsageError) {
+        console.error(`feedkeeper: ${error.message}\nRun "feedkeeper --help" for usage.`);
+        process.exitCode = 2;
+    }
+    else {
+        console.error(error instanceof Error ? error.message : error);
+        process.exitCode = 1;
+    }
+});
+//# sourceMappingURL=feedkeeper.js.map

package/server/dist/feeds/archive.js

@@ -0,0 +1,334 @@
+import { createHash } from "node:crypto";
+import { mkdirSync, readdirSync, unlinkSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { link, readFile, rename, unlink, writeFile } from "node:fs/promises";
+import { config } from "../config.js";
+import { db } from "../db/index.js";
+import { fetchImage } from "./fetcher.js";
+import { loadFullText } from "./fullText.js";
+import { canAccessItem, findItemById, findItemForUser } from "./repository.js";
+import { decodeEntities } from "./text.js";
+import { ImageCache, ImageCacheBusyError } from "./imageCache.js";
+import { detectImageType } from "./imageTypes.js";
+export { detectImageType } from "./imageTypes.js";
+const MAX_IMAGES_PER_ARTICLE = 30;
+const MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+const FILE_NAME = /^\d+-[0-9a-f]{16}\.(jpg|png|webp|gif|avif)$/;
+let imageCache;
+let imageCacheTimer;
+let imageCacheStopping = false;
+let imageCachePruning = false;
+const archiveWrites = new Set();
+async function storeArchivedImage(destination, image) {
+    const temporary = `${destination}.tmp`;
+    archiveWrites.add(temporary);
+    try {
+        await unlink(temporary).catch((error) => { if (error.code !== "ENOENT")
+            throw error; });
+        if (image.path)
+            await link(image.path, temporary).catch(() => writeFile(temporary, image.buffer, { mode: 0o600 }));
+        else
+            await writeFile(temporary, image.buffer, { mode: 0o600 });
+        await rename(temporary, destination);
+    }
+    finally {
+        archiveWrites.delete(temporary);
+    }
+}
+function sharedImages() {
+    if (!imageCache) {
+        imageCache = new ImageCache(config.imageCache);
+        imageCacheTimer = setInterval(() => {
+            if (imageCachePruning)
+                return;
+            imageCachePruning = true;
+            void imageCache.prune().catch(() => undefined).then(() => {
+                console.log(JSON.stringify({ event: "image_cache", ...imageCache.metrics() }));
+            }).finally(() => { imageCachePruning = false; });
+        }, 60_000);
+        imageCacheTimer.unref();
+    }
+    return imageCache;
+}
+export async function stopImageCache() {
+    imageCacheStopping = true;
+    if (imageCacheTimer)
+        clearInterval(imageCacheTimer);
+    await imageCache?.close();
+}
+function sharedImage(item, url) {
+    if (imageCacheStopping)
+        return Promise.reject(new ImageCacheBusyError());
+    const archived = db.prepare("SELECT file_name FROM archived_images WHERE item_id = ? AND source_url = ?").get(item.id, url);
+    // An old saved snapshot must not replace a newer article's image at the same URL.
+    const scope = archived ? `${item.feed_id}:archive:${item.id}` : item.feed_id;
+    return sharedImages().get(scope, url, async (signal) => {
+        if (archived) {
+            const path = join(archiveDir(), archived.file_name);
+            try {
+                const buffer = await readFile(path);
+                if (buffer.length <= MAX_IMAGE_BYTES && detectImageType(buffer))
+                    return { buffer, path };
+            }
+            catch { /* Recover a missing archived file from its source. */ }
+        }
+        return fetchImage(url, MAX_IMAGE_BYTES, signal);
+    });
+}
+function archiveDir() {
+    return resolve(config.archivePath);
+}
+function srcAttribute(tag) {
+    const match = /\ssrc\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>]+))/i.exec(tag);
+    if (!match)
+        return null;
+    const value = match[1] ?? match[2] ?? match[3] ?? "";
+    const start = match.index + match[0].indexOf(value, match[0].indexOf("="));
+    return { value, start, end: start + value.length };
+}
+function resolveImageUrl(raw, baseUrl) {
+    try {
+        const url = new URL(decodeEntities(raw.trim()), baseUrl ?? undefined);
+        return url.protocol === "https:" || url.protocol === "http:" ? url.toString() : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Image URLs an article shows, in order, without tracking pixels. */
+export function articleImageUrls(html, baseUrl) {
+    const urls = new Set();
+    for (const [tag] of html.matchAll(/<img\b[^>]*>/gi)) {
+        if (/\swidth\s*=\s*["']?1["'\s>]/i.test(tag) && /\sheight\s*=\s*["']?1["'\s>]/i.test(tag))
+            continue;
+        const src = srcAttribute(tag);
+        const url = src && resolveImageUrl(src.value, baseUrl);
+        if (url)
+            urls.add(url);
+    }
+    return [...urls];
+}
+/** Replace the `src` of every image for which `replacement` knows a new address. */
+function rewriteImageSources(html, baseUrl, replacement) {
+    return html.replace(/<img\b[^>]*>/gi, (tag) => {
+        const src = srcAttribute(tag);
+        const url = src && resolveImageUrl(src.value, baseUrl);
+        const next = url ? replacement(url) : undefined;
+        return src && next ? `${tag.slice(0, src.start)}${next}${tag.slice(src.end)}` : tag;
+    });
+}
+/** Point archived images in article HTML at their local copies under `origin`. */
+export function rewriteArchivedImages(html, baseUrl, images, origin, apiBase = "/api") {
+    if (images.size === 0)
+        return html;
+    return rewriteImageSources(html, baseUrl, (url) => {
+        const id = images.get(url);
+        return id ? archivedImageUrl(origin, id, apiBase) : undefined;
+    });
+}
+/** Absolute, so the web app treats archived images like any other image URL. */
+export function archivedImageUrl(origin, imageId, apiBase = "/api") {
+    return `${origin.replace(/\/$/, "")}${apiBase}/archive/images/${imageId}`;
+}
+function hasBookmark(itemId) {
+    return db.prepare("SELECT user_id FROM item_bookmarks WHERE item_id = ? LIMIT 1").get(itemId)?.user_id;
+}
+/** Keep a saved article readable for good: fetch its full text and store its images locally. */
+export async function archiveItem(itemId) {
+    const userId = hasBookmark(itemId);
+    if (userId === undefined)
+        return;
+    // Respects per-feed full-text settings and consent walls; falls back to the feed content.
+    await loadFullText(userId, itemId).catch(() => undefined);
+    const item = findItemById(itemId);
+    if (!item)
+        return;
+    const html = item.full_content_html ?? item.content_html ?? "";
+    const heroUrl = item.image_url ? resolveImageUrl(item.image_url, item.link) : null;
+    const urls = [...new Set([...(heroUrl ? [heroUrl] : []), ...articleImageUrls(html, item.link)])].slice(0, MAX_IMAGES_PER_ARTICLE);
+    const known = new Set(db.prepare("SELECT source_url FROM archived_images WHERE item_id = ?").all(itemId).map((row) => row.source_url));
+    const insert = db.prepare("INSERT INTO archived_images (item_id, source_url, file_name, mime_type, byte_size) VALUES (?, ?, ?, ?, ?) ON CONFLICT (item_id, source_url) DO NOTHING");
+    mkdirSync(archiveDir(), { recursive: true });
+    for (const url of urls) {
+        if (imageCacheStopping)
+            return;
+        if (known.has(url))
+            continue;
+        try {
+            const image = await sharedImage(item, url);
+            if (image === "unsupported")
+                continue;
+            const { buffer } = image;
+            const type = detectImageType(buffer);
+            if (!type)
+                continue;
+            const fileName = `${itemId}-${createHash("sha256").update(url).digest("hex").slice(0, 16)}.${type.ext}`;
+            const destination = join(archiveDir(), fileName);
+            await storeArchivedImage(destination, image);
+            // The last bookmark or article may have disappeared while the image was loading.
+            if (!hasBookmark(itemId) || !findItemById(itemId)) {
+                unlinkSync(destination);
+                continue;
+            }
+            insert.run(itemId, url, fileName, type.mime, buffer.length);
+        }
+        catch (error) {
+            // Leave the durable bookmark pending so startup can finish it later.
+            if (error instanceof ImageCacheBusyError || imageCacheStopping)
+                return;
+            // A missing image should not stop the rest of the article from being archived.
+        }
+    }
+    if (!imageCacheStopping)
+        db.prepare("UPDATE items SET archived_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now') WHERE id = ?").run(itemId);
+}
+const queue = [];
+let draining = false;
+async function drain() {
+    if (draining)
+        return;
+    draining = true;
+    try {
+        while (queue.length > 0) {
+            const itemId = queue.shift();
+            await archiveItem(itemId).catch((error) => console.warn(`[archive] item ${itemId}:`, error));
+        }
+    }
+    finally {
+        draining = false;
+    }
+}
+/** Archive in the background, one article at a time, so saving stays instant. */
+export function scheduleArchive(itemId) {
+    if (!queue.includes(itemId))
+        queue.push(itemId);
+    void drain();
+}
+/** Catch up on saved articles that were never archived, e.g. saved before this feature. */
+export function scheduleMissingArchives() {
+    const rows = db.prepare("SELECT DISTINCT i.id FROM items i JOIN item_bookmarks b ON b.item_id = i.id WHERE i.archived_at IS NULL ORDER BY i.id").all();
+    rows.forEach((row) => scheduleArchive(row.id));
+    return rows.length;
+}
+/** Wait until queued archiving is done (used by tests and shutdown). */
+export async function archiveIdle() {
+    while (draining || queue.length > 0)
+        await new Promise((resolve) => setTimeout(resolve, 20));
+}
+/** Delete archived images of articles nobody has saved anymore, plus stray files. */
+export function pruneArchive() {
+    const stale = db.prepare("SELECT a.id, a.item_id, a.file_name FROM archived_images a WHERE NOT EXISTS (SELECT 1 FROM item_bookmarks b WHERE b.item_id = a.item_id)").all();
+    db.transaction(() => {
+        for (const row of stale) {
+            db.prepare("DELETE FROM archived_images WHERE id = ?").run(row.id);
+            db.prepare("UPDATE items SET archived_at = NULL WHERE id = ?").run(row.item_id);
+        }
+        db.prepare("UPDATE items SET archived_at = NULL WHERE archived_at IS NOT NULL AND id NOT IN (SELECT item_id FROM item_bookmarks)").run();
+    })();
+    let removed = 0;
+    let files;
+    try {
+        files = readdirSync(archiveDir());
+    }
+    catch {
+        return 0;
+    }
+    const kept = new Set(db.prepare("SELECT file_name FROM archived_images").all().map((row) => row.file_name));
+    for (const file of files) {
+        if (file.endsWith(".tmp") && FILE_NAME.test(file.slice(0, -4)) && !archiveWrites.has(join(archiveDir(), file))) {
+            try {
+                unlinkSync(join(archiveDir(), file));
+                removed++;
+            }
+            catch { /* Already gone. */ }
+            continue;
+        }
+        if (!FILE_NAME.test(file) || kept.has(file))
+            continue;
+        try {
+            unlinkSync(join(archiveDir(), file));
+            removed++;
+        }
+        catch {
+            // Already gone.
+        }
+    }
+    return removed;
+}
+/** Local copies for the given items, keyed by original URL. */
+export function archivedImagesFor(itemIds) {
+    const result = new Map();
+    if (itemIds.length === 0)
+        return result;
+    const rows = db.prepare(`SELECT id, item_id, source_url FROM archived_images WHERE item_id IN (${itemIds.map(() => "?").join(",")})`).all(...itemIds);
+    for (const row of rows) {
+        if (!result.has(row.item_id))
+            result.set(row.item_id, new Map());
+        result.get(row.item_id).set(row.source_url, row.id);
+    }
+    return result;
+}
+/** An archived image the user may see (they subscribe to or saved its article). */
+export function findArchivedImage(userId, imageId) {
+    const row = db.prepare("SELECT item_id, file_name, mime_type FROM archived_images WHERE id = ?").get(imageId);
+    if (!row || !canAccessItem(userId, row.item_id))
+        return null;
+    return { path: join(archiveDir(), row.file_name), mime: row.mime_type };
+}
+/** Swap image URLs of archived articles for their local copies before sending them to the browser. */
+export function withArchivedImages(items, origin, apiBase = "/api") {
+    const archived = archivedImagesFor(items.map((item) => item.id));
+    return items.map((item) => {
+        const images = archived.get(item.id);
+        if (!images)
+            return item;
+        const hero = item.image_url ? resolveImageUrl(item.image_url, item.link) : null;
+        return {
+            ...item,
+            image_url: hero && images.has(hero) ? archivedImageUrl(origin, images.get(hero), apiBase) : item.image_url,
+            content_html: item.content_html ? rewriteArchivedImages(item.content_html, item.link, images, origin, apiBase) : item.content_html,
+            full_content_html: item.full_content_html ? rewriteArchivedImages(item.full_content_html, item.link, images, origin, apiBase) : item.full_content_html,
+        };
+    });
+}
+/** Every image address an article shows: the lead image first, then those in the text. */
+export function itemImageUrls(item) {
+    const hero = item.image_url ? resolveImageUrl(item.image_url, item.link) : null;
+    return [...new Set([...(hero ? [hero] : []), ...articleImageUrls(item.full_content_html ?? "", item.link), ...articleImageUrls(item.content_html ?? "", item.link)])];
+}
+function proxiedImageUrl(origin, itemId, imageUrl, apiBase = "/api") {
+    return `${origin.replace(/\/$/, "")}${apiBase}/items/${itemId}/image?src=${encodeURIComponent(imageUrl).replace(/[!'()*]/g, (char) => `%${char.charCodeAt(0).toString(16).toUpperCase()}`)}`;
+}
+/**
+ * For offline copies: point the first images of articles that are not archived at an endpoint
+ * of this server, so the browser can store them without cross-origin requests.
+ */
+export function withProxiedImages(items, origin, apiBase = "/api") {
+    const own = `${origin.replace(/\/$/, "")}/api/`;
+    return items.map((item) => {
+        const urls = new Set(itemImageUrls(item).filter((url) => !url.startsWith(own)));
+        if (urls.size === 0)
+            return item;
+        const replace = (url) => (urls.has(url) ? proxiedImageUrl(origin, item.id, url, apiBase) : undefined);
+        const hero = item.image_url ? resolveImageUrl(item.image_url, item.link) : null;
+        return {
+            ...item,
+            image_url: hero && urls.has(hero) ? proxiedImageUrl(origin, item.id, hero, apiBase) : item.image_url,
+            content_html: item.content_html ? rewriteImageSources(item.content_html, item.link, replace) : item.content_html,
+            full_content_html: item.full_content_html ? rewriteImageSources(item.full_content_html, item.link, replace) : item.full_content_html,
+        };
+    });
+}
+/** Download one of an article's own images for the offline copy, or null when it is not one of them. */
+export async function fetchItemImage(userId, itemId, imageUrl) {
+    const item = findItemForUser(userId, itemId);
+    if (!item || !itemImageUrls(item).includes(imageUrl))
+        return "forbidden";
+    const image = await sharedImage(item, imageUrl);
+    // Access or the article's image list can change while a shared download is running.
+    const current = findItemForUser(userId, itemId);
+    if (!current || !itemImageUrls(current).includes(imageUrl))
+        return "forbidden";
+    return image;
+}
+//# sourceMappingURL=archive.js.map

package/server/dist/feeds/articleContent.js

@@ -0,0 +1,26 @@
+import { JSDOM } from "jsdom";
+import { decodeEntities } from "./text.js";
+/** Plain publisher content, shared by readers, search consumers and MCP. */
+export function articleText(html) {
+    if (!html)
+        return "";
+    const fragment = JSDOM.fragment(html);
+    fragment.querySelectorAll("script, style, noscript, nav, footer").forEach(node => node.remove());
+    fragment.querySelectorAll("p, div, br, li, h1, h2, h3, h4, blockquote").forEach(node => node.append(" "));
+    return (fragment.textContent ?? "").replace(/\s+/g, " ").trim();
+}
+export function contentMetadata(item) {
+    const source = item.full_content_html ? "reader" : item.content_html ? "feed" : "snippet";
+    return { revision: item.content_revision, source, status: item.extraction_status,
+        attemptedAt: item.extraction_attempted_at, retryAt: item.extraction_retry_at };
+}
+export function sourceText(item) {
+    return `${decodeEntities(item.title) ?? ""}\n${articleText(item.full_content_html || item.content_html) || decodeEntities(item.content_snippet) || ""}`.trim();
+}
+/** Prefer existing substantive publisher text over a shorter extracted teaser. */
+export function improvesContent(item, extracted) {
+    const candidate = articleText(extracted).length;
+    const existing = articleText(item.full_content_html || item.content_html).length;
+    return candidate >= 200 && candidate >= existing * 0.9;
+}
+//# sourceMappingURL=articleContent.js.map

package/server/dist/feeds/cleanup.js

@@ -0,0 +1,179 @@
+import { existsSync, statSync } from "node:fs";
+import cron from "node-cron";
+import { db } from "../db/index.js";
+import { config } from "../config.js";
+import { removeUnusedFeeds } from "./repository.js";
+import { pruneArchive } from "./archive.js";
+import { pruneChangeLog } from "../sync/changeLog.js";
+export function getDatabaseFileSizeBytes() {
+    let size = 0;
+    for (const path of [config.databasePath, `${config.databasePath}-wal`, `${config.databasePath}-shm`]) {
+        if (existsSync(path)) {
+            try {
+                size += statSync(path).size;
+            }
+            catch {
+                // ignore if concurrently removed
+            }
+        }
+    }
+    return size;
+}
+export function getDatabaseStats() {
+    const totalItemsRow = db.prepare("SELECT COUNT(*) AS count FROM items").get();
+    const readItemsRow = db.prepare("SELECT COUNT(DISTINCT item_id) AS count FROM item_reads").get();
+    const feedsRow = db.prepare("SELECT COUNT(*) AS count FROM feeds").get();
+    const oldestRow = db.prepare("SELECT MIN(COALESCE(published_at, created_at)) AS oldest FROM items").get();
+    return {
+        totalItems: totalItemsRow.count,
+        readItems: readItemsRow.count,
+        feedsCount: feedsRow.count,
+        oldestItemDate: oldestRow.oldest,
+        databaseSizeBytes: getDatabaseFileSizeBytes(),
+    };
+}
+export function getRetentionSettings() {
+    try {
+        const rows = db.prepare("SELECT key, value FROM system_settings").all();
+        const map = new Map(rows.map((r) => [r.key, r.value]));
+        return {
+            retentionReadDays: Number(map.get("retention_read_days") ?? config.retentionReadDays),
+            retentionMaxDays: Number(map.get("retention_max_days") ?? config.retentionMaxDays),
+            retentionMaxItemsPerFeed: Number(map.get("retention_max_items_per_feed") ?? config.retentionMaxItemsPerFeed),
+            autoCleanupEnabled: (map.get("auto_cleanup_enabled") ?? String(config.autoCleanupEnabled)) === "true",
+        };
+    }
+    catch {
+        return {
+            retentionReadDays: config.retentionReadDays,
+            retentionMaxDays: config.retentionMaxDays,
+            retentionMaxItemsPerFeed: config.retentionMaxItemsPerFeed,
+            autoCleanupEnabled: config.autoCleanupEnabled,
+        };
+    }
+}
+export function updateRetentionSettings(settings) {
+    const updateStmt = db.prepare(`INSERT INTO system_settings (key, value, updated_at)
+     VALUES (?, ?, strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+     ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`);
+    const apply = db.transaction(() => {
+        if (settings.retentionReadDays !== undefined) {
+            updateStmt.run("retention_read_days", String(Math.max(0, settings.retentionReadDays)));
+        }
+        if (settings.retentionMaxDays !== undefined) {
+            updateStmt.run("retention_max_days", String(Math.max(0, settings.retentionMaxDays)));
+        }
+        if (settings.retentionMaxItemsPerFeed !== undefined) {
+            updateStmt.run("retention_max_items_per_feed", String(Math.max(0, settings.retentionMaxItemsPerFeed)));
+        }
+        if (settings.autoCleanupEnabled !== undefined) {
+            updateStmt.run("auto_cleanup_enabled", String(settings.autoCleanupEnabled));
+        }
+    });
+    apply();
+    return getRetentionSettings();
+}
+export function runCleanup(custom) {
+    const settings = {
+        ...getRetentionSettings(),
+        ...custom,
+    };
+    const sizeBefore = getDatabaseFileSizeBytes();
+    let deletedReadItems = 0;
+    let deletedOldItems = 0;
+    let deletedPerFeedExcess = 0;
+    // 1. Delete read items older than retentionReadDays (excluding bookmarked items and items with notes)
+    if (settings.retentionReadDays > 0) {
+        const res = db.prepare(`DELETE FROM items
+       WHERE id IN (
+         SELECT i.id
+         FROM items i
+         WHERE i.id NOT IN (SELECT item_id FROM item_bookmarks)
+           AND i.id NOT IN (SELECT item_id FROM item_notes)
+           AND i.feed_id NOT IN (SELECT id FROM feeds WHERE is_system_inbox = 1)
+           AND NOT EXISTS (SELECT 1 FROM editions e, json_each(e.item_ids) selected
+             WHERE selected.value = i.id AND e.status = 'active' AND julianday(e.expires_at) > julianday('now'))
+           AND i.id IN (SELECT item_id FROM item_reads)
+           AND NOT EXISTS (
+             SELECT 1 FROM subscriptions s
+             WHERE s.feed_id = i.feed_id
+               AND NOT EXISTS (SELECT 1 FROM item_reads r WHERE r.item_id = i.id AND r.user_id = s.user_id)
+           )
+           AND COALESCE(julianday(i.published_at), julianday(i.created_at)) <= julianday('now', '-' || ? || ' days')
+       )`).run(settings.retentionReadDays);
+        deletedReadItems = res.changes;
+    }
+    // 2. Delete all items older than retentionMaxDays (excluding bookmarked items and items with notes)
+    if (settings.retentionMaxDays > 0) {
+        const res = db.prepare(`DELETE FROM items
+       WHERE id NOT IN (SELECT item_id FROM item_bookmarks)
+         AND id NOT IN (SELECT item_id FROM item_notes)
+         AND feed_id NOT IN (SELECT id FROM feeds WHERE is_system_inbox = 1)
+         AND NOT EXISTS (SELECT 1 FROM editions e, json_each(e.item_ids) selected
+           WHERE selected.value = items.id AND e.status = 'active' AND julianday(e.expires_at) > julianday('now'))
+         AND COALESCE(julianday(published_at), julianday(created_at)) <= julianday('now', '-' || ? || ' days')`).run(settings.retentionMaxDays);
+        deletedOldItems = res.changes;
+    }
+    // 3. Delete items exceeding retentionMaxItemsPerFeed (excluding bookmarked items and items with notes)
+    if (settings.retentionMaxItemsPerFeed > 0) {
+        const res = db.prepare(`DELETE FROM items
+       WHERE id NOT IN (SELECT item_id FROM item_bookmarks)
+         AND id NOT IN (SELECT item_id FROM item_notes)
+         AND feed_id NOT IN (SELECT id FROM feeds WHERE is_system_inbox = 1)
+         AND NOT EXISTS (SELECT 1 FROM editions e, json_each(e.item_ids) selected
+           WHERE selected.value = items.id AND e.status = 'active' AND julianday(e.expires_at) > julianday('now'))
+         AND id IN (
+           SELECT id FROM (
+             SELECT id, ROW_NUMBER() OVER (
+               PARTITION BY feed_id
+               ORDER BY COALESCE(julianday(published_at), julianday(created_at)) DESC, id DESC
+             ) as rn
+             FROM items
+           )
+           WHERE rn > ?
+         )`).run(settings.retentionMaxItemsPerFeed);
+        deletedPerFeedExcess = res.changes;
+    }
+    // Feeds kept only for saved articles go once nothing of them is saved anymore.
+    removeUnusedFeeds();
+    pruneArchive();
+    pruneChangeLog();
+    const totalDeleted = deletedReadItems + deletedOldItems + deletedPerFeedExcess;
+    // Optimize query planning; rebuild storage only when this run freed rows.
+    db.exec("PRAGMA optimize;");
+    if (totalDeleted > 0) {
+        try {
+            db.exec("VACUUM;");
+        }
+        catch (err) {
+            console.warn("[cleanup] VACUUM skipped or could not run:", err);
+        }
+    }
+    const sizeAfter = getDatabaseFileSizeBytes();
+    return {
+        deletedReadItems,
+        deletedOldItems,
+        deletedPerFeedExcess,
+        totalDeleted,
+        sizeBefore,
+        sizeAfter,
+    };
+}
+export function startCleanupScheduler() {
+    // Run daily at 03:00 AM server time
+    cron.schedule("0 3 * * *", () => {
+        const settings = getRetentionSettings();
+        if (!settings.autoCleanupEnabled) {
+            return;
+        }
+        try {
+            console.log("[cleanup] running daily automated housekeeping...");
+            const result = runCleanup(settings);
+            console.log(`[cleanup] automated housekeeping complete: ${result.totalDeleted} items deleted (read: ${result.deletedReadItems}, max age: ${result.deletedOldItems}, feed cap: ${result.deletedPerFeedExcess}). Database size: ${(result.sizeBefore / 1024 / 1024).toFixed(2)} MB -> ${(result.sizeAfter / 1024 / 1024).toFixed(2)} MB`);
+        }
+        catch (err) {
+            console.error("[cleanup] error during automated housekeeping:", err);
+        }
+    });
+}
+//# sourceMappingURL=cleanup.js.map

package/server/dist/feeds/dates.js

@@ -0,0 +1,21 @@
+// Nothing on the web is older than this, so an earlier date is a placeholder such as 1970-01-01.
+const EARLIEST_PLAUSIBLE = Date.UTC(1991, 0, 1);
+// Feeds may announce an article a little ahead of time or in another zone, but not by years.
+const MAX_AHEAD_MS = 24 * 60 * 60 * 1000;
+/**
+ * The publish date of a feed entry as an ISO timestamp, or null when the feed gives none we can trust: missing,
+ * not a date ("gestern", localised weekday names), a placeholder in the past or a date far in the future. Null makes
+ * the app use the time it stored the article, so the article lists, ages and is cleaned up like any other.
+ */
+export function normalizePublishedAt(value, now = Date.now()) {
+    if (typeof value !== "string")
+        return null;
+    const text = value.trim();
+    if (!text)
+        return null;
+    const time = Date.parse(text);
+    if (!Number.isFinite(time) || time < EARLIEST_PLAUSIBLE || time > now + MAX_AHEAD_MS)
+        return null;
+    return new Date(time).toISOString();
+}
+//# sourceMappingURL=dates.js.map