@iflow-mcp/jakeliume-webpeel 0.22.0

package/dist/core/content-pruner.js

@@ -0,0 +1,425 @@
+/**
+ * Content Density Pruner
+ *
+ * Two-pass pruning to reduce HTML before markdown conversion:
+ *
+ *   Pass 1 — Semantic removal: strip elements whose tag or class/id clearly
+ *            mark them as page chrome (nav, footer, sidebar, cookie banners, ads).
+ *
+ *   Pass 2 — Density scoring: score remaining block elements by text density,
+ *            link density, tag importance, and word count. Remove low-scorers.
+ *
+ * Inspired by Crawl4AI's PruningContentFilter — targets 40-60% token savings.
+ */
+import * as cheerio from 'cheerio';
+// -----------------------------------------------------------------------
+// Pass 1 — Semantic removal: tags and class/id patterns
+// -----------------------------------------------------------------------
+/** Tags that are almost always page chrome, not article content. */
+const CHROME_TAGS = new Set([
+    'nav', 'footer', 'aside', 'noscript',
+]);
+/**
+ * Class/id patterns that indicate page chrome.
+ * Tested against lowercased class/id strings.
+ */
+const CHROME_PATTERNS = [
+    /\bsidebar\b/,
+    /\bcookie/,
+    /\bbanner\b/,
+    /\b(ad|ads|advert)\b/,
+    /\bpopup\b/,
+    /\bmodal\b/,
+    /\boverlay\b/,
+    /\bsocial/,
+    /\bshare\b/,
+    /\bbreadcrumb/,
+    /\bskip-?link/,
+    /\bfootnote/,
+    /\brelated-?(post|article)/,
+    /\bnewsletter/,
+    /\bsubscri/,
+    /\bcomment/,
+    /\b(sign-?up|sign-?in|log-?in)\b/,
+    /\btoc\b/,
+    /\btable-?of-?contents\b/,
+    /\bgdpr\b/,
+    /\bconsent\b/,
+    // Q&A sites (Stack Overflow, StackExchange)
+    /\bvote\b/,
+    /\bpost-?menu/,
+    /\bjs-vote/,
+    /\buser-?card/,
+    /\buser-?info/,
+    /\bpost-?tag/,
+    /\bquestion-?stats/,
+    // Social/sharing UI
+    /\bshare-?(button|link|panel|menu|bar)/,
+    /\bfollow-?button/,
+    /\breaction/,
+    /\blike-?button/,
+    /\bupvote/,
+    /\bdownvote/,
+    // Edit/action UI
+    /\bedit-?(link|button|post)/,
+    /\breport-?(link|button)/,
+    /\bflag-?(link|button)/,
+    // Generic site chrome
+    /\btop-?bar/,
+    /\bsite-?header/,
+    /\bpage-?header/,
+    /\bsticky-?header/,
+    /\bnotice\b/,
+    /\balert\b/,
+    /\btoast\b/,
+    /\bsnackbar/,
+    /\bbottom-?bar/,
+    /\bfloating/,
+    /\bfixed-?bottom/,
+    /\bback-?to-?top/,
+    // Interactive UI elements (non-content)
+    /\bquiz\b/,
+    /\bquestionnaire\b/,
+    /\btoggle(?!-content|-body|-text)\b/,
+    /\bcarousel\b/,
+    /\baccordion(?!-content|-body|-text)\b/,
+    /\bstepper\b/,
+    /\bpagination\b/,
+    /\btabs-?(?:list|nav|bar)\b/,
+    /\bcookie-?(?:banner|bar|notice|consent|popup)\b/,
+];
+/**
+ * Tags we never remove (they likely wrap main content).
+ * We recurse into them but never strip the element itself.
+ */
+const PROTECTED_TAGS = new Set(['main', 'article', 'body']);
+/**
+ * Tags we never remove during density scoring (Pass 2).
+ * Headings, paragraphs, and semantic content elements should survive
+ * even if they're small — they carry essential meaning.
+ */
+const DENSITY_SAFE_TAGS = new Set([
+    'h1', 'h2', 'h3', 'h4', 'h5', 'h6',
+    'p', 'pre', 'code', 'blockquote', 'figcaption',
+    'main', 'article', 'body',
+    // Table structural elements — pruner must not remove these or Turndown GFM
+    // can't convert tables and falls back to raw HTML output.
+    'table', 'thead', 'tbody', 'tfoot', 'tr', 'th', 'td',
+]);
+/**
+ * Class/id patterns that protect an element from removal.
+ */
+const CONTENT_PATTERNS = [
+    /\barticle/,
+    /\bpost-?content/,
+    /\bentry-?content/,
+    /\bmain-?content/,
+    /\bstory/,
+    /\bblog/,
+    /\bpage-?content/,
+    /\bcontent-?area/,
+    // Wikipedia/MediaWiki data tables — always content, never chrome
+    /\bwikitable\b/,
+    /\bmw-parser-output\b/,
+];
+function isChromeBySemantic(el, $) {
+    const tagName = el.tagName?.toLowerCase() ?? '';
+    if (CHROME_TAGS.has(tagName))
+        return true;
+    const cls = ($(el).attr('class') ?? '').toLowerCase();
+    const id = ($(el).attr('id') ?? '').toLowerCase();
+    const combined = cls + ' ' + id;
+    // Don't remove if it matches a content pattern
+    for (const p of CONTENT_PATTERNS) {
+        if (p.test(combined))
+            return false;
+    }
+    for (const p of CHROME_PATTERNS) {
+        if (p.test(combined))
+            return true;
+    }
+    // Role attribute
+    const role = ($(el).attr('role') ?? '').toLowerCase();
+    if (['navigation', 'banner', 'complementary', 'contentinfo', 'search'].includes(role)) {
+        return true;
+    }
+    return false;
+}
+// -----------------------------------------------------------------------
+// Pass 2 — Density scoring
+// -----------------------------------------------------------------------
+/** Tag importance scores for density scoring (-2 to +3) */
+const TAG_IMPORTANCE = {
+    article: 3, main: 3,
+    p: 2, h1: 2, h2: 2, h3: 2, h4: 2, h5: 2, h6: 2,
+    blockquote: 2, pre: 2, code: 2, figure: 2, figcaption: 2,
+    section: 1, td: 1, th: 1, li: 1, dd: 1, dt: 1,
+    div: 0, span: 0, table: 0, ul: 0, ol: 0, dl: 0,
+    aside: -1, header: -1, form: -1,
+    nav: -2, footer: -2,
+};
+function normalizeTagScore(rawScore) {
+    return (rawScore + 2) / 5; // -2..+3 → 0..1
+}
+/**
+ * Collect scoreable blocks from a DOM tree.
+ *
+ * Strategy: walk the tree top-down. For each element:
+ *   - If it's a "leaf-ish" block (< threshold size), score it as one unit.
+ *   - If it's large and a wrapper (div/section/table), recurse into children.
+ *   - Protected elements are always recursed.
+ *
+ * This finds the right granularity: not scoring a 200KB wrapper div,
+ * but scoring the divs/sections/p's nested 3-4 levels deep that carry
+ * actual content or chrome.
+ */
+function collectBlocks($, parent, blocks, maxLeafSize) {
+    const children = 'children' in parent ? parent.children : [];
+    for (const child of children) {
+        if (child.type !== 'tag')
+            continue;
+        const el = child;
+        const tagName = el.tagName?.toLowerCase() ?? '';
+        // Skip script/style
+        if (tagName === 'script' || tagName === 'style' || tagName === 'link' || tagName === 'meta')
+            continue;
+        const $el = $(el);
+        const outerHtml = $.html($el) ?? '';
+        const htmlLen = outerHtml.length;
+        // Skip extremely tiny elements (bare tags like <br>)
+        if (htmlLen < 10)
+            continue;
+        const isProtected = PROTECTED_TAGS.has(tagName);
+        const isWrapper = ['div', 'section', 'table', 'tbody', 'thead', 'tr',
+            'center', 'details', 'summary'].includes(tagName);
+        if (isProtected || (isWrapper && htmlLen > maxLeafSize)) {
+            // Too large or protected — recurse deeper
+            collectBlocks($, el, blocks, maxLeafSize);
+        }
+        else if (htmlLen > 0) {
+            // Score this element
+            const clone = $el.clone();
+            clone.find('script, style, noscript, svg, path').remove();
+            const visibleText = clone.text() ?? '';
+            const visibleTextLen = visibleText.trim().length;
+            const textDensity = Math.min(visibleTextLen / Math.max(htmlLen, 1), 1.0);
+            let linkTextLen = 0;
+            $el.find('a').each((_i, a) => {
+                linkTextLen += ($(a).text() ?? '').trim().length;
+            });
+            const linkDensity = visibleTextLen > 0
+                ? Math.min(linkTextLen / visibleTextLen, 1.0)
+                : 0;
+            const rawTagScore = TAG_IMPORTANCE[tagName] ?? 0;
+            const normalizedTag = normalizeTagScore(rawTagScore);
+            const words = visibleText.trim().split(/\s+/).filter(w => w.length > 0);
+            const wordBonus = words.length > 0
+                ? Math.min(Math.log(words.length + 1) / Math.log(1000), 1.0)
+                : 0;
+            const score = (textDensity * 0.35 +
+                (1 - linkDensity) * 0.25 +
+                normalizedTag * 0.2 +
+                wordBonus * 0.1 +
+                0.1 // baseline position score (removed position bias — not useful for deep nesting)
+            );
+            blocks.push({
+                element: el,
+                tagName,
+                htmlLength: htmlLen,
+                visibleText,
+                score,
+            });
+        }
+    }
+}
+// -----------------------------------------------------------------------
+// Main export
+// -----------------------------------------------------------------------
+/**
+ * Prune low-value HTML blocks using two-pass approach:
+ *   1. Semantic tag/class removal
+ *   2. Density scoring of remaining blocks
+ *
+ * @param html - Raw HTML to prune
+ * @param options - Pruning configuration
+ * @returns Pruned HTML with stats
+ */
+export function pruneContent(html, options = {}) {
+    const { threshold = 0.3, minWords = 3, dynamic = true, } = options;
+    const originalLength = html.length;
+    if (!html.trim()) {
+        return { html, nodesRemoved: 0, reductionPercent: 0 };
+    }
+    // =====================================================================
+    // Pass 0: Regex pre-pass — strip obvious chrome BEFORE cheerio parse
+    // =====================================================================
+    // For large HTML (> 20KB), a fast regex pass removes top-level nav/footer/
+    // aside/header blocks before we load into cheerio, saving DOM parse time.
+    // Only applies to simple self-contained elements (no nesting concerns since
+    // these are structural tags that rarely wrap article content).
+    if (html.length > 20000) {
+        // Remove <nav>…</nav>, <footer>…</footer>, <aside>…</aside>
+        // Use a non-greedy match with dotAll flag; stop at the matching close tag.
+        html = html
+            .replace(/<nav(\s[^>]*)?>[\s\S]*?<\/nav>/gi, '')
+            .replace(/<footer(\s[^>]*)?>[\s\S]*?<\/footer>/gi, '')
+            .replace(/<aside(\s[^>]*)?>[\s\S]*?<\/aside>/gi, '');
+        // No safe way to strip noise <div>s by regex (nested divs break simple patterns).
+        // Cheerio's semantic pass handles them reliably in Pass 1.
+    }
+    const $ = cheerio.load(html);
+    let nodesRemoved = 0;
+    // =====================================================================
+    // Pass 1: Semantic removal
+    // =====================================================================
+    // Walk top-down; remove entire subtrees that are clearly chrome.
+    // We look at direct children of body, and one level deeper, to catch
+    // both <body> <nav> and <body> <div> <nav> patterns.
+    const toRemoveSemantic = [];
+    function walkForChrome(parent, depth) {
+        const children = 'children' in parent ? parent.children : [];
+        for (const child of children) {
+            if (child.type !== 'tag')
+                continue;
+            const el = child;
+            const tagName = el.tagName?.toLowerCase() ?? '';
+            if (tagName === 'script' || tagName === 'style')
+                continue;
+            if (PROTECTED_TAGS.has(tagName)) {
+                // Recurse into protected — there might be chrome inside <article>
+                walkForChrome(el, depth + 1);
+                continue;
+            }
+            if (isChromeBySemantic(el, $)) {
+                toRemoveSemantic.push(el);
+                continue; // don't recurse into something we'll remove
+            }
+            // Recurse up to a reasonable depth
+            if (depth < 6) {
+                walkForChrome(el, depth + 1);
+            }
+        }
+    }
+    const body = $('body').get(0);
+    if (body) {
+        walkForChrome(body, 0);
+    }
+    for (const el of toRemoveSemantic) {
+        $(el).remove();
+        nodesRemoved++;
+    }
+    // =====================================================================
+    // Pass 2: Density scoring (on the remaining HTML)
+    // =====================================================================
+    const postPass1Html = $.html();
+    const postPass1Length = postPass1Html.length;
+    // Run density scoring on remaining content
+    if (postPass1Length > 100 && body) {
+        const blocks = [];
+        // Max leaf size: ~5KB or 30% of remaining content (whichever is smaller)
+        // This ensures we find leaf blocks even in small documents.
+        const maxLeafSize = Math.min(5000, Math.ceil(postPass1Length * 0.3));
+        collectBlocks($, body, blocks, maxLeafSize);
+        if (blocks.length >= 2) {
+            const scores = blocks.map(b => b.score);
+            const bestScore = Math.max(...scores);
+            let effectiveThreshold = threshold;
+            if (dynamic) {
+                // Blocks scoring below 50% of the best block are candidates for removal
+                effectiveThreshold = bestScore * 0.5;
+            }
+            // Safety: retain at least 40% of post-pass1 content
+            const minRetainLength = Math.ceil(postPass1Length * 0.4);
+            // Sort ascending by score — remove worst first
+            const sorted = blocks
+                .map((b, i) => ({ b, i, score: b.score }))
+                .sort((a, b) => a.score - b.score);
+            const toRemoveDensity = new Set();
+            let removedLength = 0;
+            for (const { b } of sorted) {
+                if (PROTECTED_TAGS.has(b.tagName) || DENSITY_SAFE_TAGS.has(b.tagName))
+                    continue;
+                const words = b.visibleText.trim().split(/\s+/).filter(w => w.length > 0);
+                const isTiny = words.length < minWords;
+                const isLow = b.score < effectiveThreshold;
+                if (!isTiny && !isLow)
+                    continue;
+                // Check safety floor
+                const remaining = postPass1Length - (removedLength + b.htmlLength);
+                if (remaining < minRetainLength)
+                    continue;
+                toRemoveDensity.add(b.element);
+                removedLength += b.htmlLength;
+            }
+            for (const el of toRemoveDensity) {
+                $(el).remove();
+                nodesRemoved++;
+            }
+        }
+    }
+    const resultHtml = $.html() ?? html;
+    const resultLength = resultHtml.length;
+    const reductionPercent = originalLength > 0
+        ? Math.max(0, Math.round(((originalLength - resultLength) / originalLength) * 100))
+        : 0;
+    return {
+        html: resultHtml,
+        nodesRemoved,
+        reductionPercent,
+    };
+}
+// ---------------------------------------------------------------------------
+// Markdown post-processing — remove UI noise leaked into markdown output
+// ---------------------------------------------------------------------------
+/** UI button labels that should be removed when they appear as standalone lines */
+const UI_BUTTON_LABELS = /^(load more|headlines only|show more|read more|show less|collapse|expand|view more|view less|see more|see less|more stories|more articles|sign up|subscribe|log in|sign in|follow us|get started|click here|learn more)$/i;
+/** An image with no alt text (empty brackets): `![](url)` */
+const EMPTY_IMAGE_RE = /^\!\[\]\([^)]+\)$/;
+/**
+ * Post-process markdown output to remove UI elements that leak through
+ * from content scrapers (buttons, empty images, consecutive hr separators).
+ *
+ * @param markdown - Raw markdown string
+ * @returns Cleaned markdown string
+ */
+export function pruneMarkdown(markdown) {
+    if (!markdown)
+        return markdown;
+    const lines = markdown.split('\n');
+    const result = [];
+    let consecutiveHrCount = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        // Remove lines that are just UI button labels (standalone, not in a heading/list)
+        if (UI_BUTTON_LABELS.test(trimmed)) {
+            continue;
+        }
+        // Remove empty images (no alt text): ![](url)
+        // But keep images with alt text: ![alt text](url)
+        if (EMPTY_IMAGE_RE.test(trimmed)) {
+            continue;
+        }
+        // Remove list items whose only content is an empty image
+        if (/^[-*+]\s+\!\[\]\([^)]+\)$/.test(trimmed)) {
+            continue;
+        }
+        // Handle consecutive HR separators ("* * *", "---", "___")
+        // Keep the first one, remove subsequent consecutive ones
+        const isHr = /^(\*\s*\*\s*\*|\-\s*\-\s*\-|_\s*_\s*_)$/.test(trimmed);
+        if (isHr) {
+            consecutiveHrCount++;
+            if (consecutiveHrCount > 1) {
+                continue; // skip duplicate hr
+            }
+        }
+        else {
+            // Reset counter on any non-HR, non-blank line
+            if (trimmed !== '') {
+                consecutiveHrCount = 0;
+            }
+        }
+        result.push(line);
+    }
+    return result.join('\n');
+}

package/dist/core/cookie-cache.d.ts

@@ -0,0 +1,60 @@
+/**
+ * In-memory cookie cache with TTL.
+ *
+ * Stores session cookies (especially cf_clearance, __cf_bm) keyed by domain.
+ * Cookies from challenge solves are cached here so future requests to the same
+ * domain skip the challenge entirely.
+ *
+ * Design goals:
+ *  - Zero dependencies (plain Map + setTimeout)
+ *  - In-memory only — no disk/DB persistence
+ *  - TTL per entry (default 30 min, matching cf_clearance lifetime)
+ *  - Thread-safe for single-process Node.js (event loop is single-threaded)
+ */
+export interface CachedCookies {
+    /** Raw "Cookie: ..." header value (semicolon-separated) */
+    cookieHeader: string;
+    /** Individual cookie strings (e.g. ["cf_clearance=abc; Path=/", ...]) */
+    cookies: string[];
+    /** Unix timestamp (ms) when this cache entry expires */
+    expiresAt: number;
+    /** The domain these cookies are for */
+    domain: string;
+}
+/**
+ * Store cookies for a domain.
+ *
+ * @param domain   Hostname (e.g. "example.com" or "sub.example.com")
+ * @param cookies  Array of Set-Cookie header values or cookie strings
+ * @param ttlMs    Time-to-live in ms (default: 30 min)
+ */
+export declare function cacheCookies(domain: string, cookies: string[], ttlMs?: number): void;
+/**
+ * Retrieve cached cookies for a domain (or its parent domain).
+ * Returns null if no valid (non-expired) entry exists.
+ *
+ * @param domain  Hostname to look up
+ */
+export declare function getCachedCookies(domain: string): CachedCookies | null;
+/**
+ * Build a Cookie request header value from a URL.
+ * Returns undefined if no cached cookies exist.
+ */
+export declare function getCookieHeader(url: string): string | undefined;
+/**
+ * Cache cookies from a URL's perspective.
+ * Extracts domain from URL automatically.
+ */
+export declare function cacheCookiesForUrl(url: string, cookies: string[], ttlMs?: number): void;
+/**
+ * Invalidate (remove) cached cookies for a domain.
+ */
+export declare function invalidateCookies(domain: string): void;
+/**
+ * Return the number of cached domains (for diagnostics).
+ */
+export declare function getCacheSize(): number;
+/**
+ * Clear ALL cached cookies. Mainly for tests.
+ */
+export declare function clearCookieCache(): void;

package/dist/core/cookie-cache.js

@@ -0,0 +1,163 @@
+/**
+ * In-memory cookie cache with TTL.
+ *
+ * Stores session cookies (especially cf_clearance, __cf_bm) keyed by domain.
+ * Cookies from challenge solves are cached here so future requests to the same
+ * domain skip the challenge entirely.
+ *
+ * Design goals:
+ *  - Zero dependencies (plain Map + setTimeout)
+ *  - In-memory only — no disk/DB persistence
+ *  - TTL per entry (default 30 min, matching cf_clearance lifetime)
+ *  - Thread-safe for single-process Node.js (event loop is single-threaded)
+ */
+// ── Internal store ────────────────────────────────────────────────────────────
+const store = new Map();
+let cleanupTimer = null;
+/** Default TTL: 30 minutes (cf_clearance lasts 30 min) */
+const DEFAULT_TTL_MS = 30 * 60 * 1000;
+// ── Public API ────────────────────────────────────────────────────────────────
+/**
+ * Store cookies for a domain.
+ *
+ * @param domain   Hostname (e.g. "example.com" or "sub.example.com")
+ * @param cookies  Array of Set-Cookie header values or cookie strings
+ * @param ttlMs    Time-to-live in ms (default: 30 min)
+ */
+export function cacheCookies(domain, cookies, ttlMs = DEFAULT_TTL_MS) {
+    if (!cookies.length)
+        return;
+    const normalizedDomain = normalizeDomain(domain);
+    const cookieHeader = buildCookieHeader(cookies);
+    const expiresAt = Date.now() + ttlMs;
+    store.set(normalizedDomain, {
+        cookieHeader,
+        cookies,
+        expiresAt,
+        domain: normalizedDomain,
+    });
+    // Start periodic cleanup if not already running
+    startCleanup();
+}
+/**
+ * Retrieve cached cookies for a domain (or its parent domain).
+ * Returns null if no valid (non-expired) entry exists.
+ *
+ * @param domain  Hostname to look up
+ */
+export function getCachedCookies(domain) {
+    const normalizedDomain = normalizeDomain(domain);
+    // Try exact match first, then parent domain
+    const candidates = [normalizedDomain, getParentDomain(normalizedDomain)].filter(Boolean);
+    for (const candidate of candidates) {
+        const entry = store.get(candidate);
+        if (entry && entry.expiresAt > Date.now()) {
+            return entry;
+        }
+        // Remove expired entry
+        if (entry) {
+            store.delete(candidate);
+        }
+    }
+    return null;
+}
+/**
+ * Build a Cookie request header value from a URL.
+ * Returns undefined if no cached cookies exist.
+ */
+export function getCookieHeader(url) {
+    try {
+        const domain = new URL(url).hostname;
+        const cached = getCachedCookies(domain);
+        return cached?.cookieHeader;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Cache cookies from a URL's perspective.
+ * Extracts domain from URL automatically.
+ */
+export function cacheCookiesForUrl(url, cookies, ttlMs = DEFAULT_TTL_MS) {
+    try {
+        const domain = new URL(url).hostname;
+        cacheCookies(domain, cookies, ttlMs);
+    }
+    catch {
+        // Invalid URL — ignore
+    }
+}
+/**
+ * Invalidate (remove) cached cookies for a domain.
+ */
+export function invalidateCookies(domain) {
+    const normalizedDomain = normalizeDomain(domain);
+    store.delete(normalizedDomain);
+}
+/**
+ * Return the number of cached domains (for diagnostics).
+ */
+export function getCacheSize() {
+    return store.size;
+}
+/**
+ * Clear ALL cached cookies. Mainly for tests.
+ */
+export function clearCookieCache() {
+    store.clear();
+    if (cleanupTimer) {
+        clearInterval(cleanupTimer);
+        cleanupTimer = null;
+    }
+}
+// ── Helpers ───────────────────────────────────────────────────────────────────
+/** Normalize domain: lowercase, strip www. prefix */
+function normalizeDomain(domain) {
+    return domain.toLowerCase().replace(/^www\./, '');
+}
+/** Get parent domain (strip first subdomain label) */
+function getParentDomain(domain) {
+    const parts = domain.split('.');
+    if (parts.length <= 2)
+        return null; // Already a root domain
+    return parts.slice(1).join('.');
+}
+/**
+ * Convert an array of Set-Cookie values or raw cookie strings into a single
+ * "Cookie: name=value; name2=value2" header value.
+ */
+function buildCookieHeader(cookies) {
+    const pairs = [];
+    for (const cookie of cookies) {
+        // Set-Cookie format: "name=value; Path=/; Secure; HttpOnly; ..."
+        // We only want the first "name=value" pair
+        const firstPart = cookie.split(';')[0]?.trim();
+        if (firstPart) {
+            pairs.push(firstPart);
+        }
+    }
+    return pairs.join('; ');
+}
+/** Periodically remove expired entries to prevent memory leaks. */
+function startCleanup() {
+    if (cleanupTimer)
+        return;
+    cleanupTimer = setInterval(() => {
+        const now = Date.now();
+        for (const [domain, entry] of store) {
+            if (entry.expiresAt <= now) {
+                store.delete(domain);
+            }
+        }
+        // Stop the timer if the cache is empty
+        if (store.size === 0 && cleanupTimer) {
+            clearInterval(cleanupTimer);
+            cleanupTimer = null;
+        }
+    }, 5 * 60 * 1000); // Run every 5 minutes
+    // Don't block Node.js process exit
+    if (cleanupTimer && typeof cleanupTimer.unref === 'function') {
+        cleanupTimer.unref();
+    }
+}