feedkeeper 0.0.0-stage → 0.23.0

package/server/dist/feeds/requestGate.js

@@ -0,0 +1,99 @@
+import { readPollSettings } from "./pollSettings.js";
+export class PollDeferredError extends Error {
+    retryAt;
+    host;
+    constructor(retryAt, host) {
+        super("poll_deferred");
+        this.retryAt = retryAt;
+        this.host = host;
+    }
+}
+export class RequestQueueFullError extends Error {
+    constructor() { super("request_queue_full"); }
+}
+export class PollShutdownError extends Error {
+    constructor() { super("poll_shutdown"); }
+}
+/** Hostname, deliberately excluding port and scheme; redirects acquire their destination too. */
+export function sourceHost(url) {
+    return new URL(url).hostname.toLowerCase().replace(/\.$/, "");
+}
+/** Shared by feed downloads, discovery, probes and icons. Never holds a permit over a redirect or delay. */
+export class RequestGate {
+    settings;
+    running = 0;
+    hosts = new Map();
+    waiting = [];
+    stopped = false;
+    cooldown = () => 0;
+    defer = () => { };
+    // Integrations can load their .env after importing core modules. Freeze limits on first use,
+    // after startup configuration, rather than capturing defaults during module evaluation.
+    constructor(settings) {
+        this.settings = settings;
+    }
+    get limits() { return this.settings ??= readPollSettings(); }
+    get stats() { return { running: this.running, waiting: this.waiting.length }; }
+    acquire(host, signal) {
+        if (this.stopped)
+            return Promise.reject(new PollShutdownError());
+        if (signal.aborted)
+            return Promise.reject(signal.reason);
+        const until = this.cooldown(host);
+        if (until > Date.now())
+            return Promise.reject(new PollDeferredError(until, host));
+        if (this.waiting.length >= this.limits.maxWaiters)
+            return Promise.reject(new RequestQueueFullError());
+        return new Promise((resolve, reject) => {
+            const waiter = { host, signal, resolve, reject, abort: () => {
+                    this.waiting = this.waiting.filter(entry => entry !== waiter);
+                    reject(signal.reason);
+                } };
+            signal.addEventListener("abort", waiter.abort, { once: true });
+            this.waiting.push(waiter);
+            this.pump();
+        });
+    }
+    pump() {
+        for (let i = 0; i < this.waiting.length;) {
+            const waiter = this.waiting[i];
+            const until = this.cooldown(waiter.host);
+            if (until > Date.now()) {
+                this.waiting.splice(i, 1);
+                waiter.signal.removeEventListener("abort", waiter.abort);
+                waiter.reject(new PollDeferredError(until, waiter.host));
+                continue;
+            }
+            if (this.running >= this.limits.concurrency || (this.hosts.get(waiter.host) ?? 0) >= this.limits.hostConcurrency) {
+                i++;
+                continue;
+            }
+            this.waiting.splice(i, 1);
+            waiter.signal.removeEventListener("abort", waiter.abort);
+            this.running++;
+            this.hosts.set(waiter.host, (this.hosts.get(waiter.host) ?? 0) + 1);
+            let released = false;
+            waiter.resolve(() => {
+                if (released)
+                    return;
+                released = true;
+                this.running--;
+                const count = this.hosts.get(waiter.host) - 1;
+                if (count)
+                    this.hosts.set(waiter.host, count);
+                else
+                    this.hosts.delete(waiter.host);
+                this.pump();
+            });
+        }
+    }
+    stop() {
+        this.stopped = true;
+        for (const waiter of this.waiting.splice(0)) {
+            waiter.signal.removeEventListener("abort", waiter.abort);
+            waiter.reject(new PollShutdownError());
+        }
+    }
+}
+export const feedRequests = new RequestGate();
+//# sourceMappingURL=requestGate.js.map

package/server/dist/feeds/service.js

@@ -0,0 +1,162 @@
+import { config } from "../config.js";
+import { createFeed, findFeedByUrl, isUserSubscribed, subscribe, unsubscribe as unsubscribeRepo, listSubscriptionsForUser, updateSubscriptionLabel, updateSubscriptionFolder, updateFeedPollInterval, updateSubscriptionFullTextMode, updateSubscriptionNotify, updateSubscriptionBadge, findFolderById, findFeedById, countFeedSubscribers, replaceFeedUrl, moveSubscription, } from "./repository.js";
+import { pollFeed, probeFeed } from "./poller.js";
+import { assertPublicHttpUrl } from "./ssrfGuard.js";
+import { discoverFeeds } from "./discovery.js";
+export class FeedError extends Error {
+}
+export class NoFeedsFoundError extends FeedError {
+    constructor() {
+        super("no_feeds_found");
+        this.name = "NoFeedsFoundError";
+    }
+}
+export class MultipleFeedsFoundError extends FeedError {
+    feeds;
+    constructor(feeds) {
+        super("multiple_feeds_found");
+        this.feeds = feeds;
+        this.name = "MultipleFeedsFoundError";
+    }
+}
+/** Turn a feed or website URL into a feed URL, using auto-discovery for website addresses. */
+async function resolveFeedUrl(inputUrl) {
+    const validated = await assertPublicHttpUrl(inputUrl.trim());
+    const targetUrl = validated.toString();
+    // A known shared feed needs no second discovery download beside its queued poll.
+    if (findFeedByUrl(targetUrl))
+        return { url: targetUrl };
+    try {
+        const discovered = await discoverFeeds(targetUrl);
+        if (discovered.length === 1)
+            return { url: discovered[0].url };
+        if (discovered.length > 1) {
+            const exact = discovered.find((d) => d.url === targetUrl);
+            if (exact)
+                return { url: exact.url };
+            throw new MultipleFeedsFoundError(discovered);
+        }
+    }
+    catch (err) {
+        if (err instanceof FeedError)
+            throw err;
+        // Otherwise fall back to trying the given URL directly
+    }
+    return { url: targetUrl };
+}
+export async function subscribeToFeed(userId, inputUrl, label = null, folderId = null) {
+    if (folderId !== null && !findFolderById(userId, folderId)) {
+        throw new FeedError("folder_not_found");
+    }
+    const { url: targetUrl } = await resolveFeedUrl(inputUrl);
+    let feed = findFeedByUrl(targetUrl);
+    if (!feed) {
+        feed = createFeed(targetUrl, Math.max(config.minPollIntervalMinutes, 15));
+    }
+    if (isUserSubscribed(userId, feed.id)) {
+        throw new FeedError("already_subscribed");
+    }
+    subscribe(userId, feed.id, label, folderId);
+    // Fetch immediately so the user sees items right away instead of waiting
+    // for the next scheduler tick.
+    const pollResult = await pollFeed(feed);
+    // A feed that has never been read successfully and fails right away is not a feed
+    // (e.g. a homepage that announces itself as RSS); don't keep the subscription.
+    if (pollResult.error && !pollResult.deferred && !findFeedById(feed.id)?.last_success_at) {
+        unsubscribeRepo(userId, feed.id);
+        throw new NoFeedsFoundError();
+    }
+    const subscription = listSubscriptionsForUser(userId).find((s) => s.id === feed.id);
+    if (!subscription)
+        throw new FeedError("subscription_lookup_failed");
+    return subscription;
+}
+export function unsubscribeFromFeed(userId, feedId) {
+    if (!isUserSubscribed(userId, feedId)) {
+        throw new FeedError("not_subscribed");
+    }
+    const feed = findFeedById(feedId);
+    if (feed?.is_system_inbox) {
+        throw new FeedError("cannot_unsubscribe_inbox");
+    }
+    unsubscribeRepo(userId, feedId);
+}
+export function updateFeedSettings(userId, feedId, settings) {
+    if (!isUserSubscribed(userId, feedId)) {
+        throw new FeedError("not_subscribed");
+    }
+    if (settings.folderId != null && !findFolderById(userId, settings.folderId)) {
+        throw new FeedError("folder_not_found");
+    }
+    if (settings.label !== undefined) {
+        updateSubscriptionLabel(userId, feedId, settings.label);
+    }
+    if (settings.folderId !== undefined) {
+        updateSubscriptionFolder(userId, feedId, settings.folderId);
+    }
+    if (settings.fullTextMode !== undefined) {
+        updateSubscriptionFullTextMode(userId, feedId, settings.fullTextMode);
+    }
+    if (settings.notify !== undefined) {
+        updateSubscriptionNotify(userId, feedId, settings.notify);
+    }
+    if (settings.badge !== undefined) {
+        updateSubscriptionBadge(userId, feedId, settings.badge);
+    }
+    if (settings.pollIntervalMinutes !== undefined) {
+        // The poll interval is stored per feed (shared across every subscriber),
+        // so it's floored account-wide rather than trusting each caller's input.
+        const minutes = Math.max(settings.pollIntervalMinutes, config.minPollIntervalMinutes);
+        updateFeedPollInterval(feedId, minutes);
+    }
+    const subscription = listSubscriptionsForUser(userId).find((s) => s.id === feedId);
+    if (!subscription)
+        throw new FeedError("subscription_lookup_failed");
+    return subscription;
+}
+/**
+ * Switch a subscription to a new feed URL, e.g. after a site moved its feed. The new URL is
+ * fetched and parsed first, so a broken address never replaces a working one. When the user
+ * is the only subscriber, the feed is updated in place and keeps its items, read state and
+ * bookmarks; otherwise the subscription moves to a separate feed for the new URL.
+ */
+export async function changeFeedUrl(userId, feedId, inputUrl) {
+    const current = findFeedById(feedId);
+    if (!current || !isUserSubscribed(userId, feedId))
+        throw new FeedError("not_subscribed");
+    const { url } = await resolveFeedUrl(inputUrl);
+    let target = feedId;
+    const lookup = () => {
+        const subscription = listSubscriptionsForUser(userId).find((s) => s.id === target);
+        if (!subscription)
+            throw new FeedError("subscription_lookup_failed");
+        return subscription;
+    };
+    if (url === current.url)
+        return { subscription: lookup(), previousItemsKept: true };
+    const existing = findFeedByUrl(url);
+    if (existing && isUserSubscribed(userId, existing.id))
+        throw new FeedError("already_subscribed");
+    try {
+        await probeFeed(url);
+    }
+    catch (error) {
+        throw new FeedError(`feed_unreachable: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    let previousItemsKept;
+    if (!existing && countFeedSubscribers(feedId) === 1) {
+        replaceFeedUrl(feedId, url);
+        previousItemsKept = true;
+    }
+    else {
+        const next = existing ?? createFeed(url, current.poll_interval_minutes);
+        moveSubscription(userId, feedId, next.id);
+        target = next.id;
+        previousItemsKept = false;
+    }
+    const feed = findFeedById(target);
+    if (feed)
+        await pollFeed(feed);
+    return { subscription: lookup(), previousItemsKept };
+}
+//# sourceMappingURL=service.js.map

package/server/dist/feeds/ssrfGuard.js

@@ -0,0 +1,98 @@
+import { lookup } from "node:dns/promises";
+import { Agent as HttpsAgent } from "node:https";
+import ipaddr from "ipaddr.js";
+import { Agent } from "undici";
+const BENCHMARK_NETWORK = ipaddr.parse("198.18.0.0");
+function privateFeedsAllowed() {
+    return process.env.ALLOW_PRIVATE_FEEDS === "true";
+}
+export class SsrfBlockedError extends Error {
+    constructor(url) {
+        super(`Refusing to fetch "${url}": resolves to a blocked internal address`);
+        this.name = "SsrfBlockedError";
+    }
+}
+export function normalizeUrlCandidate(rawUrl) {
+    const trimmed = rawUrl.trim();
+    if (!trimmed)
+        return trimmed;
+    if (/^https?:\/\//i.test(trimmed))
+        return trimmed;
+    if (trimmed.startsWith("//"))
+        return `https:${trimmed}`;
+    return `https://${trimmed}`;
+}
+export function isPublicIp(address) {
+    try {
+        const parsed = ipaddr.process(address.replace(/^\[|\]$/g, ""));
+        // The benchmarking range is reported as "unicast" by ipaddr.js.
+        if (parsed.kind() === "ipv4" && parsed.match(BENCHMARK_NETWORK, 15)) {
+            return false;
+        }
+        return parsed.range() === "unicast";
+    }
+    catch {
+        return false;
+    }
+}
+function assertPublicAddresses(addresses, url) {
+    if (addresses.length === 0 || addresses.some(({ address }) => !isPublicIp(address))) {
+        throw new SsrfBlockedError(url);
+    }
+}
+export async function assertPublicHttpUrl(rawUrl) {
+    let url;
+    try {
+        url = new URL(normalizeUrlCandidate(rawUrl));
+    }
+    catch {
+        throw new Error("Invalid URL");
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+        throw new Error("Only http:// and https:// URLs are allowed");
+    }
+    if (url.username || url.password)
+        throw new Error("URLs with credentials are not allowed");
+    if (privateFeedsAllowed())
+        return url;
+    const hostname = url.hostname.replace(/^\[|\]$/g, "");
+    if (ipaddr.isValid(hostname)) {
+        if (!isPublicIp(hostname))
+            throw new SsrfBlockedError(rawUrl);
+    }
+    else {
+        if (hostname === "localhost" || hostname.endsWith(".localhost") || hostname.endsWith(".local")) {
+            throw new SsrfBlockedError(rawUrl);
+        }
+        assertPublicAddresses(await lookup(hostname, { all: true }), rawUrl);
+    }
+    return url;
+}
+// Validate the address actually used by the socket. A DNS answer can change
+// between URL validation and connection, so the preflight check alone is insufficient.
+const guardedLookup = (hostname, options, callback) => {
+    lookup(hostname, { ...options, all: true })
+        .then((addresses) => {
+        try {
+            assertPublicAddresses(addresses, hostname);
+            if (options.all)
+                callback(null, addresses);
+            else
+                callback(null, addresses[0].address, addresses[0].family);
+        }
+        catch (error) {
+            callback(error, "");
+        }
+    })
+        .catch((error) => callback(error, ""));
+};
+export function createPublicDispatcher() {
+    if (privateFeedsAllowed())
+        return new Agent();
+    return new Agent({ connect: { lookup: guardedLookup } });
+}
+/** The same guard for libraries that use Node's https module, such as web-push. */
+export function createPublicHttpsAgent() {
+    return privateFeedsAllowed() ? new HttpsAgent() : new HttpsAgent({ lookup: guardedLookup });
+}
+//# sourceMappingURL=ssrfGuard.js.map

package/server/dist/feeds/text.js

@@ -0,0 +1,35 @@
+const NAMED_ENTITIES = {
+    amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", nbsp: " ",
+    lsquo: "‘", rsquo: "’", ldquo: "“", rdquo: "”", sbquo: "‚", bdquo: "„",
+    laquo: "«", raquo: "»", ndash: "–", mdash: "—", hellip: "…", middot: "·",
+    bull: "•", euro: "€", copy: "©", reg: "®", trade: "™", deg: "°",
+    auml: "ä", ouml: "ö", uuml: "ü", Auml: "Ä", Ouml: "Ö", Uuml: "Ü", szlig: "ß",
+};
+const ENTITY = /&(#x[0-9a-f]+|#\d+|[a-z][a-z0-9]*);/gi;
+function decodeOnce(text) {
+    return text.replace(ENTITY, (match, name) => {
+        if (name[0] === "#") {
+            const code = name[1] === "x" || name[1] === "X" ? parseInt(name.slice(2), 16) : parseInt(name.slice(1), 10);
+            return Number.isFinite(code) && code > 0 && code <= 0x10ffff ? String.fromCodePoint(code) : match;
+        }
+        return NAMED_ENTITIES[name] ?? match;
+    });
+}
+/** A title as one line of text: entities decoded, line breaks and runs of spaces collapsed to one space, trimmed. */
+export function plainTitle(text) {
+    const cleaned = decodeEntities(text)?.replace(/\s+/g, " ").trim();
+    return cleaned || undefined;
+}
+export function decodeEntities(text) {
+    if (!text || !text.includes("&"))
+        return text;
+    let current = text;
+    for (let pass = 0; pass < 3; pass++) {
+        const next = decodeOnce(current);
+        if (next === current)
+            break;
+        current = next;
+    }
+    return current;
+}
+//# sourceMappingURL=text.js.map

package/server/dist/index.js

@@ -0,0 +1,15 @@
+export { createApp, startCoreSchedulers, DEFAULT_WEB_DIST } from "./app.js";
+export * from "./auth/capabilities.js";
+export * from "./auth/tokens.js";
+export * from "./auth/middleware.js";
+export * from "./auth/users.js";
+export * from "./config.js";
+export * from "./db/index.js";
+export { apiRouter } from "./api/index.js";
+export { mcpRouter } from "./mcp/http.js";
+export { startPollingScheduler } from "./feeds/poller.js";
+export { startCleanupScheduler } from "./feeds/cleanup.js";
+export { repairEncodedText } from "./feeds/repository.js";
+export { pruneArchive, scheduleMissingArchives } from "./feeds/archive.js";
+export { startEditionScheduler } from "./native/editions.js";
+//# sourceMappingURL=index.js.map

package/server/dist/mcp/digest.js

@@ -0,0 +1,73 @@
+import { db } from "../db/index.js";
+import { listFoldersForUser, listItemsForUser, listSubscriptionsForUser } from "../feeds/repository.js";
+const DIGEST_FETCH_LIMIT = 200;
+export function truncate(text, maxChars) {
+    if (!text)
+        return null;
+    const clean = text.replace(/\s+/g, " ").trim();
+    return clean.length > maxChars ? `${clean.slice(0, maxChars).trimEnd()}…` : clean;
+}
+/** Items grouped by feed with short snippets: one call instead of many, and far fewer tokens. */
+export function buildDigest(userId, options) {
+    const maxItemsPerFeed = options.maxItemsPerFeed ?? 5;
+    const snippetChars = options.snippetChars ?? 200;
+    const since = options.since ?? (options.hours ? new Date(Date.now() - options.hours * 3_600_000).toISOString() : undefined);
+    const rows = listItemsForUser(userId, {
+        feedId: options.feedId,
+        folderId: options.folderId,
+        unreadOnly: options.unreadOnly ?? true,
+        publishedSince: since,
+        sortByAdded: true,
+        limit: DIGEST_FETCH_LIMIT,
+    });
+    const groups = new Map();
+    for (const row of rows) {
+        const group = groups.get(row.feed_id) ?? { feedId: row.feed_id, feed: row.feed_title, items: [] };
+        group.items.push(row);
+        groups.set(row.feed_id, group);
+    }
+    return {
+        generatedAt: new Date().toISOString(),
+        since: since ?? null,
+        totalItems: rows.length,
+        // More than the fetch limit matched; the oldest ones are not part of the digest.
+        truncated: rows.length === DIGEST_FETCH_LIMIT,
+        feeds: [...groups.values()].map((group) => ({
+            feedId: group.feedId,
+            feed: group.feed,
+            itemCount: group.items.length,
+            items: group.items.slice(0, maxItemsPerFeed).map((item) => ({
+                id: item.id,
+                title: item.title,
+                link: item.link,
+                publishedAt: item.published_at,
+                bookmarked: Boolean(item.bookmarked),
+                snippet: truncate(item.content_snippet, snippetChars),
+            })),
+            moreItems: Math.max(0, group.items.length - maxItemsPerFeed),
+        })),
+    };
+}
+/** A quick picture of the account: what is unread, where, and what needs attention. */
+export function buildOverview(userId) {
+    const feeds = listSubscriptionsForUser(userId);
+    const failing = feeds.filter((feed) => feed.last_error || feed.consecutive_errors > 0);
+    const saved = db.prepare("SELECT COUNT(*) AS n FROM item_bookmarks WHERE user_id = ?").get(userId).n;
+    const newest = db
+        .prepare("SELECT MAX(i.created_at) AS at FROM items i JOIN subscriptions s ON s.feed_id = i.feed_id AND s.user_id = ?")
+        .get(userId)?.at ?? null;
+    return {
+        feeds: feeds.length,
+        unread: feeds.reduce((total, feed) => total + feed.unread_count, 0),
+        savedArticles: saved,
+        newestItemAddedAt: newest,
+        feedsWithErrors: failing.map((feed) => ({ feedId: feed.id, title: feed.label ?? feed.title ?? feed.url, lastError: feed.last_error, consecutiveErrors: feed.consecutive_errors })),
+        topUnreadFeeds: [...feeds]
+            .filter((feed) => feed.unread_count > 0)
+            .sort((a, b) => b.unread_count - a.unread_count)
+            .slice(0, 10)
+            .map((feed) => ({ feedId: feed.id, title: feed.label ?? feed.title ?? feed.url, unread: feed.unread_count })),
+        folders: listFoldersForUser(userId).map((folder) => ({ folderId: folder.id, name: folder.name, feeds: folder.feed_count, unread: folder.unread_count })),
+    };
+}
+//# sourceMappingURL=digest.js.map

package/server/dist/mcp/http.js

@@ -0,0 +1,46 @@
+import { Router } from "express";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { requireBearerToken } from "../auth/middleware.js";
+import { requireCapability } from "../auth/capabilities.js";
+import { createMcpServerForUser } from "./server.js";
+export const mcpRouter = Router();
+// Stateless mode: a fresh McpServer + transport per request, scoped to the
+// user resolved from the bearer token. This is what makes the same endpoint
+// safely usable by many different users/clients from anywhere.
+mcpRouter.post("/", requireBearerToken, requireCapability("mcp"), async (req, res) => {
+    try {
+        const server = createMcpServerForUser(req.user.id, req.tokenScope);
+        const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined });
+        res.on("close", () => {
+            transport.close();
+            server.close();
+        });
+        await server.connect(transport);
+        await transport.handleRequest(req, res, req.body);
+    }
+    catch (error) {
+        console.error("[mcp] request failed", error);
+        if (!res.headersSent) {
+            res.status(500).json({
+                jsonrpc: "2.0",
+                error: { code: -32603, message: "Internal server error" },
+                id: null,
+            });
+        }
+    }
+});
+mcpRouter.get("/", requireBearerToken, (_req, res) => {
+    res.status(405).set("Allow", "POST").json({
+        jsonrpc: "2.0",
+        error: { code: -32000, message: "Method not allowed. This server only supports stateless POST requests." },
+        id: null,
+    });
+});
+mcpRouter.delete("/", requireBearerToken, (_req, res) => {
+    res.status(405).set("Allow", "POST").json({
+        jsonrpc: "2.0",
+        error: { code: -32000, message: "Method not allowed." },
+        id: null,
+    });
+});
+//# sourceMappingURL=http.js.map

package/server/dist/mcp/items.js

@@ -0,0 +1,73 @@
+import { contentMetadata, sourceText } from "../feeds/articleContent.js";
+import { z } from "zod";
+import { findItemForUser, listItemsForUser } from "../feeds/repository.js";
+const cursorSchema = z.object({
+    createdAt: z.string().datetime({ offset: true }),
+    id: z.number().int().positive(),
+});
+export function encodeCursor(item) {
+    return Buffer.from(JSON.stringify({ createdAt: item.created_at, id: item.id })).toString("base64url");
+}
+export function decodeCursor(value) {
+    if (value.length > 256 || !/^[A-Za-z0-9_-]+$/.test(value))
+        throw new Error("invalid_cursor");
+    const decoded = Buffer.from(value, "base64url");
+    if (decoded.toString("base64url") !== value)
+        throw new Error("invalid_cursor");
+    try {
+        return cursorSchema.parse(JSON.parse(decoded.toString("utf8")));
+    }
+    catch {
+        throw new Error("invalid_cursor");
+    }
+}
+export function listItemsPage(userId, options) {
+    const limit = options.limit ?? 50;
+    const rows = listItemsForUser(userId, {
+        feedId: options.feedId,
+        folderId: options.folderId,
+        unreadOnly: options.unreadOnly,
+        bookmarkedOnly: options.bookmarkedOnly,
+        before: options.before ? decodeCursor(options.before) : undefined,
+        after: options.after ? decodeCursor(options.after) : undefined,
+        publishedSince: options.since,
+        publishedUntil: options.until,
+        sortByAdded: true,
+        limit: limit + 1,
+    });
+    const hasMore = rows.length > limit;
+    const page = rows.slice(0, limit);
+    const items = page.map(({ content_html: _contentHtml, full_content_html: _fullContentHtml, ...item }) => item);
+    return {
+        items,
+        newestCursor: page[0] ? encodeCursor(page[0]) : null,
+        nextCursor: hasMore && page.length ? encodeCursor(page[page.length - 1]) : null,
+    };
+}
+export const MAX_CONTENT_LENGTH = 40_000;
+export function getItemForMcp(userId, itemId, maxChars = MAX_CONTENT_LENGTH, offset = 0, revision, format = "html") {
+    const item = findItemForUser(userId, itemId);
+    if (!item)
+        return null;
+    if (revision !== undefined && revision !== item.content_revision)
+        throw new Error("content_revision_conflict");
+    const content = item.full_content_html ?? item.content_html;
+    const body = format === "text" ? sourceText(item) : content ?? "";
+    let end = Math.min(offset + Math.min(maxChars, MAX_CONTENT_LENGTH), body.length);
+    if (end < body.length && /[\uD800-\uDBFF]/.test(body[end - 1]))
+        end--;
+    if (end === offset && offset < body.length)
+        end = Math.min(offset + 2, body.length);
+    return {
+        ...item,
+        content_html: format === "html" ? body.slice(offset, end) : undefined,
+        content_truncated: end < body.length,
+        full_content_html: undefined,
+        content: contentMetadata(item),
+        ...(format === "text" ? { text: body.slice(offset, end) } : {}),
+        format,
+        offset,
+        nextOffset: end < body.length ? end : null,
+    };
+}
+//# sourceMappingURL=items.js.map

package/server/dist/mcp/promptsAndResources.js

@@ -0,0 +1,43 @@
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { generateOpml } from "../feeds/opml.js";
+import { listItemsForUser, listSubscriptionsForUser } from "../feeds/repository.js";
+import { buildDigest } from "./digest.js";
+import { getItemForMcp } from "./items.js";
+const userMessage = (text) => ({ messages: [{ role: "user", content: { type: "text", text } }] });
+/** Ready-made prompts and readable resources, so MCP clients can offer FeedKeeper without custom instructions. */
+export function registerPromptsAndResources(server, userId, scope) {
+    server.registerPrompt("daily_briefing", {
+        title: "Daily briefing",
+        description: "A short briefing of what is new in your feeds, grouped by topic.",
+        argsSchema: { hours: z.string().regex(/^\d{1,3}$/).optional().describe("How many hours to look back (default 24)") },
+    }, ({ hours }) => userMessage(`Use the FeedKeeper tool get_digest with hours=${hours ?? "24"} to see what is new. Write a briefing: group the articles by topic rather than by feed, lead with the most important stories, give each one a sentence, and mention the article ids so I can ask for more. Skip trivia. If something deserves a closer look, fetch it with get_item.`));
+    server.registerPrompt("catch_up_on_topic", {
+        title: "Catch up on a topic",
+        description: "Find and summarize what your feeds say about a topic.",
+        argsSchema: { topic: z.string().min(1).max(200).describe("The topic or search words") },
+    }, ({ topic }) => userMessage(`Search my FeedKeeper articles for "${topic}" with search_items (also check saved articles with bookmarkedOnly). Read the most relevant ones with get_item and summarize how the story developed, with the sources and dates. Say clearly if there is little or nothing.`));
+    server.registerPrompt("saved_reading_list", {
+        title: "Saved reading list",
+        description: "Summarize the articles you saved for later and suggest what to read first.",
+    }, () => userMessage("List my saved FeedKeeper articles with list_items (bookmarkedOnly=true). Give each a one-line summary, group them by theme, and suggest a reading order with rough reading effort."));
+    server.registerPrompt("triage_unread", {
+        title: "Triage unread articles",
+        description: scope === "write" ? "Go through unread articles, save the keepers and mark the rest as read." : "Go through unread articles and recommend what to keep.",
+        argsSchema: { feedId: z.string().regex(/^\d{1,9}$/).optional().describe("Only this feed (id)") },
+    }, ({ feedId }) => userMessage(`Look at my unread FeedKeeper articles${feedId ? ` of feed ${feedId}` : ""} with get_digest. Recommend which are worth reading, which to save for later and which to skip.${scope === "write" ? " Ask me before you save or mark anything, then use bookmark_item and mark_read for the ones I confirm." : ""}`));
+    server.registerResource("feeds", "feedkeeper://feeds", { title: "Subscribed feeds", description: "All subscriptions with unread counts and health.", mimeType: "application/json" }, (uri) => ({ contents: [{ uri: uri.href, mimeType: "application/json", text: JSON.stringify(listSubscriptionsForUser(userId), null, 2) }] }));
+    server.registerResource("opml", "feedkeeper://opml", { title: "Subscriptions as OPML", description: "The subscription list in OPML 2.0, for backup or migration.", mimeType: "text/x-opml" }, (uri) => ({ contents: [{ uri: uri.href, mimeType: "text/x-opml", text: generateOpml(userId) }] }));
+    server.registerResource("saved", "feedkeeper://saved", { title: "Saved articles", description: "The newest 100 saved articles, without their content.", mimeType: "application/json" }, (uri) => {
+        const items = listItemsForUser(userId, { bookmarkedOnly: true, limit: 100 }).map(({ content_html: _html, full_content_html: _full, ...item }) => item);
+        return { contents: [{ uri: uri.href, mimeType: "application/json", text: JSON.stringify(items, null, 2) }] };
+    });
+    server.registerResource("digest", "feedkeeper://digest", { title: "Unread digest", description: "Unread articles of the last 24 hours, grouped by feed.", mimeType: "application/json" }, (uri) => ({ contents: [{ uri: uri.href, mimeType: "application/json", text: JSON.stringify(buildDigest(userId, { hours: 24 }), null, 2) }] }));
+    server.registerResource("item", new ResourceTemplate("feedkeeper://items/{itemId}", { list: undefined }), { title: "Article", description: "One article with its stored content.", mimeType: "application/json" }, (uri, variables) => {
+        const item = getItemForMcp(userId, Number(variables.itemId));
+        if (!item)
+            throw new Error("item_not_found");
+        return { contents: [{ uri: uri.href, mimeType: "application/json", text: JSON.stringify(item, null, 2) }] };
+    });
+}
+//# sourceMappingURL=promptsAndResources.js.map