-
- ([]);
+ const [feeds, setFeeds] = useState([]);
+ const [searchQuery, setSearchQuery] = useState('');
+ const [activeFeedId, setActiveFeedId] = useState(null);
+ const [showBookmarked, setShowBookmarked] = useState(false);
+ const [showFeedManager, setShowFeedManager] = useState(false);
+ const [loading, setLoading] = useState(true);
+ const [newCount, setNewCount] = useState(0);
+ const prevItemIdsRef = useRef>(new Set());
+
+ const fetchFeeds = useCallback(async () => {
+ try {
+ const res = await fetch('/api/rss/feeds');
+ const data = await res.json();
+ if (Array.isArray(data)) setFeeds(data);
+ } catch (e) {
+ console.error('Failed to fetch feeds:', e);
+ }
+ }, []);
+
+ const fetchItems = useCallback(async (opts?: { silent?: boolean; resetFeedFilter?: boolean }) => {
+ try {
+ const params = new URLSearchParams();
+ if (searchQuery) params.set('q', searchQuery);
+ if (!opts?.resetFeedFilter && activeFeedId !== null) params.set('feed_id', String(activeFeedId));
+ if (showBookmarked) params.set('bookmarked', '1');
+ params.set('limit', '50');
+
+ const res = await fetch(`/api/rss?${params}`);
+ const data = await res.json();
+ if (Array.isArray(data)) {
+ if (opts?.silent && prevItemIdsRef.current.size > 0) {
+ const newIds = data.filter((i: FeedItem) => !prevItemIdsRef.current.has(i.id));
+ if (newIds.length > 0) {
+ setNewCount((c) => c + newIds.length);
+ }
+ }
+ prevItemIdsRef.current = new Set(data.map((i: FeedItem) => i.id));
+ setItems(data);
+ }
+ } catch (e) {
+ console.error('Failed to fetch items:', e);
+ } finally {
+ setLoading(false);
+ }
+ }, [searchQuery, activeFeedId, showBookmarked]);
+
+ // Initial load + refresh
+ useEffect(() => {
+ fetchFeeds();
+ fetchItems();
+ }, [fetchFeeds, fetchItems]);
+
+ // Auto-refresh every 30s
+ useEffect(() => {
+ const interval = setInterval(() => {
+ fetchItems({ silent: true });
+ fetchFeeds();
+ }, 30000);
+ return () => clearInterval(interval);
+ }, [fetchItems, fetchFeeds]);
+
+ const handleRead = async (id: number) => {
+ setItems((prev) => prev.map((i) => (i.id === id ? { ...i, read: 1 } : i)));
+ try {
+ await fetch('/api/rss', {
+ method: 'PATCH',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({ id, read: true }),
+ });
+ } catch (e) {
+ console.error('Failed to mark as read:', e);
+ }
+ };
+
+ const handleBookmark = async (id: number, bookmarked: boolean) => {
+ setItems((prev) =>
+ prev.map((i) => (i.id === id ? { ...i, bookmarked: bookmarked ? 1 : 0 } : i))
+ );
+ try {
+ await fetch('/api/rss', {
+ method: 'PATCH',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({ id, bookmarked }),
+ });
+ } catch (e) {
+ console.error('Failed to toggle bookmark:', e);
+ }
+ };
+
+ const handleFeedChanged = () => {
+ setActiveFeedId(null);
+ fetchFeeds();
+ fetchItems({ resetFeedFilter: true });
+ };
+
+ const handleDismissNew = () => {
+ setNewCount(0);
+ fetchItems();
+ };
+
+ const hasFeeds = feeds.length > 0;
+
+ return (
+
+
+ );
+}
+
+function FeedFilterPills({
+ feeds,
+ activeFeedId,
+ onSelect,
+}: {
+ feeds: Feed[];
+ activeFeedId: number | null;
+ onSelect: (id: number | null) => void;
+}) {
+ const totalItems = feeds.reduce((s, f) => s + f.item_count, 0);
+
+ return (
+
+
+ {feeds.map((f) => (
+
+ ))}
+
+ );
+}
+
+function AddFeedForm({ onAdded }: { onAdded: () => void }) {
+ const [url, setUrl] = useState('');
+ const [submitting, setSubmitting] = useState(false);
+ const [error, setError] = useState('');
+
+ const handleSubmit = async (e: React.FormEvent) => {
+ e.preventDefault();
+ setError('');
+ setSubmitting(true);
+ try {
+ const res = await fetch('/api/rss/feeds', {
+ method: 'POST',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({ url: url.trim() }),
+ });
+ if (!res.ok) {
+ const data = await res.json();
+ throw new Error(data.error || 'Failed to add feed');
+ }
+ setUrl('');
+ onAdded();
+ } catch (err: unknown) {
+ setError(err instanceof Error ? err.message : 'Failed to add feed');
+ } finally {
+ setSubmitting(false);
+ }
+ };
+
+ return (
+
+ );
+}
+
+function FeedManager({
+ feeds,
+ onChanged,
+ onClose,
+}: {
+ feeds: Feed[];
+ onChanged: () => void;
+ onClose: () => void;
+}) {
+ const handleDelete = async (id: number) => {
+ try {
+ await fetch('/api/rss/feeds', {
+ method: 'DELETE',
+ headers: { 'Content-Type': 'application/json' },
+ body: JSON.stringify({ id }),
+ });
+ onChanged();
+ } catch (e) {
+ console.error('Failed to delete feed:', e);
+ }
+ };
+
+ return (
+
+
+ );
+}
+
+function FeedItemRow({
+ item,
+ onRead,
+ onBookmark,
+}: {
+ item: FeedItem;
+ onRead: (id: number) => void;
+ onBookmark: (id: number, bookmarked: boolean) => void;
+}) {
+ const handleClick = () => {
+ window.open(item.link, '_blank', 'noopener,noreferrer');
+ if (!item.read) onRead(item.id);
+ };
+
+ return (
+
+ Manage Feeds
+
+
+
+ {feeds.map((f) => (
+
+
+
+ ))}
+
+
+
+
+ {f.last_fetched && (
+
+ {formatDistanceToNow(new Date(f.last_fetched), { addSuffix: true })}
+
+ )}
+
+
+
+
+ );
+}
+
+// --- Main Component ---
+
+export function NewsFeed() {
+ const [items, setItems] = useState
+
+
+
+
+ {item.feed_url &&
+ + {item.title} +
+ {item.snippet && ( +{item.snippet}
+ )} +
+ {item.pub_date && (
+
+ {formatDistanceToNow(new Date(item.pub_date), { addSuffix: true })}
+
+ )}
+
+
+ {/* Header */}
+
+
-
+
+
+
+ {/* Feed filter pills */}
+ {hasFeeds && (
+
+
+ )}
+
+ {/* Feed manager (collapsible) */}
+ {showFeedManager && (
+
+ setShowFeedManager(false)} />
+
+ )}
+
+ {/* New items badge */}
+ {newCount > 0 && (
+
+ )}
+
+ {/* Item list */}
+
{loading ? (
- [1, 2, 3].map(i => (
-
diff --git a/lib/db.ts b/lib/db.ts
index 54ddc56..ba9fd5d 100644
--- a/lib/db.ts
+++ b/lib/db.ts
@@ -45,7 +45,40 @@ export async function getDb() {
CREATE INDEX IF NOT EXISTS idx_uptime_logs_service_timestamp
ON uptime_logs(service_name, timestamp);
+
+ CREATE TABLE IF NOT EXISTS rss_feeds (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ name TEXT NOT NULL,
+ url TEXT NOT NULL UNIQUE,
+ last_fetched DATETIME,
+ created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+ );
+
+ CREATE TABLE IF NOT EXISTS rss_items (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ feed_id INTEGER NOT NULL,
+ title TEXT NOT NULL,
+ link TEXT NOT NULL UNIQUE,
+ pub_date DATETIME,
+ creator TEXT,
+ snippet TEXT,
+ read INTEGER DEFAULT 0,
+ bookmarked INTEGER DEFAULT 0,
+ created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+ );
+
+ CREATE INDEX IF NOT EXISTS idx_rss_items_feed ON rss_items(feed_id);
+ CREATE INDEX IF NOT EXISTS idx_rss_items_pubdate ON rss_items(pub_date DESC);
`);
+ // Seed default HN feed if rss_feeds is empty
+ const feedCount = await db.get('SELECT COUNT(*) as cnt FROM rss_feeds');
+ if (feedCount?.cnt === 0) {
+ await db.run(
+ 'INSERT INTO rss_feeds (name, url) VALUES (?, ?)',
+ 'Hacker News', 'https://news.ycombinator.com/rss'
+ );
+ }
+
return db;
}
diff --git a/monitor.js b/monitor.js
index 0d41f93..ffec45f 100644
--- a/monitor.js
+++ b/monitor.js
@@ -1,5 +1,6 @@
const sqlite3 = require('sqlite3');
const { open } = require('sqlite');
+const RSSParser = require('rss-parser');
// Node 18+ has global fetch built-in
const DEFAULT_SERVICES = [
@@ -42,6 +43,78 @@ async function seedDefaults(db) {
}
}
+async function setupRssTables(db) {
+ await db.exec(`
+ CREATE TABLE IF NOT EXISTS rss_feeds (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ name TEXT NOT NULL,
+ url TEXT NOT NULL UNIQUE,
+ last_fetched DATETIME,
+ created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+ );
+ CREATE TABLE IF NOT EXISTS rss_items (
+ id INTEGER PRIMARY KEY AUTOINCREMENT,
+ feed_id INTEGER NOT NULL,
+ title TEXT NOT NULL,
+ link TEXT NOT NULL UNIQUE,
+ pub_date DATETIME,
+ creator TEXT,
+ snippet TEXT,
+ read INTEGER DEFAULT 0,
+ bookmarked INTEGER DEFAULT 0,
+ created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+ );
+ CREATE INDEX IF NOT EXISTS idx_rss_items_feed ON rss_items(feed_id);
+ CREATE INDEX IF NOT EXISTS idx_rss_items_pubdate ON rss_items(pub_date DESC);
+ `);
+
+ // Seed default HN feed
+ const count = await db.get('SELECT COUNT(*) as cnt FROM rss_feeds');
+ if (count.cnt === 0) {
+ await db.run(
+ 'INSERT INTO rss_feeds (name, url) VALUES (?, ?)',
+ 'Hacker News', 'https://news.ycombinator.com/rss'
+ );
+ console.log('Seeded default RSS feed (Hacker News)');
+ }
+}
+
+async function syncRssFeeds(db) {
+ const parser = new RSSParser({ timeout: 5000 });
+ const feeds = await db.all('SELECT * FROM rss_feeds');
+
+ for (const feed of feeds) {
+ try {
+ const parsed = await parser.parseURL(feed.url);
+ for (const item of parsed.items || []) {
+ if (!item.title || !item.link) continue;
+ await db.run(
+ `INSERT OR IGNORE INTO rss_items (feed_id, title, link, pub_date, creator, snippet)
+ VALUES (?, ?, ?, ?, ?, ?)`,
+ feed.id,
+ item.title,
+ item.link,
+ item.pubDate || item.isoDate || null,
+ item.creator || item.author || null,
+ (item.contentSnippet || item.content || '').substring(0, 500) || null
+ );
+ }
+ await db.run(
+ 'UPDATE rss_feeds SET last_fetched = ? WHERE id = ?',
+ new Date().toISOString(), feed.id
+ );
+ console.log(`RSS synced: ${feed.name} (${(parsed.items || []).length} items)`);
+ } catch (err) {
+ console.error(`RSS sync error for ${feed.name}:`, err.message);
+ }
+ }
+
+ // Prune items older than 90 days
+ try {
+ await db.run(`DELETE FROM rss_items WHERE created_at < datetime('now', '-90 days')`);
+ } catch (e) { }
+}
+
async function monitor() {
console.log('Starting monitoring loop...');
@@ -66,6 +139,10 @@ async function monitor() {
await seedDefaults(db);
+ // Setup RSS tables and do initial sync
+ await setupRssTables(db);
+ syncRssFeeds(db); // initial sync, don't await to not block uptime start
+
setInterval(async () => {
console.log('Running checks...');
const now = new Date().toISOString();
@@ -114,6 +191,9 @@ async function monitor() {
} catch (e) { }
}, 60000); // Run every minute
+
+ // RSS sync every 5 minutes
+ setInterval(() => syncRssFeeds(db), 5 * 60 * 1000);
}
monitor();
-
-
-
- ))
- ) : (
- news.map((item) => (
-
- - {item.title} -
-
- {item.pubDate ? formatDistanceToNow(new Date(item.pubDate), { addSuffix: true }) : ''}
+
+ {[1, 2, 3, 4, 5].map((i) => (
+
+ ) : !hasFeeds ? (
+
+
+
+
-
- ))
+ ))}
+
+
+ ) : items.length === 0 ? (
+
+
+ ) : (
+
+ {items.map((item) => (
+
)}