feedkeeper 0.0.0-stage → 0.23.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Christian Hamann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,23 @@
-# Temporary Holding Version
+# FeedKeeper
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A lightweight, self-hosted RSS reader and remote MCP server. One Node process, one SQLite file.
+
+```bash
+npx feedkeeper
+```
+
+Open <http://localhost:3000> and finish the setup in the browser. The database, the archive of saved
+articles and a generated session secret live in `~/.feedkeeper`.
+
+```text
+feedkeeper [--port <number>] [--public-url <url>] [--data-dir <folder>]
+feedkeeper backup <file>
+feedkeeper restore <file> --force
+```
+
+Requires Node.js ^22.22.2 || ^24.15.0 || >=26.0.0. A `.env` file in the current folder is read; the settings
+are the ones of [.env.example](https://github.com/visualfusion/feedkeeper/blob/main/.env.example).
+
+Documentation, Docker images and the changelog: <https://github.com/visualfusion/feedkeeper>
+
+MIT licensed.

package/package.json

@@ -1,6 +1,59 @@
 {
   "name": "feedkeeper",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.23.0",
+  "description": "A lightweight, self-hosted RSS reader and remote MCP server for your news, blogs, and AI workflows.",
+  "keywords": [
+    "rss",
+    "atom",
+    "feed-reader",
+    "self-hosted",
+    "mcp",
+    "model-context-protocol",
+    "sqlite"
+  ],
+  "license": "MIT",
+  "homepage": "https://github.com/visualfusion/feedkeeper#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/visualfusion/feedkeeper.git"
+  },
+  "bugs": {
+    "url": "https://github.com/visualfusion/feedkeeper/issues"
+  },
+  "bin": {
+    "feedkeeper": "server/dist/feedkeeper.js"
+  },
+  "engines": {
+    "node": "^22.22.2 || ^24.15.0 || >=26.0.0"
+  },
+  "files": [
+    "server",
+    "web",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {
+    "@humanwhocodes/ico-to-png": "^1.1.0",
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "@mozilla/readability": "^0.6.0",
+    "@resvg/resvg-js": "^2.6.2",
+    "@simplewebauthn/server": "^14.0.3",
+    "bcryptjs": "^3.0.3",
+    "better-sqlite3": "^13.0.3",
+    "cookie-session": "^2.1.1",
+    "cors": "^2.8.6",
+    "dotenv": "^18.0.5",
+    "express": "^5.2.1",
+    "express-rate-limit": "^8.7.1",
+    "fast-xml-parser": "^5.11.2",
+    "helmet": "^8.3.0",
+    "ipaddr.js": "^1.9.1",
+    "jsdom": "^30.1.2",
+    "node-cron": "^4.6.0",
+    "otpauth": "^9.5.2",
+    "rss-parser": "^3.13.0",
+    "undici": "^8.11.2",
+    "web-push": "^3.6.7",
+    "zod": "^4.6.5"
+  }
+}

package/server/dist/api/archive.js

@@ -0,0 +1,19 @@
+import { Router } from "express";
+import { requireSession } from "../auth/middleware.js";
+import { findArchivedImage } from "../feeds/archive.js";
+export const archiveRouter = Router();
+archiveRouter.use(requireSession);
+archiveRouter.get("/images/:imageId", (req, res) => {
+    const image = findArchivedImage(req.user.id, Number(req.params.imageId));
+    if (!image) {
+        res.status(404).json({ error: "not_found" });
+        return;
+    }
+    // Archived files never change; the URL is tied to one stored copy.
+    res.setHeader("Cache-Control", "private, max-age=31536000, immutable");
+    res.type(image.mime).sendFile(image.path, (error) => {
+        if (error && !res.headersSent)
+            res.status(404).json({ error: "not_found" });
+    });
+});
+//# sourceMappingURL=archive.js.map

package/server/dist/api/auth.js

@@ -0,0 +1,162 @@
+import express, { Router } from "express";
+import rateLimit from "express-rate-limit";
+import { z } from "zod";
+import { config } from "../config.js";
+import { requireSession, requireAdmin } from "../auth/middleware.js";
+import { createUser, deleteUserAvatar, findUserByEmail, findUserById, getUserAvatar, listUsers, setUserAvatar, toPublicUser, updateDisplayName, dismissIntro, updateUserPassword, } from "../auth/users.js";
+import { AVATAR_MAX_BYTES, detectAvatarType } from "../auth/avatar.js";
+import { verifyPassword } from "../auth/password.js";
+import { getUserCapabilities } from "../auth/capabilities.js";
+import { beginMfa, securityVersion } from "../auth/security.js";
+import { createSecurityRouter } from "../auth/securityRoutes.js";
+export const authRouter = Router();
+authRouter.use("/security", createSecurityRouter({ completeLogin: (req, res, userId) => {
+        req.session = { userId, securityVersion: securityVersion(userId) };
+        res.json(toPublicUser(findUserById(userId)));
+    } }));
+const loginLimiter = rateLimit({
+    windowMs: 15 * 60 * 1000,
+    limit: 10,
+    standardHeaders: true,
+    legacyHeaders: false,
+});
+const loginSchema = z.object({
+    email: z.string().email(),
+    password: z.string().min(1),
+});
+authRouter.post("/login", loginLimiter, (req, res) => {
+    const parsed = loginSchema.safeParse(req.body);
+    if (!parsed.success) {
+        res.status(400).json({ error: "invalid_input" });
+        return;
+    }
+    const user = findUserByEmail(parsed.data.email);
+    if (!user || !verifyPassword(parsed.data.password, user.password_hash)) {
+        res.status(401).json({ error: "invalid_credentials" });
+        return;
+    }
+    const mfa = beginMfa(req, user.id, "web", {});
+    if (mfa) {
+        res.status(403).json(mfa);
+        return;
+    }
+    req.session = { userId: user.id, securityVersion: securityVersion(user.id) };
+    res.json(toPublicUser(user));
+});
+authRouter.post("/logout", (req, res) => {
+    req.session = null;
+    res.status(204).end();
+});
+authRouter.get("/me", requireSession, (req, res) => {
+    res.json({
+        ...req.user,
+        capabilities: getUserCapabilities(req.user.id),
+    });
+});
+const profileSchema = z.object({
+    displayName: z.string().trim().min(1).max(100),
+});
+authRouter.patch("/me", requireSession, (req, res) => {
+    const parsed = profileSchema.safeParse(req.body);
+    if (!parsed.success) {
+        res.status(400).json({ error: "invalid_input", details: parsed.error.flatten() });
+        return;
+    }
+    updateDisplayName(req.user.id, parsed.data.displayName);
+    res.json(toPublicUser(findUserById(req.user.id)));
+});
+// The introduction to the app is shown once per account; closing it on one device closes it everywhere.
+authRouter.post("/me/intro", requireSession, (req, res) => {
+    dismissIntro(req.user.id);
+    res.json(toPublicUser(findUserById(req.user.id)));
+});
+authRouter.get("/me/avatar", requireSession, (req, res) => {
+    const avatar = getUserAvatar(req.user.id);
+    if (!avatar) {
+        res.status(404).json({ error: "not_found" });
+        return;
+    }
+    // The client adds the update timestamp to the URL, so a changed photo gets a new cache key.
+    res.setHeader("Cache-Control", "private, max-age=31536000, immutable");
+    res.type(avatar.mime_type).send(avatar.data);
+});
+authRouter.put("/me/avatar", requireSession, express.raw({ type: ["image/jpeg", "image/png", "image/webp"], limit: AVATAR_MAX_BYTES }), (req, res) => {
+    const data = Buffer.isBuffer(req.body) ? req.body : null;
+    const mimeType = data ? detectAvatarType(data) : null;
+    if (!data || !mimeType) {
+        res.status(400).json({ error: "invalid_image" });
+        return;
+    }
+    setUserAvatar(req.user.id, mimeType, data);
+    res.json(toPublicUser(findUserById(req.user.id)));
+});
+authRouter.delete("/me/avatar", requireSession, (req, res) => {
+    deleteUserAvatar(req.user.id);
+    res.json(toPublicUser(findUserById(req.user.id)));
+});
+const changePasswordSchema = z.object({
+    currentPassword: z.string().min(1),
+    newPassword: z.string().min(10),
+});
+authRouter.post("/change-password", requireSession, loginLimiter, (req, res) => {
+    const parsed = changePasswordSchema.safeParse(req.body);
+    if (!parsed.success) {
+        res.status(400).json({ error: "invalid_input", details: parsed.error.flatten() });
+        return;
+    }
+    const user = findUserById(req.user.id);
+    if (!verifyPassword(parsed.data.currentPassword, user.password_hash)) {
+        res.status(401).json({ error: "invalid_credentials" });
+        return;
+    }
+    updateUserPassword(user.id, parsed.data.newPassword);
+    res.status(204).end();
+});
+const createUserSchema = z.object({
+    email: z.string().email(),
+    password: z.string().min(10),
+    displayName: z.string().min(1).max(100),
+    role: z.enum(["admin", "user"]).default("user"),
+});
+// Admin-only user management. Signup stays closed by default (config.allowSignup);
+// this is how additional accounts get created on a locked-down instance.
+authRouter.get("/users", requireSession, requireAdmin, (_req, res) => {
+    res.json(listUsers());
+});
+authRouter.post("/users", requireSession, requireAdmin, (req, res) => {
+    const parsed = createUserSchema.safeParse(req.body);
+    if (!parsed.success) {
+        res.status(400).json({ error: "invalid_input", details: parsed.error.flatten() });
+        return;
+    }
+    if (findUserByEmail(parsed.data.email)) {
+        res.status(409).json({ error: "email_taken" });
+        return;
+    }
+    const user = createUser(parsed.data);
+    res.status(201).json(toPublicUser(user));
+});
+const signupSchema = z.object({
+    email: z.string().email(),
+    password: z.string().min(10),
+    displayName: z.string().min(1).max(100),
+});
+authRouter.post("/signup", (req, res) => {
+    if (!config.allowSignup) {
+        res.status(403).json({ error: "signup_disabled" });
+        return;
+    }
+    const parsed = signupSchema.safeParse(req.body);
+    if (!parsed.success) {
+        res.status(400).json({ error: "invalid_input", details: parsed.error.flatten() });
+        return;
+    }
+    if (findUserByEmail(parsed.data.email)) {
+        res.status(409).json({ error: "email_taken" });
+        return;
+    }
+    const user = createUser({ ...parsed.data, role: "user" });
+    req.session.userId = user.id;
+    res.status(201).json(toPublicUser(user));
+});
+//# sourceMappingURL=auth.js.map

package/server/dist/api/feeds.js

@@ -0,0 +1,207 @@
+import { Router } from "express";
+import { z } from "zod";
+import { requireSession } from "../auth/middleware.js";
+import { requireCapability } from "../auth/capabilities.js";
+import { listSubscriptionsForUser, findFeedById, isUserSubscribed, reorderSubscriptions } from "../feeds/repository.js";
+import { subscribeToFeed, unsubscribeFromFeed, updateFeedSettings, FeedError, MultipleFeedsFoundError } from "../feeds/service.js";
+import { SsrfBlockedError, normalizeUrlCandidate } from "../feeds/ssrfGuard.js";
+import { generateOpml, importOpmlFeeds } from "../feeds/opml.js";
+import { pollFeed, pollFeeds } from "../feeds/poller.js";
+import { discoverFeeds } from "../feeds/discovery.js";
+import { canAccessFeed, loadFeedIcon } from "../feeds/feedIcon.js";
+import rateLimit from "express-rate-limit";
+export const feedsRouter = Router();
+feedsRouter.use(requireSession);
+// Adding and updating feeds belongs to the plan's sync feature; reading, exporting and deleting stay available without it.
+const requireSync = requireCapability("sync");
+feedsRouter.get("/", (req, res) => {
+    res.json(listSubscriptionsForUser(req.user.id));
+});
+const reorderSchema = z.object({
+    feedIds: z.array(z.number().int().positive()),
+});
+feedsRouter.put("/reorder", (req, res) => {
+    const parsed = reorderSchema.safeParse(req.body);
+    if (!parsed.success) {
+        res.status(400).json({ error: "invalid_feed_ids" });
+        return;
+    }
+    const currentIds = listSubscriptionsForUser(req.user.id).map((feed) => feed.id);
+    const requestedIds = parsed.data.feedIds;
+    if (requestedIds.length !== currentIds.length ||
+        new Set(requestedIds).size !== currentIds.length ||
+        requestedIds.some((id) => !currentIds.includes(id))) {
+        res.status(400).json({ error: "invalid_feed_ids" });
+        return;
+    }
+    reorderSubscriptions(req.user.id, requestedIds);
+    res.json({ ok: true });
+});
+const iconLimiter = rateLimit({ windowMs: 60 * 1000, limit: 600, standardHeaders: true, legacyHeaders: false });
+// A feed's icon through this server, so it can be stored for offline use.
+feedsRouter.get("/:feedId/icon", iconLimiter, async (req, res) => {
+    const feedId = Number(req.params.feedId);
+    const icon = canAccessFeed(req.user.id, feedId) ? await loadFeedIcon(feedId) : null;
+    if (!icon) {
+        res.status(404).json({ error: "not_found" });
+        return;
+    }
+    res.setHeader("Cache-Control", "private, max-age=86400");
+    // SVG icons must never run scripts, even when opened directly.
+    res.setHeader("Content-Security-Policy", "default-src 'none'; style-src 'unsafe-inline'; sandbox");
+    res.type(icon.mime).send(icon.buffer);
+});
+feedsRouter.get("/opml", (req, res) => {
+    const opml = generateOpml(req.user.id);
+    res.setHeader("Content-Type", "application/xml; charset=utf-8");
+    res.setHeader("Content-Disposition", 'attachment; filename="feedkeeper-subscriptions.opml"');
+    res.send(opml);
+});
+feedsRouter.post("/opml", requireSync, async (req, res) => {
+    const xmlContent = typeof req.body === "string"
+        ? req.body
+        : typeof req.body?.opml === "string"
+            ? req.body.opml
+            : null;
+    if (!xmlContent || !xmlContent.trim()) {
+        res.status(400).json({ error: "missing_opml_content" });
+        return;
+    }
+    try {
+        const result = await importOpmlFeeds(req.user.id, xmlContent);
+        res.json(result);
+    }
+    catch (error) {
+        res.status(400).json({
+            error: "invalid_opml",
+            message: error instanceof Error ? error.message : String(error),
+        });
+    }
+});
+const urlField = z.preprocess((val) => (typeof val === "string" ? normalizeUrlCandidate(val) : val), z.string().url());
+const discoverSchema = z.object({
+    url: urlField,
+});
+feedsRouter.post("/discover", requireSync, async (req, res) => {
+    const parsed = discoverSchema.safeParse(req.body);
+    if (!parsed.success) {
+        res.status(400).json({ error: "invalid_input", details: parsed.error.flatten() });
+        return;
+    }
+    try {
+        const feeds = await discoverFeeds(parsed.data.url);
+        res.json({ feeds });
+    }
+    catch (error) {
+        if (error instanceof SsrfBlockedError) {
+            res.status(400).json({ error: "blocked_url", message: error.message });
+            return;
+        }
+        res.status(400).json({ error: "discovery_failed", message: error instanceof Error ? error.message : String(error) });
+    }
+});
+const subscribeSchema = z.object({
+    url: urlField,
+    label: z.string().max(200).nullable().optional(),
+    folderId: z.number().int().positive().nullable().optional(),
+});
+feedsRouter.post("/", requireSync, async (req, res) => {
+    const parsed = subscribeSchema.safeParse(req.body);
+    if (!parsed.success) {
+        res.status(400).json({ error: "invalid_input", details: parsed.error.flatten() });
+        return;
+    }
+    try {
+        const subscription = await subscribeToFeed(req.user.id, parsed.data.url, parsed.data.label ?? null, parsed.data.folderId ?? null);
+        res.status(201).json(subscription);
+    }
+    catch (error) {
+        if (error instanceof SsrfBlockedError) {
+            res.status(400).json({ error: "blocked_url", message: error.message });
+            return;
+        }
+        if (error instanceof MultipleFeedsFoundError) {
+            res.status(400).json({ error: "multiple_feeds_found", feeds: error.feeds });
+            return;
+        }
+        if (error instanceof FeedError) {
+            const status = error.message === "already_subscribed" ? 409 : 400;
+            res.status(status).json({ error: error.message });
+            return;
+        }
+        res.status(400).json({ error: "invalid_feed", message: error instanceof Error ? error.message : String(error) });
+    }
+});
+const updateSchema = z.object({
+    label: z.string().max(200).nullable().optional(),
+    folderId: z.number().int().positive().nullable().optional(),
+    pollIntervalMinutes: z.number().int().positive().max(10080).optional(),
+    fullTextMode: z.enum(["auto", "never"]).optional(),
+    notify: z.boolean().optional(),
+    badge: z.boolean().optional(),
+});
+feedsRouter.patch("/:feedId", (req, res) => {
+    const feedId = Number(req.params.feedId);
+    const parsed = updateSchema.safeParse(req.body);
+    if (!parsed.success) {
+        res.status(400).json({ error: "invalid_input", details: parsed.error.flatten() });
+        return;
+    }
+    try {
+        const subscription = updateFeedSettings(req.user.id, feedId, parsed.data);
+        res.json(subscription);
+    }
+    catch (error) {
+        if (error instanceof FeedError) {
+            res.status(404).json({ error: error.message });
+            return;
+        }
+        throw error;
+    }
+});
+feedsRouter.delete("/:feedId", (req, res) => {
+    const feedId = Number(req.params.feedId);
+    try {
+        unsubscribeFromFeed(req.user.id, feedId);
+        res.status(204).end();
+    }
+    catch (error) {
+        if (error instanceof FeedError) {
+            res.status(404).json({ error: error.message });
+            return;
+        }
+        throw error;
+    }
+});
+feedsRouter.post("/:feedId/refresh", requireSync, async (req, res) => {
+    const feedId = Number(req.params.feedId);
+    if (!Number.isInteger(feedId) || feedId <= 0) {
+        res.status(400).json({ error: "invalid_feed_id" });
+        return;
+    }
+    const feed = findFeedById(feedId);
+    if (!feed || !isUserSubscribed(req.user.id, feedId)) {
+        res.status(404).json({ error: "feed_not_found" });
+        return;
+    }
+    const pollResult = await pollFeed(feed);
+    const updatedFeed = listSubscriptionsForUser(req.user.id).find((f) => f.id === feedId);
+    res.json({
+        feed: updatedFeed,
+        newItems: pollResult.newItems,
+        error: pollResult.error,
+        deferred: pollResult.deferred ?? false,
+        retryAt: pollResult.retryAt,
+    });
+});
+feedsRouter.post("/refresh-all", requireSync, async (req, res) => {
+    const subs = listSubscriptionsForUser(req.user.id);
+    const { newItems: totalNewItems, errors: errorCount, deferred } = await pollFeeds(subs);
+    res.json({
+        refreshed: subs.length,
+        newItems: totalNewItems,
+        errors: errorCount,
+        deferred,
+    });
+});
+//# sourceMappingURL=feeds.js.map

package/server/dist/api/filters.js

@@ -0,0 +1,32 @@
+import { Router } from "express";
+import { z } from "zod";
+import { requireSession } from "../auth/middleware.js";
+import { listMutedKeywords, addMutedKeyword, removeMutedKeyword, } from "../feeds/repository.js";
+export const filtersRouter = Router();
+filtersRouter.use(requireSession);
+filtersRouter.get("/muted", (req, res) => {
+    const keywords = listMutedKeywords(req.user.id);
+    res.json({ keywords });
+});
+const addKeywordSchema = z.object({
+    keyword: z.string().trim().min(1).max(100),
+});
+filtersRouter.post("/muted", (req, res) => {
+    const parsed = addKeywordSchema.safeParse(req.body);
+    if (!parsed.success) {
+        res.status(400).json({ error: "invalid_input", details: parsed.error.flatten() });
+        return;
+    }
+    const created = addMutedKeyword(req.user.id, parsed.data.keyword);
+    res.status(201).json(created);
+});
+filtersRouter.delete("/muted/:id", (req, res) => {
+    const keywordId = Number(req.params.id);
+    if (isNaN(keywordId)) {
+        res.status(400).json({ error: "invalid_id" });
+        return;
+    }
+    removeMutedKeyword(req.user.id, keywordId);
+    res.status(204).end();
+});
+//# sourceMappingURL=filters.js.map

package/server/dist/api/folders.js

@@ -0,0 +1,53 @@
+import { requireCapability } from "../auth/capabilities.js";
+import { Router } from "express";
+import { z } from "zod";
+import { requireSession } from "../auth/middleware.js";
+import { listFoldersForUser, createFolder, updateFolder, deleteFolder, findFolderById, markAllRead, } from "../feeds/repository.js";
+export const foldersRouter = Router();
+foldersRouter.use(requireSession);
+const folderNameSchema = z.object({
+    name: z.string().trim().min(1).max(100),
+});
+foldersRouter.get("/", (req, res) => {
+    const folders = listFoldersForUser(req.user.id);
+    res.json({ folders });
+});
+foldersRouter.post("/", requireCapability("sync"), (req, res) => {
+    const parsed = folderNameSchema.safeParse(req.body);
+    if (!parsed.success) {
+        res.status(400).json({ error: "invalid_input", details: parsed.error.flatten() });
+        return;
+    }
+    const folder = createFolder(req.user.id, parsed.data.name);
+    res.status(201).json({
+        ...folder,
+        feed_count: 0,
+        unread_count: 0,
+    });
+});
+foldersRouter.patch("/:folderId", (req, res) => {
+    const folderId = Number(req.params.folderId);
+    const existing = findFolderById(req.user.id, folderId);
+    if (!existing) {
+        res.status(404).json({ error: "folder_not_found" });
+        return;
+    }
+    const parsed = folderNameSchema.safeParse(req.body);
+    if (!parsed.success) {
+        res.status(400).json({ error: "invalid_input", details: parsed.error.flatten() });
+        return;
+    }
+    const updated = updateFolder(req.user.id, folderId, parsed.data.name);
+    res.json(updated);
+});
+foldersRouter.delete("/:folderId", (req, res) => {
+    const folderId = Number(req.params.folderId);
+    deleteFolder(req.user.id, folderId);
+    res.json({ success: true });
+});
+foldersRouter.post("/:folderId/read", (req, res) => {
+    const folderId = Number(req.params.folderId);
+    const updatedCount = markAllRead(req.user.id, { folderId });
+    res.json({ read: updatedCount });
+});
+//# sourceMappingURL=folders.js.map

package/server/dist/api/index.js

@@ -0,0 +1,37 @@
+import { Router } from "express";
+import { onboardingRouter } from "./onboarding.js";
+import { authRouter } from "./auth.js";
+import { feedsRouter } from "./feeds.js";
+import { itemsRouter } from "./items.js";
+import { tokensRouter } from "./tokens.js";
+import { oauthGrantsRouter } from "./oauth.js";
+import { systemRouter } from "./system.js";
+import { filtersRouter } from "./filters.js";
+import { foldersRouter } from "./folders.js";
+import { archiveRouter } from "./archive.js";
+import { pushRouter } from "./push.js";
+import { v1Router } from "./v1/index.js";
+import { config } from "../config.js";
+export const apiRouter = Router();
+apiRouter.get("/health", (_req, res) => {
+    res.json({ status: "ok" });
+});
+apiRouter.get("/config", (_req, res) => {
+    res.json({
+        showGithubLink: config.showGithubLink,
+        githubUrl: config.githubUrl,
+    });
+});
+apiRouter.use("/onboarding", onboardingRouter);
+apiRouter.use("/auth", authRouter);
+apiRouter.use("/feeds", feedsRouter);
+apiRouter.use("/items", itemsRouter);
+apiRouter.use("/tokens", tokensRouter);
+apiRouter.use("/oauth-grants", oauthGrantsRouter);
+apiRouter.use("/system", systemRouter);
+apiRouter.use("/filters", filtersRouter);
+apiRouter.use("/folders", foldersRouter);
+apiRouter.use("/archive", archiveRouter);
+apiRouter.use("/push", pushRouter);
+apiRouter.use("/v1", v1Router);
+//# sourceMappingURL=index.js.map