feedkeeper 0.0.0-stage → 0.23.1

package/server/dist/feeds/pollQueue.js

@@ -0,0 +1,301 @@
+import { AsyncResource } from "node:async_hooks";
+import { setImmediate as yieldTurn } from "node:timers/promises";
+import { db } from "../db/index.js";
+import { findFeedById, updateFeedAfterPoll } from "./repository.js";
+import { FeedHttpError } from "./fetcher.js";
+import { feedRequests, PollDeferredError, PollShutdownError, RequestQueueFullError, sourceHost } from "./requestGate.js";
+import { readPollSettings } from "./pollSettings.js";
+import { pushOutboxMetrics } from "../pushOutbox.js";
+// Created when the core is loaded at startup, outside HTTP middleware. Background attempts
+// must not inherit a request's cached capabilities (or keep that request context alive).
+const pollingContext = new AsyncResource("FeedKeeperPolling");
+export function retryDelay(attempt, settings, random = Math.random()) {
+    return Math.ceil(Math.min(settings.retryMaxMs, settings.retryBaseMs * 2 ** attempt) * (0.5 + random * 0.5));
+}
+function isTransient(error) {
+    return error instanceof FeedHttpError ? [408, 425, 429, 500, 502, 503, 504].includes(error.status)
+        : error instanceof TypeError || error instanceof RequestQueueFullError || (error instanceof Error && ["TimeoutError", "AbortError"].includes(error.name));
+}
+export function pollErrorCode(error) {
+    if (error instanceof FeedHttpError)
+        return `feed_http_${error.status}`;
+    if (error instanceof Error && ["TimeoutError", "AbortError"].includes(error.name))
+        return "feed_timeout";
+    if (error instanceof TypeError)
+        return "feed_network_error";
+    return "feed_invalid_or_unavailable";
+}
+/** Install storage callbacks before discovery can run, without querying before migrations. */
+export function configurePollHostCooldowns() {
+    feedRequests.cooldown = host => (db.prepare("SELECT retry_at FROM feed_poll_hosts WHERE host = ?").get(host)?.retry_at ?? 0);
+    feedRequests.defer = (host, until) => {
+        db.prepare("INSERT INTO feed_poll_hosts(host,retry_at) VALUES (?,?) ON CONFLICT(host) DO UPDATE SET retry_at = MAX(retry_at,excluded.retry_at)").run(host, until);
+    };
+}
+/** SQLite stores pending work; only active attempts and a capped set of API waiters live in memory.
+ * There is deliberately no durable running lock: restart simply replays unfinished jobs.
+ * Exactly one application process may own a database (not PM2 cluster / multiple replicas).
+ */
+export class PollQueue {
+    attempt;
+    eligible;
+    settings;
+    active = new Map();
+    waiters = new Map();
+    stopped = false;
+    pumping = false;
+    repump = false;
+    seed;
+    timer;
+    logTimer;
+    errorCounts = {};
+    counters = { succeeded: 0, newItems: 0, completed: 0, errors: 0, retries: 0, throttled: 0, coalesced: 0, deferred: 0, durationMs: 0, maxDurationMs: 0, startLagMs: 0, maxStartLagMs: 0 };
+    since = Date.now();
+    constructor(attempt, eligible, settings = readPollSettings()) {
+        this.attempt = attempt;
+        this.eligible = eligible;
+        this.settings = settings;
+        configurePollHostCooldowns();
+    }
+    /** Preserve existing backoff; manual refresh never resets a retry budget or host cooldown. */
+    enqueue(feed) {
+        if (this.active.has(feed.id) || feed.is_system_inbox || !this.eligible(feed.id))
+            return;
+        const now = Date.now();
+        db.prepare("INSERT OR IGNORE INTO feed_poll_jobs(feed_id,host,enqueued_at,available_at) VALUES (?,?,?,?)")
+            .run(feed.id, sourceHost(feed.url), now, now);
+    }
+    submit(feed) {
+        if (this.stopped) {
+            // In-flight HTTP handlers may finish subscribing during drain. Preserve their request
+            // for the next process, even though this process will no longer dispatch work.
+            this.enqueue(feed);
+            return Promise.resolve({ newItems: 0, error: null, deferred: true });
+        }
+        const running = this.active.get(feed.id);
+        if (running) {
+            this.counters.coalesced++;
+            return running.promise;
+        }
+        const waiting = this.waiters.get(feed.id);
+        if (waiting) {
+            this.counters.coalesced++;
+            return waiting.promise;
+        }
+        this.enqueue(feed);
+        const job = db.prepare("SELECT * FROM feed_poll_jobs WHERE feed_id = ?").get(feed.id);
+        if (!job)
+            return Promise.resolve({ newItems: 0, error: "feed_poll_not_allowed" });
+        const retryAt = Math.max(job.available_at, feedRequests.cooldown(job.host));
+        if (retryAt > Date.now() || this.waiters.size >= this.settings.maxWaiters) {
+            this.counters.deferred++;
+            this.kick();
+            return Promise.resolve({ newItems: 0, error: null, deferred: true, retryAt });
+        }
+        let resolve;
+        const promise = new Promise(done => { resolve = done; });
+        const timer = setTimeout(() => {
+            this.waiters.delete(feed.id);
+            this.counters.deferred++;
+            resolve({ newItems: 0, error: null, deferred: true });
+        }, this.settings.attemptTimeoutMs);
+        this.waiters.set(feed.id, { promise, resolve, timer });
+        this.kick();
+        return promise;
+    }
+    /** Keyset pages create no Promise/task per feed, and yield so imports/sync remain responsive. */
+    seedDue() {
+        if (this.seed)
+            return this.seed;
+        this.seed = (async () => {
+            let after = 0;
+            while (!this.stopped) {
+                const rows = db.prepare(`SELECT f.* FROM feeds f
+          WHERE f.id > ? AND f.is_system_inbox = 0
+          AND EXISTS (SELECT 1 FROM subscriptions s WHERE s.feed_id = f.id)
+          AND NOT EXISTS (SELECT 1 FROM feed_poll_jobs j WHERE j.feed_id = f.id)
+          AND (f.last_polled_at IS NULL OR f.last_polled_at <= strftime('%Y-%m-%dT%H:%M:%fZ','now','-' || f.poll_interval_minutes || ' minutes'))
+          ORDER BY f.id LIMIT 200`).all(after);
+                if (!rows.length)
+                    break;
+                db.transaction(() => { for (const feed of rows)
+                    if (!this.active.has(feed.id))
+                        this.enqueue(feed); })();
+                after = rows[rows.length - 1].id;
+                this.kick();
+                await yieldTurn();
+            }
+            this.kick();
+        })().finally(() => { this.seed = undefined; });
+        return this.seed;
+    }
+    start() {
+        if (this.timer || this.stopped)
+            return;
+        pollingContext.runInAsyncScope(() => {
+            this.timer = setInterval(() => this.kick(), this.settings.tickMs);
+            this.timer.unref();
+            this.logTimer = setInterval(() => {
+                try {
+                    console.log(JSON.stringify({ event: "feed_poll_metrics", ...this.metrics() }));
+                    db.prepare("DELETE FROM feed_poll_hosts WHERE retry_at <= ?").run(Date.now());
+                }
+                catch {
+                    console.error(JSON.stringify({ event: "feed_poll_queue_error", code: "metrics_storage_failure" }));
+                }
+            }, 60_000);
+            this.logTimer.unref();
+        });
+    }
+    kick() {
+        if (this.stopped)
+            return;
+        if (this.pumping) {
+            this.repump = true;
+            return;
+        }
+        this.pumping = true;
+        // Schedule in a new event-loop turn, including after a synchronous DB/eligibility failure.
+        pollingContext.runInAsyncScope(() => setImmediate(() => {
+            this.repump = false;
+            try {
+                this.pump();
+            }
+            catch {
+                console.error(JSON.stringify({ event: "feed_poll_queue_error", code: "queue_storage_or_eligibility_failure" }));
+            }
+            finally {
+                this.pumping = false;
+                if (this.repump)
+                    this.kick();
+            }
+        }));
+    }
+    pump() {
+        while (!this.stopped && this.active.size < this.settings.concurrency) {
+            const blockedHosts = [...new Set([...this.active.values()].map(entry => entry.host))]
+                .filter(host => [...this.active.values()].filter(entry => entry.host === host).length >= this.settings.hostConcurrency);
+            const job = db.prepare(`SELECT j.* FROM feed_poll_jobs j
+        WHERE j.available_at <= ?
+        AND j.feed_id NOT IN (SELECT value FROM json_each(?))
+        AND j.host NOT IN (SELECT value FROM json_each(?))
+        AND NOT EXISTS (SELECT 1 FROM feed_poll_hosts h WHERE h.host = j.host AND h.retry_at > ?)
+        ORDER BY j.enqueued_at, j.feed_id LIMIT 1`).get(Date.now(), JSON.stringify([...this.active.keys()]), JSON.stringify(blockedHosts), Date.now());
+            if (!job)
+                break;
+            const feed = findFeedById(job.feed_id);
+            if (!feed || feed.is_system_inbox || !this.eligible(feed.id)) {
+                db.prepare("DELETE FROM feed_poll_jobs WHERE feed_id = ?").run(job.feed_id);
+                this.resolve(job.feed_id, { newItems: 0, error: "feed_poll_not_allowed" });
+                continue;
+            }
+            // A URL may have been changed since enqueue. Do not dispatch under its old host budget.
+            if (sourceHost(feed.url) !== job.host) {
+                db.prepare("UPDATE feed_poll_jobs SET host = ? WHERE feed_id = ?").run(sourceHost(feed.url), feed.id);
+                continue;
+            }
+            const waiter = this.waiters.get(feed.id);
+            if (waiter)
+                clearTimeout(waiter.timer);
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(new DOMException("Poll deadline exceeded", "TimeoutError")), this.settings.attemptTimeoutMs);
+            const started = Date.now();
+            const dueAt = feed.last_polled_at ? Date.parse(feed.last_polled_at) + feed.poll_interval_minutes * 60_000 : Date.parse(feed.created_at);
+            const lag = Math.max(0, started - dueAt);
+            this.counters.startLagMs += lag;
+            this.counters.maxStartLagMs = Math.max(this.counters.maxStartLagMs, lag);
+            const promise = this.run(job, feed, controller.signal).catch(() => {
+                console.error(JSON.stringify({ event: "feed_poll_queue_error", code: "attempt_storage_failure" }));
+                // A storage failure leaves the durable job intact. Stop admission until process restart.
+                this.stopped = true;
+                return { newItems: 0, error: "feed_poll_storage_failure", deferred: true };
+            }).finally(() => {
+                clearTimeout(timeout);
+                const duration = Date.now() - started;
+                this.counters.durationMs += duration;
+                this.counters.maxDurationMs = Math.max(this.counters.maxDurationMs, duration);
+                this.counters.completed++;
+                this.active.delete(feed.id);
+                this.kick();
+            });
+            this.active.set(feed.id, { promise, controller, host: job.host });
+            void promise.then(result => this.resolve(feed.id, result));
+        }
+    }
+    async run(job, feed, signal) {
+        try {
+            const result = await this.attempt(feed, signal);
+            db.prepare("DELETE FROM feed_poll_jobs WHERE feed_id = ?").run(feed.id);
+            if (!result.error) {
+                this.counters.succeeded++;
+                this.counters.newItems += result.newItems;
+            }
+            return result;
+        }
+        catch (error) {
+            if (this.stopped || error instanceof PollShutdownError)
+                return { newItems: 0, error: null, deferred: true };
+            if (error instanceof PollDeferredError) {
+                this.counters.throttled++;
+                db.prepare("UPDATE feed_poll_jobs SET available_at = ? WHERE feed_id = ?").run(error.retryAt, feed.id);
+                return { newItems: 0, error: null, deferred: true, retryAt: error.retryAt };
+            }
+            this.counters.errors++;
+            if (error instanceof FeedHttpError && [429, 503].includes(error.status))
+                this.counters.throttled++;
+            const message = pollErrorCode(error);
+            this.errorCounts[message] = (this.errorCounts[message] ?? 0) + 1;
+            const transient = isTransient(error);
+            const retry = transient && job.attempts < this.settings.maxRetries;
+            const retryAt = Math.max(Date.now() + retryDelay(job.attempts, this.settings), error instanceof FeedHttpError ? error.retryAt ?? 0 : 0);
+            const resumeAt = retry ? retryAt : Math.max(retryAt, Date.now() + feed.poll_interval_minutes * 60_000);
+            db.transaction(() => {
+                updateFeedAfterPoll(feed.id, { error: message });
+                if (retry) {
+                    // Rejoin the tail: a failing source cannot repeatedly displace fresh work.
+                    db.prepare("UPDATE feed_poll_jobs SET attempts = attempts + 1, available_at = ?, enqueued_at = ? WHERE feed_id = ?").run(retryAt, Date.now(), feed.id);
+                }
+                else {
+                    // Exhausted/permanent failures resume only on the next regular interval. Manual triggers
+                    // join this durable delay instead of starting a fresh retry budget immediately.
+                    db.prepare("UPDATE feed_poll_jobs SET attempts = 0, available_at = ?, enqueued_at = ? WHERE feed_id = ?")
+                        .run(resumeAt, Date.now(), feed.id);
+                }
+            })();
+            if (retry)
+                this.counters.retries++;
+            return { newItems: 0, error: message, ...(transient ? { deferred: true, retryAt: resumeAt } : {}) };
+        }
+    }
+    resolve(id, result) {
+        const waiter = this.waiters.get(id);
+        if (!waiter)
+            return;
+        clearTimeout(waiter.timer);
+        this.waiters.delete(id);
+        waiter.resolve(result);
+    }
+    metrics() {
+        const now = Date.now();
+        const queue = db.prepare(`SELECT COUNT(*) pending,
+      COALESCE(SUM(available_at <= ?),0) due, COALESCE(MAX(? - enqueued_at),0) oldestMs FROM feed_poll_jobs`).get(now, now);
+        const { completed, ...counters } = this.counters;
+        return { ...queue, errorCounts: { ...this.errorCounts }, meanDurationMs: this.counters.durationMs / Math.max(1, completed), meanStartLagMs: this.counters.startLagMs / Math.max(1, completed), running: this.active.size, waiters: this.waiters.size, requests: feedRequests.stats, push: pushOutboxMetrics(),
+            completed, ...counters, elapsedMs: now - this.since,
+            throughputPerSecond: completed / Math.max(1, (now - this.since) / 1000) };
+    }
+    async stop() {
+        this.stopped = true;
+        if (this.timer)
+            clearInterval(this.timer);
+        if (this.logTimer)
+            clearInterval(this.logTimer);
+        for (const id of this.waiters.keys())
+            this.resolve(id, { newItems: 0, error: null, deferred: true });
+        for (const entry of this.active.values())
+            entry.controller.abort(new PollShutdownError());
+        await Promise.allSettled([...this.active.values()].map(entry => entry.promise));
+        await this.seed;
+    }
+}
+//# sourceMappingURL=pollQueue.js.map

package/server/dist/feeds/pollSettings.js

@@ -0,0 +1,23 @@
+/** Kept independent of application config so the guarded downloader also works in CLI tools. */
+function integer(name, fallback, min, max) {
+    const raw = process.env[name];
+    const value = raw === undefined ? fallback : Number(raw);
+    if (!Number.isSafeInteger(value) || value < min || value > max) {
+        throw new Error(`${name} must be an integer between ${min} and ${max}`);
+    }
+    return value;
+}
+export function readPollSettings() {
+    return {
+        concurrency: integer("POLL_CONCURRENCY", 4, 1, 32),
+        hostConcurrency: integer("POLL_HOST_CONCURRENCY", 2, 1, 8),
+        maxWaiters: integer("POLL_MAX_WAITERS", 64, 1, 1024),
+        requestTimeoutMs: integer("POLL_REQUEST_TIMEOUT_MS", 15_000, 50, 60_000),
+        attemptTimeoutMs: integer("POLL_ATTEMPT_TIMEOUT_MS", 30_000, 100, 120_000),
+        maxRetries: integer("POLL_MAX_RETRIES", 2, 0, 5),
+        retryBaseMs: integer("POLL_RETRY_BASE_MS", 5_000, 10, 300_000),
+        retryMaxMs: integer("POLL_RETRY_MAX_MS", 300_000, 100, 3_600_000),
+        tickMs: integer("POLL_TICK_MS", 1_000, 20, 60_000),
+    };
+}
+//# sourceMappingURL=pollSettings.js.map

package/server/dist/feeds/poller.js

@@ -0,0 +1,223 @@
+import Parser from "rss-parser";
+import { fetchFeed } from "./fetcher.js";
+import { discoverIconUrls, iconCheckDue } from "./icon.js";
+import { refreshFeedIcon } from "./feedIcon.js";
+import { decodeEntities, plainTitle } from "./text.js";
+import { enqueueNewItemNotifications, startPushOutbox, stopPushOutbox } from "../pushOutbox.js";
+import { hasUserCapability } from "../auth/capabilities.js";
+import { findFeedById, listSubscriberIds, updateFeedAfterPoll, updateFeedIcon, upsertItems } from "./repository.js";
+import { db } from "../db/index.js";
+import { configurePollHostCooldowns, PollQueue } from "./pollQueue.js";
+import { feedRequests, PollDeferredError, sourceHost } from "./requestGate.js";
+import { normalizePublishedAt } from "./dates.js";
+configurePollHostCooldowns();
+function mediaAttribute(value, key) {
+    if (typeof value !== "object" || value === null)
+        return undefined;
+    const record = value;
+    const attributes = record.$;
+    if (typeof attributes === "object" && attributes !== null) {
+        const nested = attributes[key];
+        if (nested !== undefined)
+            return nested;
+    }
+    return record[key];
+}
+const parser = new Parser({
+    customFields: {
+        item: [
+            ["media:content", "mediaContent", { keepArray: false }],
+            ["media:thumbnail", "mediaThumbnail", { keepArray: false }],
+            ["content:encoded", "contentEncoded", { keepArray: false }],
+        ],
+    },
+});
+function cleanImageUrl(url) {
+    return url.trim().replace(/&/g, "&").replace(/&/g, "&");
+}
+function isValidImageUrl(url) {
+    if (typeof url !== "string")
+        return false;
+    const trimmed = url.trim();
+    if (!trimmed.startsWith("http://") && !trimmed.startsWith("https://"))
+        return false;
+    if (trimmed.includes("/1x1") || trimmed.includes("pixel.wp.com") || trimmed.includes("tracking") || trimmed.includes("beacon")) {
+        if (trimmed.includes("pixel") || trimmed.includes("1x1"))
+            return false;
+    }
+    return true;
+}
+function extractImageUrl(item) {
+    // 1. media:content (Media RSS)
+    const mediaContent = item.mediaContent ?? item["media:content"];
+    if (mediaContent) {
+        if (isValidImageUrl(mediaContent))
+            return cleanImageUrl(mediaContent);
+        const url = mediaAttribute(mediaContent, "url");
+        const medium = mediaAttribute(mediaContent, "medium");
+        const type = mediaAttribute(mediaContent, "type");
+        if (isValidImageUrl(url) && (medium === "image" || !medium || (typeof type === "string" && type.startsWith("image/")))) {
+            return cleanImageUrl(url);
+        }
+    }
+    // 2. media:thumbnail
+    const mediaThumbnail = item.mediaThumbnail ?? item["media:thumbnail"];
+    if (mediaThumbnail) {
+        if (isValidImageUrl(mediaThumbnail))
+            return cleanImageUrl(mediaThumbnail);
+        const url = mediaAttribute(mediaThumbnail, "url");
+        if (isValidImageUrl(url))
+            return cleanImageUrl(url);
+    }
+    // 3. enclosure
+    if (item.enclosure?.url) {
+        const url = item.enclosure.url;
+        const type = item.enclosure.type ?? "";
+        if (type.startsWith("image/") || /\.(jpe?g|png|webp|gif|avif|svg)(\?.*)?$/i.test(url)) {
+            if (isValidImageUrl(url))
+                return cleanImageUrl(url);
+        }
+    }
+    // 4. First <img> tag in HTML content or summary
+    const htmlContent = item.contentEncoded ?? item["content:encoded"] ?? item.content ?? item.summary ?? "";
+    if (typeof htmlContent === "string" && htmlContent.includes("<img")) {
+        const match = htmlContent.match(/<img[^>]+src=["'](https?:\/\/[^"'\s>]+)["']/i);
+        if (match && isValidImageUrl(match[1])) {
+            return cleanImageUrl(match[1]);
+        }
+    }
+    return null;
+}
+/** One attempt; the queue owns retries, admission, single-flight and the total deadline. */
+async function pollAttempt(feed, signal) {
+    const fetched = await fetchFeed(feed.url, { etag: feed.etag ?? undefined, lastModified: feed.last_modified ?? undefined, signal });
+    const parsed = fetched.notModified ? null : await parser.parseString(fetched.body);
+    signal.throwIfAborted();
+    const current = findFeedById(feed.id);
+    if (!current || current.url !== feed.url)
+        throw new PollDeferredError(Date.now(), current ? sourceHost(current.url) : sourceHost(feed.url));
+    // Recheck hosted capabilities after network I/O, before committing or sending notifications.
+    if (!feedHasActiveSubscriber(feed.id))
+        return { newItems: 0, error: "feed_poll_not_allowed" };
+    const items = parsed?.items.map(item => ({
+        guid: item.guid ?? item.link ?? item.title ?? crypto.randomUUID(),
+        title: plainTitle(item.title), link: item.link,
+        contentSnippet: decodeEntities(item.contentSnippet ?? item.content) ?? undefined,
+        contentHtml: item.contentEncoded ?? item["content:encoded"] ?? item.content ?? null,
+        publishedAt: normalizePublishedAt(item.isoDate ?? item.pubDate) ?? undefined, imageUrl: extractImageUrl(item),
+    }));
+    // No await in this transaction. Items, health/validators and job completion become visible together.
+    const newItems = db.transaction(() => {
+        const count = items ? upsertItems(feed.id, items) : 0;
+        updateFeedAfterPoll(feed.id, {
+            ...(parsed ? { title: plainTitle(parsed.title), siteUrl: parsed.link, etag: fetched.etag, lastModified: fetched.lastModified } : {}),
+            error: null,
+        });
+        if (count > 0 && feed.last_success_at)
+            enqueueNewItemNotifications(feed.id, count);
+        db.prepare("DELETE FROM feed_poll_jobs WHERE feed_id = ?").run(feed.id);
+        return count;
+    })();
+    // Push is committed above and dispatched independently of the feed deadline.
+    startPushOutbox();
+    // Bounded icon maintenance cannot retry a committed feed.
+    try {
+        signal.throwIfAborted();
+        if (iconCheckDue(feed.icon_checked_at)) {
+            const siteUrl = parsed?.link || feed.site_url;
+            const urls = siteUrl ? await discoverIconUrls(siteUrl, signal) : [];
+            signal.throwIfAborted();
+            updateFeedIcon(feed.id, feed.icon_url);
+            await refreshFeedIcon(feed.id, siteUrl, urls, signal);
+        }
+    }
+    catch { /* Keep the successful poll; icon failures are best effort. */ }
+    return { newItems, error: null };
+}
+let queue;
+function pollingQueue() {
+    queue ??= new PollQueue(pollAttempt, feedHasActiveSubscriber);
+    queue.start();
+    startPushOutbox();
+    return queue;
+}
+/** Concurrent triggers share the same attempt result. Deferred work survives the HTTP caller. */
+export function pollFeed(feed) { return pollingQueue().submit(feed); }
+/** Bounded consumers for explicit refresh-all. Each feed still uses the shared durable queue. */
+export async function pollFeeds(feeds) {
+    let cursor = 0;
+    let newItems = 0;
+    let errors = 0;
+    let deferred = 0;
+    await Promise.all(Array.from({ length: Math.min(pollingQueue().settings.concurrency, feeds.length) }, async () => {
+        while (cursor < feeds.length) {
+            const result = await pollFeed(feeds[cursor++]);
+            newItems += result.newItems;
+            if (result.error)
+                errors++;
+            if (result.deferred)
+                deferred++;
+        }
+    }));
+    return { newItems, errors, deferred };
+}
+/** Bulk imports need no suspended JavaScript task per subscription. */
+export function requestFeedPoll(feed) {
+    const queue = pollingQueue();
+    queue.enqueue(feed);
+    queue.kick();
+}
+export function pollingMetrics() { return pollingQueue().metrics(); }
+/** Fetch and parse a feed without storing anything, to validate a URL before switching to it. */
+export async function probeFeed(url) {
+    const fetched = await fetchFeed(url);
+    const parsed = await parser.parseString(fetched.body);
+    return { title: parsed.title ?? null, itemCount: parsed.items.length };
+}
+/**
+ * Whether anyone who subscribes to the feed may have it updated. An account whose plan does not include syncing (a hosted
+ * service after the trial) gets no updates, and a feed that only such accounts subscribe to is not fetched at all.
+ */
+export function feedHasActiveSubscriber(feedId) {
+    return listSubscriberIds(feedId).some((userId) => hasUserCapability(userId, "sync"));
+}
+/** Schedules due work, returning after bounded-page admission rather than a network round. */
+export function pollDueFeeds() { return pollingQueue().seedDue(); }
+let scheduler;
+export function startPollingScheduler() {
+    if (scheduler)
+        return;
+    const tick = () => { void pollDueFeeds().catch(() => console.error(JSON.stringify({ event: "feed_poll_seed_error" }))); };
+    tick();
+    scheduler = setInterval(tick, 60_000);
+    scheduler.unref();
+}
+export async function stopPollingScheduler() {
+    if (scheduler)
+        clearInterval(scheduler);
+    scheduler = undefined;
+    const { stopImageCache } = await import("./archive.js");
+    await stopImageCache();
+    await Promise.all([queue?.stop(), stopPushOutbox()]);
+    feedRequests.stop();
+}
+/** Graceful shutdown for server integrations; process-manager grace should be >= 45 seconds. */
+export function installPollingShutdown(server) {
+    let stopping = false;
+    const shutdown = () => {
+        if (stopping)
+            return;
+        stopping = true;
+        console.log(JSON.stringify({ event: "feed_poll_shutdown" }));
+        const deadline = setTimeout(() => process.exit(1), 40_000);
+        deadline.unref();
+        const drained = new Promise(resolve => server.close(() => resolve()));
+        void Promise.all([stopPollingScheduler(), drained]).then(() => {
+            server.closeAllConnections();
+            process.exit(0);
+        }, () => process.exit(1));
+    };
+    process.once("SIGTERM", shutdown);
+    process.once("SIGINT", shutdown);
+}
+//# sourceMappingURL=poller.js.map