feedkeeper 0.0.0-stage → 0.23.0

package/server/dist/native/editionSelection.js

@@ -0,0 +1,127 @@
+/** Remove only known tracking parameters; meaningful query parameters remain distinct. */
+export function canonicalArticleUrl(value) {
+    if (!value)
+        return null;
+    try {
+        const url = new URL(value);
+        if (!["https:", "http:"].includes(url.protocol))
+            return null;
+        url.hash = "";
+        for (const key of [...url.searchParams.keys()]) {
+            if (/^utm_/i.test(key) || /^(fbclid|gclid|dclid|mc_cid|mc_eid)$/i.test(key))
+                url.searchParams.delete(key);
+        }
+        url.searchParams.sort();
+        url.pathname = url.pathname.replace(/\/+$/, "") || "/";
+        return url.toString();
+    }
+    catch {
+        return null;
+    }
+}
+function normalizedTitle(value) {
+    return (value ?? "").normalize("NFKD").replace(/\p{M}/gu, "").toLocaleLowerCase("en")
+        .replace(/[^\p{L}\p{N}]+/gu, " ").trim();
+}
+function duplicate(a, b) {
+    if (a.url && a.url === b.url)
+        return true;
+    if (a.title.length >= 25 && a.title === b.title)
+        return true;
+    if (Math.abs(a.published - b.published) > 48 * 3_600_000)
+        return false;
+    const words = a.words, otherWords = b.words;
+    if (words.size < 6 || otherWords.size < 6)
+        return false;
+    if (Math.min(words.size, otherWords.size) / Math.max(words.size, otherWords.size) < 0.9)
+        return false;
+    const shared = [...words].filter((word) => otherWords.has(word)).length;
+    return shared / (words.size + otherWords.size - shared) >= 0.9;
+}
+/** Selection is deterministic and independent of images and device opening counters.
+ * First favour new stories, then relax source caps to fill a small library fairly. */
+export function selectEdition(candidates, settings) {
+    const chosen = [];
+    const chosenKeys = [];
+    const chosenIds = new Set();
+    // Normalize URLs and Unicode once, not for every pair on every selection pass.
+    const prepared = candidates.map((article) => {
+        const title = normalizedTitle(article.title);
+        return { article, title, words: new Set(title.split(" ")), url: canonicalArticleUrl(article.url), published: Date.parse(article.publishedAt) };
+    });
+    const feeds = new Map();
+    const folders = new Map();
+    let minutes = 0;
+    const distinctFolders = Math.max(1, new Set(candidates.map((item) => item.folderId)).size);
+    const folderCap = Math.max(2, Math.ceil(settings.editionSize / distinctFolders * 1.5));
+    // New stories precede repeats, including older background pieces within the seven-day window.
+    for (const repeats of [false, true]) {
+        for (const cap of [3, 6, 12, 24]) {
+            while (chosen.length < settings.editionSize) {
+                let best;
+                let bestScore = -Infinity;
+                for (const candidate of prepared) {
+                    const item = candidate.article;
+                    if (item.previouslySelected !== repeats || chosenIds.has(item.id) ||
+                        (feeds.get(item.subscriptionId) ?? 0) >= cap ||
+                        (folders.get(item.folderId) ?? 0) >= Math.max(folderCap, cap) ||
+                        (settings.readingMinutes && minutes + item.readingMinutes > settings.readingMinutes && chosen.length > 0))
+                        continue;
+                    const adjusted = item.score / (1 + (feeds.get(item.subscriptionId) ?? 0) * 0.7 + (folders.get(item.folderId) ?? 0) * 0.35);
+                    if (best && (adjusted < bestScore || (adjusted === bestScore &&
+                        (candidate.published < best.published || (candidate.published === best.published && item.id < best.article.id)))))
+                        continue;
+                    if (chosenKeys.some((selected) => duplicate(selected, candidate)))
+                        continue;
+                    best = candidate;
+                    bestScore = adjusted;
+                }
+                if (!best)
+                    break;
+                const item = best.article;
+                chosen.push(item);
+                chosenKeys.push(best);
+                chosenIds.add(item.id);
+                minutes += item.readingMinutes;
+                feeds.set(item.subscriptionId, (feeds.get(item.subscriptionId) ?? 0) + 1);
+                folders.set(item.folderId, (folders.get(item.folderId) ?? 0) + 1);
+            }
+        }
+    }
+    return chosen;
+}
+const formatters = new Map();
+export function editionPeriod(now, timeZone) {
+    let formatter = formatters.get(timeZone);
+    if (!formatter) {
+        formatter = new Intl.DateTimeFormat("en-CA", { timeZone, year: "numeric", month: "2-digit", day: "2-digit", hour: "2-digit", hourCycle: "h23" });
+        if (formatters.size >= 100)
+            formatters.clear();
+        formatters.set(timeZone, formatter);
+    }
+    const parts = Object.fromEntries(formatter.formatToParts(now).map((part) => [part.type, part.value]));
+    const hour = Number(parts.hour);
+    const period = hour >= 5 && hour < 11 ? "morning" : hour >= 11 && hour < 17 ? "midday" : hour >= 17 && hour < 23 ? "evening" : "late";
+    // The late issue spans midnight; use the preceding calendar date before 05:00.
+    let day = `${parts.year}-${parts.month}-${parts.day}`;
+    if (hour < 5)
+        day = new Date(Date.parse(`${day}T12:00:00Z`) - 86_400_000).toISOString().slice(0, 10);
+    return { key: `${day}:${period}`, period };
+}
+/** Find the next actual boundary in the user's zone, including DST and fractional offsets. */
+export function nextEditionBoundary(now, timeZone) {
+    const key = editionPeriod(now, timeZone).key;
+    let low = Math.floor(now.getTime() / 60_000);
+    let high = low + 60;
+    while (editionPeriod(new Date(high * 60_000), timeZone).key === key)
+        high += 60;
+    while (high - low > 1) {
+        const middle = Math.floor((low + high) / 2);
+        if (editionPeriod(new Date(middle * 60_000), timeZone).key === key)
+            low = middle;
+        else
+            high = middle;
+    }
+    return new Date(high * 60_000);
+}
+//# sourceMappingURL=editionSelection.js.map

package/server/dist/native/editionText.js

@@ -0,0 +1,15 @@
+import { findItemById, canAccessItem } from "../feeds/repository.js";
+import { sourceText, contentMetadata } from "../feeds/articleContent.js";
+/** Complete cached source material; consumers must explicitly chunk their own bounded requests. */
+export function cachedEditionSources(userId, itemIds) {
+    if (itemIds.length > 24 || new Set(itemIds).size !== itemIds.length)
+        throw new Error("invalid_source_selection");
+    return itemIds.map(id => {
+        const item = findItemById(id);
+        if (!item || !canAccessItem(userId, id))
+            throw new Error("item_not_found");
+        return { id, text: sourceText(item), textKind: contentMetadata(item).source,
+            revision: item.content_revision, status: item.extraction_status, truncated: false };
+    });
+}
+//# sourceMappingURL=editionText.js.map

package/server/dist/native/editions.js

@@ -0,0 +1,218 @@
+import { hasUserCapability } from "../auth/capabilities.js";
+import { randomUUID } from "node:crypto";
+import cron from "node-cron";
+import { z } from "zod";
+import { db } from "../db/index.js";
+import { canAccessItem } from "../feeds/repository.js";
+import { decodeEntities } from "../feeds/text.js";
+import { editionPeriod, nextEditionBoundary, selectEdition } from "./editionSelection.js";
+import { getNativePreferences } from "./preferences.js";
+import { NativeError, nativeRequest } from "./requests.js";
+export const overviewSchema = z.array(z.object({
+    heading: z.string().trim().min(1).max(160),
+    segments: z.array(z.object({
+        text: z.string().min(1).max(1000),
+        itemId: z.number().int().positive().optional(),
+    }).strict()).min(1).max(20),
+}).strict()).min(1).max(5).refine((blocks) => blocks.reduce((sum, block) => sum + block.heading.length + block.segments.reduce((n, segment) => n + segment.text.length, 0), 0) <= 3000, "Overview text must not exceed 3000 characters");
+function storedEdition(userId) {
+    return db.prepare("SELECT * FROM editions WHERE user_id = ?").get(userId);
+}
+function serialize(row) {
+    const prefs = getNativePreferences(row.user_id);
+    return {
+        id: row.edition_id, revision: row.revision, source: row.source,
+        createdAt: row.created_at, updatedAt: row.updated_at, expiresAt: row.expires_at,
+        period: row.period?.split(":")[1] ?? editionPeriod(new Date(row.created_at), prefs.timeZone).period,
+        title: row.title, summary: row.summary, overview: row.overview ? JSON.parse(row.overview) : null, preferencesRevision: row.preferences_revision,
+        itemIds: JSON.parse(row.item_ids),
+    };
+}
+export function getEditionState(userId, now = new Date()) {
+    const row = storedEdition(userId);
+    if (!row)
+        return { revision: 0, status: "none", edition: null };
+    const status = row.status === "active" && Date.parse(row.expires_at) <= now.getTime() ? "expired" : row.status;
+    return { revision: row.revision, status, edition: status === "active" ? serialize(row) : null };
+}
+export function getEdition(userId, now = new Date()) {
+    return getEditionState(userId, now).edition;
+}
+function checkRevision(userId, expectedRevision, now) {
+    const current = getEditionState(userId, now);
+    if (expectedRevision !== undefined && current.revision !== expectedRevision)
+        throw new NativeError("revision_conflict", 409, current);
+}
+function writeEdition(userId, itemIds, source, expiry, now, title = null, summary = null, overview = null) {
+    const prefs = getNativePreferences(userId);
+    const id = randomUUID();
+    const revision = (storedEdition(userId)?.revision ?? 0) + 1;
+    const created = now.toISOString();
+    db.prepare(`INSERT INTO editions (user_id, edition_id, item_ids, revision, source, status, created_at, updated_at, expires_at, period, title, summary, preferences_revision, overview)
+    VALUES (?, ?, ?, ?, ?, 'active', ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(user_id) DO UPDATE SET edition_id = excluded.edition_id, item_ids = excluded.item_ids,
+      revision = excluded.revision, source = excluded.source, status = 'active', created_at = excluded.created_at,
+      updated_at = excluded.updated_at, expires_at = excluded.expires_at, period = excluded.period,
+      title = excluded.title, summary = excluded.summary, preferences_revision = excluded.preferences_revision, overview = excluded.overview`)
+        .run(userId, id, JSON.stringify(itemIds), revision, source, created, created, expiry.toISOString(), editionPeriod(now, prefs.timeZone).key, title, summary, prefs.revision, overview ? JSON.stringify(overview.map((block, index) => ({ id: `topic-${index + 1}`, ...block }))) : null);
+    db.prepare("INSERT INTO edition_history (user_id, edition_id, item_ids, revision, created_at) VALUES (?, ?, ?, ?, ?)")
+        .run(userId, id, JSON.stringify(itemIds), revision, created);
+    db.prepare(`DELETE FROM edition_history WHERE user_id = ? AND edition_id NOT IN
+    (SELECT edition_id FROM edition_history WHERE user_id = ? ORDER BY revision DESC LIMIT 32)`)
+        .run(userId, userId);
+    return serialize(storedEdition(userId));
+}
+export const publishEditionFields = {
+    itemIds: z.array(z.number().int().positive()).min(1).max(24),
+    expiresAt: z.string().datetime({ offset: true }).optional(),
+    durationHours: z.number().positive().max(168).optional(),
+    expectedRevision: z.number().int().min(0).optional(),
+    requestId: z.uuid().optional(),
+    title: z.string().trim().min(1).max(200).optional(),
+    summary: z.string().trim().min(1).max(2000).optional(),
+    overview: overviewSchema.optional(),
+};
+const publishSchema = z.object(publishEditionFields).strict().refine((input) => !(input.expiresAt && input.durationHours), "Use expiresAt or durationHours, not both");
+/** Both automatic and MCP editions obey the app's hard exclusions. Read/saved articles
+ * may be selected deliberately by an agent, but foreign and muted items cannot be published. */
+export function publishCuratedEdition(userId, input, now = new Date()) {
+    const parsed = publishSchema.safeParse(input);
+    if (!parsed.success)
+        throw new NativeError("invalid_input");
+    const { requestId, ...data } = parsed.data;
+    return nativeRequest(userId, requestId, "edition.publish", data, () => {
+        checkRevision(userId, data.expectedRevision, now);
+        if (new Set(data.itemIds).size !== data.itemIds.length)
+            throw new NativeError("duplicate_item_ids");
+        if (data.overview?.some((block) => !block.segments.some((segment) => segment.itemId !== undefined) ||
+            block.segments.some((segment) => segment.itemId !== undefined && !data.itemIds.includes(segment.itemId)))) {
+            throw new NativeError("invalid_overview_reference");
+        }
+        const prefs = getNativePreferences(userId);
+        for (const id of data.itemIds) {
+            if (!canAccessItem(userId, id))
+                throw new NativeError("item_not_found", 404);
+            const item = db.prepare(`SELECT s.folder_id, s.id IS NOT NULL AS subscribed,
+          EXISTS (SELECT 1 FROM user_muted_keywords m WHERE m.user_id = ? AND
+            (instr(lower(coalesce(i.title, '')), lower(m.keyword)) > 0 OR instr(lower(coalesce(i.content_snippet, '')), lower(m.keyword)) > 0)) AS muted
+         FROM items i LEFT JOIN subscriptions s ON s.feed_id = i.feed_id AND s.user_id = ? WHERE i.id = ?`).get(userId, userId, id);
+            if (item.muted || (item.subscribed && (item.folder_id === null ? !prefs.showUnfiled : prefs.hiddenFolderIds.includes(item.folder_id)))) {
+                throw new NativeError("item_excluded");
+            }
+        }
+        const expiry = data.expiresAt ? new Date(data.expiresAt) : new Date(now.getTime() + (data.durationHours ?? 24) * 3_600_000);
+        if (expiry.getTime() <= now.getTime() || expiry.getTime() > now.getTime() + 168 * 3_600_000)
+            throw new NativeError("invalid_expiry");
+        return writeEdition(userId, data.itemIds, "curated", expiry, now, data.title ?? null, data.summary ?? (data.overview?.map((block) => `${block.heading}: ${block.segments.map((segment) => segment.text).join("")}`).join("\n\n").slice(0, 2000).replace(/[\uD800-\uDBFF]$/, "") ?? null), data.overview ?? null);
+    }, now);
+}
+/** Compatibility entry point for existing internal callers. New agents supply a
+ * request ID and expected revision to publishCuratedEdition. */
+export function publishEdition(userId, itemIds, expiresAt) {
+    return publishCuratedEdition(userId, { itemIds, ...(expiresAt ? { expiresAt } : {}) });
+}
+export function dismissEdition(userId, input = {}, now = new Date()) {
+    return nativeRequest(userId, input.requestId, "edition.dismiss", { expectedRevision: input.expectedRevision }, () => {
+        checkRevision(userId, input.expectedRevision, now);
+        const row = storedEdition(userId);
+        if (row && row.status !== "dismissed") {
+            db.prepare("UPDATE editions SET status = 'dismissed', revision = revision + 1, updated_at = ?, period = ? WHERE user_id = ?")
+                .run(now.toISOString(), editionPeriod(now, getNativePreferences(userId).timeZone).key, userId);
+        }
+        return getEditionState(userId, now);
+    }, now);
+}
+export function deleteEdition(userId) {
+    const existed = Boolean(getEdition(userId));
+    dismissEdition(userId);
+    return existed;
+}
+export function editionCandidates(userId, now = new Date(), limit = 200) {
+    const prefs = getNativePreferences(userId);
+    const previous = new Set(db.prepare("SELECT item_ids FROM edition_history WHERE user_id = ? AND created_at >= ?").all(userId, new Date(now.getTime() - 72 * 3_600_000).toISOString()).flatMap((row) => JSON.parse(row.item_ids)));
+    // Fetch bounded candidates per source, so a busy feed cannot hide the others.
+    const rows = db.prepare(`SELECT * FROM (
+      SELECT i.id, i.feed_id, s.folder_id, i.title, i.link, i.content_snippet, i.image_url,
+        coalesce(s.label, f.title) AS source_name, folders.name AS folder_name,
+        strftime('%Y-%m-%dT%H:%M:%fZ', coalesce(julianday(i.published_at), julianday(i.created_at))) AS published,
+        length(coalesce(i.full_content_html, i.content_html, i.content_snippet, '')) AS content_chars,
+        row_number() OVER (PARTITION BY i.feed_id ORDER BY coalesce(julianday(i.published_at), julianday(i.created_at)) DESC, i.id DESC) AS source_rank
+      FROM items i JOIN subscriptions s ON s.feed_id = i.feed_id AND s.user_id = ?
+      JOIN feeds f ON f.id = i.feed_id LEFT JOIN folders ON folders.id = s.folder_id
+      WHERE NOT EXISTS (SELECT 1 FROM item_reads r WHERE r.item_id = i.id AND r.user_id = ?)
+        AND NOT EXISTS (SELECT 1 FROM user_muted_keywords m WHERE m.user_id = ? AND
+          (instr(lower(coalesce(i.title, '')), lower(m.keyword)) > 0 OR instr(lower(coalesce(i.content_snippet, '')), lower(m.keyword)) > 0))
+        AND coalesce(julianday(i.published_at), julianday(i.created_at)) BETWEEN julianday(?) AND julianday(?)
+    ) WHERE source_rank <= 40 ORDER BY source_rank, published DESC, id DESC LIMIT 4000`)
+        .all(userId, userId, userId, new Date(now.getTime() - 7 * 86_400_000).toISOString(), now.toISOString());
+    const scored = rows.filter((row) => row.folder_id === null ? prefs.showUnfiled : !prefs.hiddenFolderIds.includes(row.folder_id))
+        .map((row) => ({
+        id: row.id, sourceName: row.source_name, folderName: row.folder_name, subscriptionId: row.feed_id, folderId: row.folder_id,
+        title: row.title, url: row.link, publishedAt: row.published, snippet: decodeEntities(row.content_snippet) ?? null, imageUrl: row.image_url,
+        readingMinutes: Math.max(1, Math.ceil(row.content_chars / 1400)), previouslySelected: previous.has(row.id),
+        score: Math.pow(0.5, Math.max(0, now.getTime() - Date.parse(row.published)) / (18 * 3_600_000)) *
+            (row.folder_id !== null && prefs.preferredFolderIds.includes(row.folder_id) ? 1.4 : 1),
+    }));
+    // Candidate requests expose a diversified shortlist rather than only the busiest source.
+    if (limit < scored.length) {
+        const sorted = selectEdition(scored, { ...prefs, editionSize: Math.min(limit, 24), readingMinutes: null });
+        const selected = new Set(sorted.map((item) => item.id));
+        return [...sorted, ...scored.filter((item) => !selected.has(item.id)).sort((a, b) => b.score - a.score || b.id - a.id)].slice(0, limit);
+    }
+    return scored.sort((a, b) => b.score - a.score || b.id - a.id);
+}
+export const generateEditionSchema = z.object({
+    requestId: z.uuid(),
+    expectedRevision: z.number().int().min(0).optional(),
+    force: z.boolean().default(false),
+}).strict().refine((input) => !input.force || input.expectedRevision !== undefined, "force requires expectedRevision");
+export function generateEdition(userId, input = {}, now = new Date()) {
+    return nativeRequest(userId, input.requestId, "edition.generate", { expectedRevision: input.expectedRevision, force: input.force ?? false }, () => {
+        checkRevision(userId, input.expectedRevision, now);
+        const prefs = getNativePreferences(userId);
+        const period = editionPeriod(now, prefs.timeZone).key;
+        const state = getEditionState(userId, now);
+        if (state.edition) {
+            if (state.edition.source === "curated") {
+                if (input.force)
+                    throw new NativeError("curated_edition_active", 409, state);
+                return state.edition;
+            }
+            if (!input.force)
+                return state.edition;
+        }
+        const row = storedEdition(userId);
+        if (!input.force && row?.status === "dismissed" && row.period === period)
+            return null;
+        if (row?.status === "active" && !state.edition) {
+            db.prepare("UPDATE editions SET status = 'expired', revision = revision + 1, updated_at = ? WHERE user_id = ?").run(now.toISOString(), userId);
+        }
+        const chosen = selectEdition(editionCandidates(userId, now, 4000), prefs);
+        if (!chosen.length)
+            return state.edition;
+        if (state.edition && JSON.stringify(state.edition.itemIds) === JSON.stringify(chosen.map((item) => item.id)))
+            return state.edition;
+        return writeEdition(userId, chosen.map((item) => item.id), "automatic", nextEditionBoundary(now, prefs.timeZone), now);
+    }, now);
+}
+/** Only users who opted in by storing preferences or creating an edition are scheduled. */
+export function maintainEditions(now = new Date()) {
+    const users = db.prepare("SELECT user_id FROM native_preferences UNION SELECT user_id FROM editions").all();
+    for (const user of users) {
+        if (!hasUserCapability(user.user_id, "editions"))
+            continue;
+        try {
+            generateEdition(user.user_id, {}, now);
+        }
+        catch (error) {
+            console.error("[edition] could not refresh an edition", error instanceof Error ? error.message : "unknown error");
+        }
+    }
+    // Receipts remain valid for at least 35 days, beyond the native offline window.
+    db.prepare("DELETE FROM native_requests WHERE created_at < ?").run(new Date(now.getTime() - 35 * 86_400_000).toISOString());
+}
+export function startEditionScheduler() {
+    maintainEditions();
+    cron.schedule("* * * * *", () => maintainEditions());
+}
+//# sourceMappingURL=editions.js.map

package/server/dist/native/preferences.js

@@ -0,0 +1,66 @@
+import { z } from "zod";
+import { db } from "../db/index.js";
+import { NativeError, nativeRequest } from "./requests.js";
+export const folderId = z.number().int().positive();
+const distinctIds = z.array(folderId).max(1000).refine((ids) => new Set(ids).size === ids.length, "IDs must be unique");
+const timezone = z.string().max(100).refine((value) => {
+    try {
+        new Intl.DateTimeFormat("en", { timeZone: value });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}, "Use an IANA time zone");
+export const preferenceFields = {
+    timeZone: timezone,
+    editionSize: z.number().int().min(1).max(24).nullable(),
+    readingMinutes: z.number().int().min(5).max(180).nullable(),
+    folderOrder: z.array(folderId.nullable()).max(1001).refine((ids) => new Set(ids).size === ids.length, "IDs must be unique"),
+    hiddenFolderIds: distinctIds,
+    preferredFolderIds: distinctIds,
+    showUnfiled: z.boolean(),
+};
+export const preferencePatchSchema = z.object(preferenceFields).partial().extend({
+    requestId: z.uuid(),
+    expectedRevision: z.number().int().min(0),
+}).strict();
+const defaults = {
+    timeZone: "UTC", editionSize: 24, editionSizeIsCustom: false, readingMinutes: null,
+    folderOrder: [], hiddenFolderIds: [], preferredFolderIds: [], showUnfiled: true,
+};
+export function getNativePreferences(userId) {
+    const row = db.prepare("SELECT revision, settings, updated_at FROM native_preferences WHERE user_id = ?").get(userId);
+    const stored = row ? JSON.parse(row.settings) : {};
+    // Legacy non-default values express intent. Legacy 24 is indistinguishable from
+    // an implicit default recorded by a folder-only write; treat it as the default.
+    return { ...defaults, ...stored, editionSizeIsCustom: stored.editionSizeIsCustom ?? (stored.editionSize != null && stored.editionSize !== 24), revision: row?.revision ?? 0, updatedAt: row?.updated_at ?? null };
+}
+export function patchNativePreferences(userId, input) {
+    const parsed = preferencePatchSchema.safeParse(input);
+    if (!parsed.success)
+        throw new NativeError("invalid_input");
+    const { requestId, expectedRevision, ...patch } = parsed.data;
+    return nativeRequest(userId, requestId, "preferences.patch", { expectedRevision, ...patch }, () => {
+        const current = getNativePreferences(userId);
+        if (current.revision !== expectedRevision)
+            throw new NativeError("revision_conflict", 409, current);
+        const ownedIds = new Set(db.prepare("SELECT id FROM folders WHERE user_id = ?").all(userId).map((f) => f.id));
+        for (const ids of [patch.folderOrder, patch.hiddenFolderIds, patch.preferredFolderIds]) {
+            if (ids?.some((id) => id !== null && !ownedIds.has(id)))
+                throw new NativeError("folder_not_found", 404);
+        }
+        const { revision, updatedAt: _updatedAt, ...settings } = current;
+        const next = { ...settings, ...patch, editionSize: patch.editionSize === null ? defaults.editionSize : patch.editionSize ?? current.editionSize,
+            editionSizeIsCustom: patch.editionSize === undefined ? current.editionSizeIsCustom : patch.editionSize !== null };
+        // The first write records ownership of defaults, allowing a one-time local migration.
+        if (revision > 0 && JSON.stringify(settings) === JSON.stringify(next))
+            return current;
+        const now = new Date().toISOString();
+        db.prepare(`INSERT INTO native_preferences (user_id, revision, settings, updated_at) VALUES (?, ?, ?, ?)
+      ON CONFLICT(user_id) DO UPDATE SET revision = excluded.revision, settings = excluded.settings, updated_at = excluded.updated_at`)
+            .run(userId, revision + 1, JSON.stringify(next), now);
+        return getNativePreferences(userId);
+    });
+}
+//# sourceMappingURL=preferences.js.map

package/server/dist/native/requests.js

@@ -0,0 +1,35 @@
+import { createHash } from "node:crypto";
+import { db } from "../db/index.js";
+export class NativeError extends Error {
+    code;
+    status;
+    current;
+    constructor(code, status = 400, current) {
+        super(code);
+        this.code = code;
+        this.status = status;
+        this.current = current;
+    }
+}
+/** An operation and its receipt commit together. Replays return the original result,
+ * even after newer changes; reusing an ID with a different payload is rejected. */
+export function nativeRequest(userId, requestId, operation, input, action, now = new Date()) {
+    return db.transaction(() => {
+        const fingerprint = createHash("sha256").update(JSON.stringify([operation, input])).digest("hex");
+        if (requestId) {
+            const receipt = db.prepare("SELECT fingerprint, response FROM native_requests WHERE user_id = ? AND request_id = ?").get(userId, requestId);
+            if (receipt) {
+                if (receipt.fingerprint !== fingerprint)
+                    throw new NativeError("request_id_reused", 409);
+                return JSON.parse(receipt.response);
+            }
+        }
+        const result = action();
+        if (requestId) {
+            db.prepare("INSERT INTO native_requests (user_id, request_id, fingerprint, response, created_at) VALUES (?, ?, ?, ?, ?)")
+                .run(userId, requestId, fingerprint, JSON.stringify(result), now.toISOString());
+        }
+        return result;
+    })();
+}
+//# sourceMappingURL=requests.js.map

package/server/dist/oauth/constants.js

@@ -0,0 +1,6 @@
+import { config } from "../config.js";
+/** The address clients know this server by; OAuth tokens are bound to the /mcp resource below it. */
+export const ISSUER = config.publicUrl.replace(/\/+$/, "");
+export const MCP_RESOURCE = `${ISSUER}/mcp`;
+export const RESOURCE_METADATA_URL = `${ISSUER}/.well-known/oauth-protected-resource/mcp`;
+//# sourceMappingURL=constants.js.map

package/server/dist/oauth/host.js

@@ -0,0 +1,8 @@
+let activeHost = null;
+export function setOAuthHost(host) {
+    activeHost = host;
+}
+export function getOAuthHost() {
+    return activeHost;
+}
+//# sourceMappingURL=host.js.map

package/server/dist/oauth/pages.js

@@ -0,0 +1,148 @@
+const strings = {
+    en: {
+        passkey: "Use a passkey",
+        loginTitle: "Sign in to FeedKeeper",
+        loginIntro: "{client} wants to connect to your FeedKeeper account. Sign in to continue.",
+        email: "Email",
+        password: "Password",
+        signIn: "Sign in",
+        badLogin: "Email or password is wrong.",
+        consentTitle: "Allow access?",
+        consentIntro: "{client} wants to access your FeedKeeper account through MCP.",
+        returnsTo: "After you decide, you are sent back to {host}.",
+        readOnly: "Read only",
+        readOnlyHint: "Look up feeds and articles. Changes nothing.",
+        readWrite: "Read and write",
+        readWriteHint: "Also mark articles read, bookmark, and manage feeds and folders.",
+        allow: "Allow",
+        deny: "Deny",
+        signedInAs: "Signed in as {user}",
+        errorTitle: "This request cannot be completed",
+        unknownClient: "The app is not registered with this server.",
+        badRedirect: "The return address does not match the app's registration.",
+        noAccess: "Your account does not include MCP access.",
+        manage: "Manage your plan",
+        forbidden: "The request came from another site and was blocked.",
+    },
+    de: {
+        passkey: "Mit Passkey anmelden",
+        loginTitle: "Bei FeedKeeper anmelden",
+        loginIntro: "{client} möchte sich mit deinem FeedKeeper-Konto verbinden. Melde dich an, um fortzufahren.",
+        email: "E-Mail",
+        password: "Passwort",
+        signIn: "Anmelden",
+        badLogin: "E-Mail oder Passwort ist falsch.",
+        consentTitle: "Zugriff erlauben?",
+        consentIntro: "{client} möchte über MCP auf dein FeedKeeper-Konto zugreifen.",
+        returnsTo: "Nach deiner Entscheidung geht es zurück zu {host}.",
+        readOnly: "Nur lesen",
+        readOnlyHint: "Feeds und Artikel abrufen. Ändert nichts.",
+        readWrite: "Lesen und schreiben",
+        readWriteHint: "Zusätzlich Artikel als gelesen markieren, merken sowie Feeds und Ressorts verwalten.",
+        allow: "Erlauben",
+        deny: "Ablehnen",
+        signedInAs: "Angemeldet als {user}",
+        errorTitle: "Die Anfrage kann nicht abgeschlossen werden",
+        unknownClient: "Die App ist bei diesem Server nicht registriert.",
+        badRedirect: "Die Rücksprungadresse passt nicht zur Registrierung der App.",
+        noAccess: "Dein Konto enthält keinen MCP-Zugriff.",
+        manage: "Tarif verwalten",
+        forbidden: "Die Anfrage kam von einer anderen Website und wurde blockiert.",
+    },
+    ja: {
+        passkey: "パスキーでサインイン",
+        loginTitle: "FeedKeeperにサインイン",
+        loginIntro: "{client} がFeedKeeperアカウントへの接続を求めています。続けるにはサインインしてください。",
+        email: "メールアドレス",
+        password: "パスワード",
+        signIn: "サインイン",
+        badLogin: "メールアドレスまたはパスワードが正しくありません。",
+        consentTitle: "アクセスを許可しますか？",
+        consentIntro: "{client} がMCP経由でFeedKeeperアカウントにアクセスしようとしています。",
+        returnsTo: "選択後は {host} に戻ります。",
+        readOnly: "読み取りのみ",
+        readOnlyHint: "フィードと記事を参照します。変更はしません。",
+        readWrite: "読み取りと書き込み",
+        readWriteHint: "記事の既読化、ブックマーク、フィードとフォルダの管理も行えます。",
+        allow: "許可",
+        deny: "拒否",
+        signedInAs: "{user} としてサインイン中",
+        errorTitle: "このリクエストは完了できません",
+        unknownClient: "このアプリはこのサーバーに登録されていません。",
+        badRedirect: "戻り先のアドレスがアプリの登録と一致しません。",
+        noAccess: "お使いのアカウントにはMCPアクセスが含まれていません。",
+        manage: "プランを管理",
+        forbidden: "別のサイトからのリクエストのためブロックしました。",
+    },
+};
+function languageOf(req) {
+    const header = String(req.headers["accept-language"] ?? "").toLowerCase();
+    for (const part of header.split(",")) {
+        const tag = part.trim().slice(0, 2);
+        if (tag === "de" || tag === "ja" || tag === "en")
+            return tag;
+    }
+    return "en";
+}
+export function escapeHtml(value) {
+    return value.replace(/[&<>"']/g, (char) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[char]);
+}
+function text(lang, key, values = {}) {
+    const template = strings[lang][key];
+    return escapeHtml(template.replace(/\{(\w+)\}/g, (_match, name) => values[name] ?? ""));
+}
+function layout(lang, title, body) {
+    return `<!doctype html>
+<html lang="${lang}"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
+<meta name="robots" content="noindex"><title>${title}</title>
+<style>
+:root{--bg:#f6f7f8;--card:#fff;--text:#1d2329;--muted:#5c6770;--line:#d9dee2;--accent:#3d5a73;--accent-text:#fff}
+@media (prefers-color-scheme:dark){:root{--bg:#14181c;--card:#1e242a;--text:#e8ecef;--muted:#9aa6b0;--line:#323a42;--accent:#8fb0cc;--accent-text:#10161b}}
+*{box-sizing:border-box}body{margin:0;min-height:100vh;display:flex;align-items:center;justify-content:center;padding:16px;background:var(--bg);color:var(--text);font:16px/1.45 -apple-system,BlinkMacSystemFont,"Segoe UI",Inter,sans-serif}
+main{width:100%;max-width:420px;background:var(--card);border:1px solid var(--line);border-radius:16px;padding:28px}
+h1{font-size:1.35rem;margin:0 0 8px}p{margin:0 0 16px}.muted{color:var(--muted);font-size:.9rem}
+label.field{display:block;font-weight:600;font-size:.9rem;margin-bottom:12px}
+input[type=email],input[type=password]{display:block;width:100%;margin-top:4px;padding:10px 12px;border:1px solid var(--line);border-radius:10px;background:var(--bg);color:var(--text);font:inherit}
+.choice{display:flex;gap:10px;align-items:flex-start;padding:12px;border:1px solid var(--line);border-radius:12px;margin-bottom:10px;cursor:pointer}
+.choice input{margin-top:4px}.choice strong{display:block}.choice span{color:var(--muted);font-size:.88rem}
+.row{display:flex;gap:10px;margin-top:20px}button{flex:1;padding:11px 14px;border-radius:10px;border:1px solid var(--line);background:transparent;color:var(--text);font:inherit;font-weight:600;cursor:pointer}
+button.primary{background:var(--accent);border-color:var(--accent);color:var(--accent-text)}.error{color:#b3261e}a{color:var(--accent)}
+</style></head><body><main>${body}</main></body></html>`;
+}
+export function hidden(name, value) {
+    return `<input type="hidden" name="${escapeHtml(name)}" value="${escapeHtml(value)}">`;
+}
+export function renderLogin(req, input) {
+    const lang = languageOf(req);
+    return layout(lang, text(lang, "loginTitle"), `
+<h1>${text(lang, "loginTitle")}</h1>
+<p>${text(lang, "loginIntro", { client: input.clientName })}</p>
+${input.failed ? `<p class="error" role="alert">${text(lang, "badLogin")}</p>` : ""}
+<form method="post" action="/oauth/authorize/login">
+${hidden("return_to", input.returnTo)}
+<label class="field">${text(lang, "email")}<input type="email" name="email" required autofocus autocomplete="username"></label>
+<label class="field">${text(lang, "password")}<input type="password" name="password" required autocomplete="current-password"></label>
+<div class="row"><button class="primary" type="submit">${text(lang, "signIn")}</button></div>
+</form>
+<p><a href="/login?next=${encodeURIComponent(input.returnTo)}">${text(lang, "passkey")}</a></p>`);
+}
+export function renderConsent(req, input) {
+    const lang = languageOf(req);
+    const radio = (value, label, hint) => `<label class="choice"><input type="radio" name="grant_scope" value="${value}"${input.preselect === value ? " checked" : ""}><div><strong>${text(lang, label)}</strong><span>${text(lang, hint)}</span></div></label>`;
+    return layout(lang, text(lang, "consentTitle"), `
+<h1>${text(lang, "consentTitle")}</h1>
+<p>${text(lang, "consentIntro", { client: input.clientName })}</p>
+<form method="post" action="/oauth/authorize/decision">
+${Object.entries(input.fields).map(([name, value]) => hidden(name, value)).join("\n")}
+${radio("read", "readOnly", "readOnlyHint")}
+${input.allowWrite ? radio("write", "readWrite", "readWriteHint") : ""}
+<p class="muted">${text(lang, "returnsTo", { host: input.redirectHost })}<br>${text(lang, "signedInAs", { user: input.userName })}</p>
+<div class="row"><button type="submit" name="decision" value="deny">${text(lang, "deny")}</button><button class="primary" type="submit" name="decision" value="allow">${text(lang, "allow")}</button></div>
+</form>`);
+}
+export function renderError(req, key, manageUrl) {
+    const lang = languageOf(req);
+    const link = manageUrl && /^https?:\/\//.test(manageUrl) ? `<p><a href="${escapeHtml(manageUrl)}">${text(lang, "manage")}</a></p>` : "";
+    return layout(lang, text(lang, "errorTitle"), `<h1>${text(lang, "errorTitle")}</h1><p>${text(lang, key)}</p>${link}`);
+}
+//# sourceMappingURL=pages.js.map