feedkeeper 0.0.0-stage → 0.23.0

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(i.published_at, i.created_at) <= strftime('%Y-%m-%dT%H:%M:%fZ', '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(published_at, created_at) <= strftime('%Y-%m-%dT%H:%M:%fZ', '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(published_at, 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/discovery.js

@@ -0,0 +1,153 @@
+import Parser from "rss-parser";
+import { fetchFeed } from "./fetcher.js";
+import { assertPublicHttpUrl } from "./ssrfGuard.js";
+import { decodeEntities, plainTitle } from "./text.js";
+const rssParser = new Parser();
+// Common alternate feed types found in HTML <head>
+const FEED_MIME_TYPES = [
+    "application/rss+xml",
+    "application/atom+xml",
+    "text/xml",
+    "application/xml",
+];
+const MAX_PROBES = 15;
+const COMMON_PATHS = ["/feed", "/rss.xml", "/atom.xml", "/feed.xml", "/index.xml", "/rss", "/rss.php?feed=RSS2.0", "/rss.php?feed=ATOM1.0"];
+// Feed-looking URLs anywhere in a page, including JSON embedded in attributes.
+const FEED_URL_IN_TEXT = /https?:\/\/[^\s"'<>\\]+?(?:\.rss|\.atom|\/feed\/?|\/(?:rss|atom|feed)\.xml)(?=["'\s<>\\]|$)/gi;
+function sameUrl(a, b) {
+    const normalize = (value) => {
+        try {
+            const url = new URL(value);
+            url.hash = "";
+            return url.toString().replace(/\/$/, "");
+        }
+        catch {
+            return value;
+        }
+    };
+    return normalize(a) === normalize(b);
+}
+async function parseFeedAt(url) {
+    const fetched = await fetchFeed(url);
+    const finalUrl = fetched.finalUrl || url;
+    try {
+        const parsed = await rssParser.parseString(fetched.body);
+        if (parsed.items && (parsed.title || parsed.description || parsed.items.length > 0)) {
+            return { feed: { url: finalUrl, title: plainTitle(parsed.title) ?? null, type: "application/rss+xml" }, html: null, finalUrl };
+        }
+    }
+    catch {
+        // Not a feed; the caller may look for feed links in the HTML instead.
+    }
+    return { feed: null, html: fetched.body, finalUrl };
+}
+/**
+ * Keep only candidates that really are feeds. Sites sometimes announce their own
+ * homepage as RSS, so self-references are dropped and every candidate is fetched.
+ */
+async function keepRealFeeds(candidates, pageUrl) {
+    const toProbe = candidates.filter((candidate) => !sameUrl(candidate.url, pageUrl)).slice(0, MAX_PROBES);
+    const probed = await Promise.all(toProbe.map(async (candidate) => {
+        try {
+            const { feed } = await parseFeedAt(candidate.url);
+            return feed ? { ...feed, title: candidate.title ?? feed.title } : null;
+        }
+        catch {
+            return null;
+        }
+    }));
+    const seen = new Set();
+    return probed.filter((feed) => {
+        if (!feed || seen.has(feed.url))
+            return false;
+        seen.add(feed.url);
+        return true;
+    });
+}
+/**
+ * Given a URL, determines if it is already a direct RSS/Atom feed
+ * or if it is an HTML page that links to one or more feeds (auto-discovery).
+ */
+export async function discoverFeeds(inputUrl) {
+    const validated = await assertPublicHttpUrl(inputUrl);
+    const targetUrl = validated.toString();
+    // 1. The URL is already a feed.
+    const page = await parseFeedAt(targetUrl);
+    if (page.feed)
+        return [page.feed];
+    if (!page.html)
+        return [];
+    // 2. Feeds announced or linked on the page.
+    const fromPage = await keepRealFeeds(extractFeedsFromHtml(page.html, page.finalUrl), page.finalUrl);
+    if (fromPage.length > 0)
+        return fromPage;
+    // 3. Common feed paths; some lead to an overview page that lists the site's feeds.
+    for (const path of COMMON_PATHS) {
+        try {
+            const candidateUrl = new URL(path, page.finalUrl).toString();
+            if (sameUrl(candidateUrl, targetUrl))
+                continue;
+            const candidate = await parseFeedAt(candidateUrl);
+            if (candidate.feed)
+                return [candidate.feed];
+            if (candidate.html && !sameUrl(candidate.finalUrl, page.finalUrl)) {
+                const listed = await keepRealFeeds(extractFeedsFromHtml(candidate.html, candidate.finalUrl), candidate.finalUrl);
+                if (listed.length > 0)
+                    return listed;
+            }
+        }
+        catch {
+            // Try the next path.
+        }
+    }
+    return [];
+}
+/**
+ * Collect feed candidates from an HTML page: `<link rel="alternate">` tags first,
+ * then feed-like links, then feed URLs mentioned in the page text. Candidates are
+ * unverified; discoverFeeds checks them before use.
+ */
+export function extractFeedsFromHtml(html, baseUrl) {
+    const results = [];
+    const seenUrls = new Set();
+    const add = (href, title, type) => {
+        try {
+            const resolved = new URL(href, baseUrl).toString();
+            if (!/^https?:/i.test(resolved) || seenUrls.has(resolved))
+                return;
+            seenUrls.add(resolved);
+            results.push({ url: resolved, title, type });
+        }
+        catch {
+            // Invalid URL, skip.
+        }
+    };
+    for (const match of html.matchAll(/<link\b([^>]*)\/?>/gi)) {
+        const attrs = match[1];
+        const rel = getAttr(attrs, "rel")?.toLowerCase();
+        const type = getAttr(attrs, "type")?.toLowerCase();
+        const href = getAttr(attrs, "href");
+        const title = getAttr(attrs, "title");
+        if (href && type && rel?.split(/\s+/).includes("alternate") && FEED_MIME_TYPES.includes(type)) {
+            add(href, title ? decodeEntities(title.trim()) : null, type);
+        }
+    }
+    for (const match of html.matchAll(/<a\b([^>]*href=["']([^"']+)["'][^>]*)>(.*?)<\/a>/gis)) {
+        const href = match[2];
+        if (href.endsWith("/feed") || href.endsWith(".rss") || href.endsWith(".xml") || href.includes("/rss/")) {
+            add(href, decodeEntities(match[3].replace(/<[^>]+>/g, "").trim()) || null, "application/rss+xml");
+        }
+    }
+    for (const match of decodeEntities(html).matchAll(FEED_URL_IN_TEXT)) {
+        add(match[0], null, "application/rss+xml");
+    }
+    return results;
+}
+function getAttr(attrsStr, attrName) {
+    const regex = new RegExp(`\\b${attrName}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|([^\\s>]+))`, "i");
+    const match = regex.exec(attrsStr);
+    if (!match)
+        return null;
+    return match[1] ?? match[2] ?? match[3] ?? null;
+}
+//# sourceMappingURL=discovery.js.map

package/server/dist/feeds/extractor.js

@@ -0,0 +1,208 @@
+import { Readability } from "@mozilla/readability";
+import { JSDOM } from "jsdom";
+import { fetch as undiciFetch } from "undici";
+import { assertPublicHttpUrl, createPublicDispatcher, SsrfBlockedError } from "./ssrfGuard.js";
+import { APP_VERSION } from "../version.js";
+const defaultFetch = undiciFetch;
+const CONSENT_SELECTORS = [
+    "#onetrust-consent-sdk",
+    "#cmpbox",
+    "#usercentrics-root",
+    "[id*='sp_message_container']",
+    "[class*='cookie-banner']",
+    "[class*='cookie-consent']",
+    "[class*='consent-banner']",
+    "[id*='cookie-notice']",
+    "[id*='cookie-banner']",
+    ".qc-cmp2-container",
+    "#didomi-host",
+    "dialog[open]",
+    ".cookie-wall",
+    ".consent-wall",
+    "[data-nosnippet]",
+];
+function cleanConsentDom(doc) {
+    for (const sel of CONSENT_SELECTORS) {
+        try {
+            doc.querySelectorAll(sel).forEach((el) => el.remove());
+        }
+        catch {
+            // ignore invalid selector in edge environments
+        }
+    }
+}
+/**
+ * Checks if a given URL or extracted HTML/text is a cookie / consent wall rather than article content.
+ */
+export function isConsentContent(finalUrl, html, title, text) {
+    if (/\/zustimmung[/?]/i.test(finalUrl) ||
+        /\/consent[/?]/i.test(finalUrl) ||
+        /\/cookie-wall/i.test(finalUrl) ||
+        /\/pur-abo[/?]/i.test(finalUrl) ||
+        /\/cmp[/?]/i.test(finalUrl) ||
+        /\/privacy-wall/i.test(finalUrl)) {
+        return true;
+    }
+    const combined = `${title || ""} ${text || ""} ${html}`.toLowerCase();
+    const strongSignatures = [
+        "cookies zustimmen",
+        "nutzung aller cookies",
+        "tracking zustimmen",
+        "einwilligung verwalten",
+        "werbung und tracking, indem sie",
+        "zustimmen & weiter",
+        "bevor sie fortfahren",
+        "accept all cookies",
+        "cookie-einstellungen",
+        "alle cookies akzeptieren",
+        "cookies akzeptieren",
+        "we value your privacy",
+    ];
+    const headText = `${title || ""} ${text || ""}`.toLowerCase().slice(0, 600);
+    const hits = strongSignatures.filter(sig => combined.includes(sig));
+    if (hits.length === 0)
+        return false;
+    const heading = (title || "").toLowerCase();
+    if (strongSignatures.some(sig => heading.includes(sig)))
+        return true;
+    return (text || "").length < 1200 && hits.length >= 2 && hits.some(sig => headText.includes(sig));
+}
+/**
+ * Checks cached HTML to see if it was a saved consent banner instead of real article content.
+ */
+export function isCachedConsentSnippet(html) {
+    return isConsentContent("", html, "", html.replace(/<[^>]+>/g, " "));
+}
+// Browser-like so article pages render normally, but identifies FeedKeeper honestly.
+const FETCH_USER_AGENT = `Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/128.0.0.0 Safari/537.36 FeedKeeper/${APP_VERSION}`;
+const FETCH_TIMEOUT_MS = 12_000;
+const MAX_REDIRECTS = 5;
+class ArticleHttpError extends Error {
+    status;
+    constructor(status) {
+        super("article_http_error");
+        this.status = status;
+    }
+}
+const MAX_HTML_BYTES = 2 * 1024 * 1024;
+function stripHeavyTags(html) {
+    return html
+        .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, "")
+        .replace(/<style\b[^<]*(?:(?!<\/style>)<[^<]*)*<\/style>/gi, "")
+        .replace(/<svg\b[^<]*(?:(?!<\/svg>)<[^<]*)*<\/svg>/gi, "")
+        .replace(/<iframe\b[^<]*(?:(?!<\/iframe>)<[^<]*)*<\/iframe>/gi, "")
+        .replace(/<noscript\b[^<]*(?:(?!<\/noscript>)<[^<]*)*<\/noscript>/gi, "");
+}
+async function fetchArticleHtml(rawUrl, signal, dispatcher, fetchImpl) {
+    let currentUrl = rawUrl;
+    for (let redirects = 0; redirects <= MAX_REDIRECTS; redirects++) {
+        const safeUrl = await assertPublicHttpUrl(currentUrl);
+        const response = await fetchImpl(safeUrl, {
+            signal,
+            headers: {
+                "User-Agent": FETCH_USER_AGENT,
+                Accept: "text/html,application/xhtml+xml;q=0.9,*/*;q=0.8",
+                // Article URLs already point to one language; don't prefer any locale.
+                "Accept-Language": "*",
+                "Cache-Control": "no-cache",
+            },
+            redirect: "manual",
+            dispatcher,
+        });
+        if (response.status >= 300 && response.status < 400) {
+            const location = response.headers.get("location");
+            if (!location)
+                return null;
+            await response.body?.cancel();
+            currentUrl = new URL(location, safeUrl).toString();
+            continue;
+        }
+        if (!response.ok) {
+            await response.body?.cancel();
+            throw new ArticleHttpError(response.status);
+        }
+        const contentLength = Number(response.headers.get("content-length"));
+        if (contentLength > MAX_HTML_BYTES)
+            return null;
+        const reader = response.body?.getReader();
+        if (!reader)
+            return null;
+        const chunks = [];
+        let total = 0;
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            total += value.byteLength;
+            if (total > MAX_HTML_BYTES) {
+                await reader.cancel();
+                return null;
+            }
+            chunks.push(value);
+        }
+        const html = new TextDecoder().decode(Buffer.concat(chunks.map((chunk) => Buffer.from(chunk))));
+        return { html, url: safeUrl.toString() };
+    }
+    return null;
+}
+export async function extractArticleFromUrl(rawUrl, fetchImpl = defaultFetch) {
+    const result = await extractArticle(rawUrl, fetchImpl);
+    return result.status === "ok" ? result.article : null;
+}
+/** Like extractArticleFromUrl, but reports whether the site answered with a consent wall. */
+export async function extractArticle(rawUrl, fetchImpl = defaultFetch) {
+    const safeUrl = await assertPublicHttpUrl(rawUrl);
+    const dispatcher = createPublicDispatcher();
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    try {
+        const fetched = await fetchArticleHtml(safeUrl.toString(), controller.signal, dispatcher, fetchImpl);
+        if (!fetched)
+            return { status: "failed" };
+        const cleanedHtml = stripHeavyTags(fetched.html);
+        const dom = new JSDOM(cleanedHtml, { url: fetched.url });
+        let parsed;
+        try {
+            const paywall = /"isAccessibleForFree"\s*:\s*(?:false|"false")/i.test(fetched.html);
+            cleanConsentDom(dom.window.document);
+            parsed = new Readability(dom.window.document, { charThreshold: 60 }).parse();
+            if (isConsentContent(fetched.url, parsed?.content ?? fetched.html, parsed?.title, parsed?.textContent)) {
+                return { status: "consent_wall" };
+            }
+            if (paywall || ((parsed?.textContent?.length ?? 0) < 2500 && /(?:subscribe to (?:continue|read)|sign in to (?:continue|read)|abonnieren und weiterlesen|nur für abonnenten|jetzt abonnieren.{0,40}weiterlesen)/i.test(parsed?.textContent ?? "")))
+                return { status: "paywall" };
+            if (!parsed?.content)
+                return { status: "failed" };
+        }
+        finally {
+            dom.window.close();
+        }
+        return {
+            status: (parsed.textContent?.trim().length ?? 0) < 200 ? "partial" : "ok",
+            article: {
+                title: parsed.title || null,
+                byline: parsed.byline || null,
+                contentHtml: parsed.content,
+                textContent: parsed.textContent || "",
+                excerpt: parsed.excerpt || null,
+                siteName: parsed.siteName || null,
+            },
+        };
+    }
+    catch (error) {
+        if (error instanceof SsrfBlockedError)
+            throw error;
+        if (controller.signal.aborted)
+            return { status: "timeout" };
+        if (error instanceof ArticleHttpError && [401, 402].includes(error.status))
+            return { status: "paywall" };
+        if (error instanceof ArticleHttpError && [403, 429, 503].includes(error.status))
+            return { status: "bot_blocked" };
+        return { status: "failed" };
+    }
+    finally {
+        clearTimeout(timeout);
+        dispatcher.destroy();
+    }
+}
+//# sourceMappingURL=extractor.js.map