dsh-mishu 0.7.2 → 0.7.3

package/lib/core/watch/fetch.js

@@ -0,0 +1,169 @@
+/**
+ * Reading a watched address: a feed, a JSON list, or just a page.
+ *
+ * Whatever comes back is turned into a handful of items — a title, a bit of
+ * text and a stable key — so the rest of the code never has to care whether
+ * it was RSS, Atom, JSON or plain HTML. No parser library: the shapes that
+ * matter here are small, and a wrong guess costs nothing (the page is read
+ * as text and still works).
+ */
+import { createHash } from 'node:crypto';
+import { bi } from "../i18n.js";
+import { entryKey } from "./source.js";
+/** The real fetch: a plain GET with a short timeout and no cookies. */
+export const httpFetch = async (url) => {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 20_000);
+    try {
+        const response = await fetch(url, {
+            method: 'GET',
+            redirect: 'follow',
+            signal: controller.signal,
+            headers: {
+                'user-agent': 'dsh-mishu/1 (+https://github.com/AIcivilization/dsh-mishu)',
+                accept: 'application/rss+xml, application/atom+xml, application/json, text/html;q=0.9, */*;q=0.8',
+            },
+        });
+        const body = await response.text();
+        return { status: response.status, body, contentType: response.headers.get('content-type') ?? '' };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+};
+const ENTITIES = { amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", nbsp: ' ' };
+function unescape(text) {
+    return text
+        .replace(/&(#x?[0-9a-f]+|[a-z]+);/gi, (whole, name) => {
+        if (name.startsWith('#')) {
+            const code = name[1]?.toLowerCase() === 'x' ? Number.parseInt(name.slice(2), 16) : Number.parseInt(name.slice(1), 10);
+            return Number.isFinite(code) && code > 0 && code < 0x110000 ? String.fromCodePoint(code) : whole;
+        }
+        return ENTITIES[name.toLowerCase()] ?? whole;
+    });
+}
+/** Markup out, whitespace collapsed. */
+export function plainText(markup) {
+    return unescape(markup
+        .replace(/<(script|style)\b[^>]*>[\s\S]*?<\/\1>/gi, ' ')
+        .replace(/<[^>]+>/g, ' '))
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function tag(block, name) {
+    const match = new RegExp(`<${name}\\b[^>]*>([\\s\\S]*?)</${name}>`, 'i').exec(block);
+    if (match === null)
+        return undefined;
+    const inner = match[1];
+    const cdata = /^\s*<!\[CDATA\[([\s\S]*?)\]\]>\s*$/.exec(inner);
+    return plainText(cdata === null ? inner : cdata[1]);
+}
+function attr(block, name) {
+    const match = new RegExp(`\\b${name}\\s*=\\s*["']([^"']*)["']`, 'i').exec(block);
+    return match === null ? undefined : unescape(match[1]);
+}
+/** RSS `<item>` and Atom `<entry>` blocks, whichever the document has. */
+export function parseFeed(body, now, base) {
+    const blocks = [...body.matchAll(/<(item|entry)\b[\s\S]*?<\/\1>/gi)].map(m => m[0]);
+    if (blocks.length === 0)
+        return undefined;
+    return blocks.map((block) => {
+        const title = tag(block, 'title') ?? '';
+        const link = tag(block, 'link') ?? (() => {
+            const href = attr(block, 'href');
+            return href === undefined ? undefined : href;
+        })();
+        const bodyText = tag(block, 'description') ?? tag(block, 'summary') ?? tag(block, 'content') ?? '';
+        const guid = tag(block, 'guid') ?? tag(block, 'id');
+        const when = tag(block, 'pubDate') ?? tag(block, 'updated') ?? tag(block, 'published') ?? tag(block, 'dc:date');
+        const at = when === undefined ? now : Date.parse(when);
+        const href = link === undefined ? null : absolute(link, base);
+        return {
+            key: entryKey({ id: guid ?? href ?? undefined, link: href ?? undefined, title }),
+            title: title === '' ? (href ?? '?') : title,
+            text: bodyText,
+            url: href,
+            at: Number.isFinite(at) ? at : now,
+        };
+    });
+}
+function absolute(link, base) {
+    try {
+        return new URL(link, base).toString();
+    }
+    catch {
+        return link;
+    }
+}
+/**
+ * A JSON body: an array of objects, or an object with one array inside. Each
+ * element's title-like and text-like fields become an item.
+ */
+export function parseJson(body, now, base) {
+    let value;
+    try {
+        value = JSON.parse(body);
+    }
+    catch {
+        return undefined;
+    }
+    const list = Array.isArray(value)
+        ? value
+        : Object.values(value).find(Array.isArray);
+    if (list === undefined || list.length === 0)
+        return undefined;
+    const str = (item, names) => {
+        for (const name of names) {
+            const found = item[name];
+            if (typeof found === 'string' && found.trim() !== '')
+                return found;
+            if (typeof found === 'number')
+                return String(found);
+        }
+        return undefined;
+    };
+    return list.slice(0, 60).map((raw) => {
+        if (typeof raw !== 'object' || raw === null)
+            return { key: entryKey({ title: String(raw) }), title: String(raw), text: '', url: null, at: now };
+        const item = raw;
+        const title = str(item, ['title', 'name', 'subject', 'headline', 'version', 'label']) ?? JSON.stringify(item).slice(0, 120);
+        const text = str(item, ['description', 'body', 'content', 'summary', 'text', 'excerpt', 'details']) ?? '';
+        const link = str(item, ['url', 'link', 'html_url', 'permalink', 'href']);
+        const when = str(item, ['date', 'published', 'updated', 'pubDate', 'created_at', 'time', 'timestamp']);
+        const at = when === undefined ? now : Date.parse(when);
+        const href = link === undefined ? null : absolute(link, base);
+        return {
+            key: entryKey({ id: str(item, ['id', 'guid', 'uuid', 'key']) ?? href ?? undefined, link: href ?? undefined, title }),
+            title, text, url: href, at: Number.isFinite(at) ? at : now,
+        };
+    });
+}
+/** A page with no feed: its title and text, as one item keyed by a hash of the text. */
+export function parsePage(body, now, base) {
+    const title = plainText(/<title\b[^>]*>([\s\S]*?)<\/title>/i.exec(body)?.[1] ?? '') || new URL(base).hostname;
+    const text = plainText(/<body\b[^>]*>([\s\S]*?)<\/body>/i.exec(body)?.[1] ?? body).slice(0, 20_000);
+    const key = createHash('sha256').update(text).digest('hex').slice(0, 16);
+    return [{ key, title, text, url: base, at: now }];
+}
+/** Whatever the address returned, as items. */
+export function readWatchBody(options) {
+    const { body, contentType, url, now } = options;
+    const looksJson = /json/i.test(contentType) || /^\s*[[{]/.test(body);
+    const looksFeed = /xml|rss|atom/i.test(contentType) || /<(rss|feed)\b/i.test(body);
+    if (looksFeed || (!looksJson && /<(item|entry)\b/i.test(body)))
+        return parseFeed(body, now, url) ?? parsePage(body, now, url);
+    if (looksJson)
+        return parseJson(body, now, url) ?? parsePage(body, now, url);
+    return parsePage(body, now, url);
+}
+/** The sentence shown when a watch cannot be read. */
+export function describeWatchError(error, source) {
+    const raw = error.message ?? String(error);
+    if (/abort/i.test(raw))
+        return bi(`${source.label} 20 秒没有回应，可能是网站太慢或打不开。`, `${source.label} did not answer within 20 seconds; the site may be slow or down.`);
+    if (/ENOTFOUND|EAI_AGAIN|getaddrinfo/i.test(raw))
+        return bi(`${source.label} 的网址找不到服务器：检查一下网址有没有写错。`, `The server for ${source.label} was not found: check the address.`);
+    if (/certificate|self.signed|SSL|TLS/i.test(raw))
+        return bi(`${source.label} 的证书有问题，读不了。`, `${source.label} has a certificate problem and could not be read.`);
+    return bi(`读 ${source.label} 失败：${raw}`, `Could not read ${source.label}: ${raw}`);
+}

package/lib/core/watch/source.js

@@ -0,0 +1,116 @@
+/**
+ * Things you watch yourself: a page, a feed or an API you care about.
+ *
+ * GitHub and mail are sources the secretary knows how to read. Everything
+ * else a person cares about — a game's patch notes, a job posting, a price,
+ * a status page — is a URL. You add it here with the words that matter to
+ * you, and the secretary looks at it now and then: when it changes, or when
+ * one of your words shows up, it becomes a card like anything else.
+ *
+ * Only where and what to look for is kept here. What was seen last lives in
+ * the notebook's key-value table, so an entry never grows without bound.
+ */
+import { createHash } from 'node:crypto';
+import { bi, MishuError } from "../i18n.js";
+export const WATCH_SOURCE = 'watch';
+const SOURCES_KEY = 'watch.sources';
+const NEXT_ID_KEY = 'watch.nextId';
+export function watchSources(store) {
+    return store.get(SOURCES_KEY) ?? [];
+}
+export function watchById(store, id) {
+    return watchSources(store).find(s => s.id === id);
+}
+export function watchReportKey(id) {
+    return `watch.lastSync.${id}`;
+}
+/** Where one watch keeps what it has already seen. */
+export function watchStateKey(id) {
+    return `watch.state.${id}`;
+}
+export function watchSeenKey(id) {
+    return `watch.seen.${id}`;
+}
+/** A stable id for a feed entry: its guid, else its link, else its title. */
+export function entryKey(entry) {
+    const basis = entry.id ?? entry.link ?? entry.title ?? '';
+    return createHash('sha256').update(basis).digest('hex').slice(0, 16);
+}
+/** Split what you typed into words: commas, 、, spaces or new lines all work. */
+export function parseKeywords(value) {
+    const list = Array.isArray(value) ? value : String(value ?? '').split(/[,，、;\n]+/);
+    const words = list.map(w => w.trim().toLowerCase()).filter(w => w !== '');
+    return [...new Set(words)].slice(0, 20);
+}
+/** Check and complete what the settings page sent; throws a sentence a person can act on. */
+export function resolveWatch(input, id) {
+    const raw = String(input.url ?? '').trim();
+    if (raw === '')
+        throw new MishuError(bi('还没填网址', 'the address is empty'));
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw new MishuError(bi(`网址看不懂：${raw}。要完整的一串，比如 https://example.com/news`, `that is not a web address: ${raw}. It should look like https://example.com/news`));
+    }
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+        throw new MishuError(bi('只支持 http 和 https 的网址', 'only http and https addresses work'));
+    }
+    const label = String(input.label ?? '').trim() || url.hostname;
+    if (label.length > 60)
+        throw new MishuError(bi('名字太长了，60 个字以内', 'the name is too long; keep it under 60 characters'));
+    const intervalMinutes = Number(input.intervalMinutes ?? 60);
+    if (!Number.isInteger(intervalMinutes) || intervalMinutes < 15 || intervalMinutes > 1440) {
+        throw new MishuError(bi('多久看一次要是 15 到 1440 分钟', 'how often to look must be 15 to 1440 minutes'));
+    }
+    return {
+        id,
+        label,
+        url: url.toString(),
+        keywords: parseKeywords(input.keywords),
+        enabled: input.enabled !== false,
+        intervalMinutes,
+    };
+}
+/** Add (no id) or update one watch. */
+export function saveWatch(store, input, now) {
+    const sources = watchSources(store);
+    const existing = input.id === undefined ? undefined : sources.find(s => s.id === input.id);
+    if (input.id !== undefined && existing === undefined)
+        throw new MishuError(bi(`没有 #${input.id} 这个关注`, `there is no watch #${input.id}`));
+    const id = existing?.id ?? (store.get(NEXT_ID_KEY) ?? 1);
+    const source = resolveWatch({ ...existing, ...input }, id);
+    store.set(SOURCES_KEY, existing === undefined ? [...sources, source] : sources.map(s => (s.id === id ? source : s)));
+    if (existing === undefined)
+        store.set(NEXT_ID_KEY, id + 1);
+    store.log(now, existing === undefined ? 'watch-add' : 'watch-update', { id, url: source.url, keywords: source.keywords.length });
+    return source;
+}
+/** Remove one watch and close whatever it still has open. */
+export function deleteWatch(store, id, now) {
+    const sources = watchSources(store);
+    if (!sources.some(s => s.id === id))
+        return false;
+    store.transaction(() => {
+        store.set(SOURCES_KEY, sources.filter(s => s.id !== id));
+        store.set(watchStateKey(id), null);
+        store.set(watchSeenKey(id), null);
+        for (const matter of store.mattersOfSource(WATCH_SOURCE)) {
+            if (matter.status === 'open' && (matter.key === `watch:${id}` || matter.key.startsWith(`watch:${id}:`))) {
+                store.updateMatter(matter.id, { status: 'done', reason: 'watch-removed', closedBy: 'source', closedAt: now }, now);
+            }
+        }
+        store.log(now, 'watch-delete', { id });
+    });
+    return true;
+}
+/** The watches whose next check is due. */
+export function dueWatches(store, now) {
+    return watchSources(store).filter((source) => {
+        if (!source.enabled)
+            return false;
+        const report = store.get(watchReportKey(source.id));
+        return report === undefined || now - report.at >= source.intervalMinutes * 60_000;
+    });
+}

package/lib/core/watch/sync.js

@@ -0,0 +1,171 @@
+/**
+ * One watch, one check: read the address, compare with what was seen last
+ * time, and turn anything new into a card.
+ *
+ * A card per watch, not per entry: "补丁公告 · 3 条新内容" is what you want to
+ * see, not three cards that say the same thing. Marking it done closes it;
+ * the next change opens it again with what changed.
+ *
+ * The first check only writes down what is there now — otherwise adding a
+ * feed would hand you every entry it ever published. Words you asked to watch
+ * for are the exception: those are shown right away, because you asked.
+ */
+import { applyVerdict } from "../fold.js";
+import { bi, MishuError } from "../i18n.js";
+import { shortDay } from "../time.js";
+import { describeWatchError, readWatchBody } from "./fetch.js";
+import { WATCH_SOURCE, watchReportKey, watchSeenKey, watchStateKey } from "./source.js";
+/** How many entry keys one watch remembers. A feed longer than this is fine; the tail ages out. */
+const SEEN_LIMIT = 500;
+function readState(store, id) {
+    return store.get(watchStateKey(id)) ?? { seen: [], primed: false };
+}
+/** Which items are new since last time, and whether the whole page changed. */
+export function diffItems(items, state) {
+    const seen = new Set(state.seen);
+    const fresh = items.filter(item => !seen.has(item.key));
+    // A single-item read is a page: its key is a hash of the text, so "new" means "the text changed".
+    const digest = items.length === 1 ? items[0].key : items.map(i => i.key).sort().join(',');
+    return { fresh, changed: state.digest !== undefined && state.digest !== digest, digest };
+}
+function matches(item, keywords) {
+    if (keywords.length === 0)
+        return undefined;
+    const haystack = `${item.title}\n${item.text}`.toLowerCase();
+    return keywords.find(word => haystack.includes(word));
+}
+function quote(items, lang) {
+    const shown = items.slice(0, 3).map(i => `「${i.title.slice(0, 80)}」`);
+    const more = items.length - shown.length;
+    if (lang === 'zh')
+        return more > 0 ? `${shown.join('、')} 等 ${items.length} 条` : shown.join('、');
+    return more > 0 ? `${shown.join(', ')} and ${more} more` : shown.join(', ');
+}
+export function judgeWatch(options) {
+    const { source, items, fresh, changed, first, now } = options;
+    const hit = (list) => list
+        .map(item => ({ item, word: matches(item, source.keywords) }))
+        .filter((x) => x.word !== undefined);
+    const freshHits = hit(fresh);
+    const allHits = hit(items);
+    const keywordMode = source.keywords.length > 0;
+    let reason;
+    let relevant;
+    let word;
+    if (keywordMode) {
+        // A word you watch for is worth a card even on the very first check.
+        relevant = (first ? allHits : freshHits).map(x => x.item);
+        if (relevant.length === 0)
+            return undefined;
+        word = (first ? allHits : freshHits)[0].word;
+        reason = 'watch-keyword';
+    }
+    else if (first) {
+        return undefined;
+    }
+    else if (fresh.length > 0) {
+        relevant = fresh;
+        reason = items.length > 1 ? 'watch-new' : 'watch-changed';
+    }
+    else if (changed) {
+        relevant = items.slice(0, 1);
+        reason = 'watch-changed';
+    }
+    else {
+        return undefined;
+    }
+    const when = shortDay(now);
+    const what = bi(`你关注「${source.label}」（${new URL(source.url).hostname}）`, `The thing you watch: "${source.label}" (${new URL(source.url).hostname})`);
+    const why = keywordMode && word !== undefined
+        ? bi(`${when} 检查时，这里有内容提到你关注的字「${word}」：${quote(relevant, 'zh')}。`, `On ${when} it mentioned "${word}", one of your words: ${quote(relevant, 'en')}.`)
+        : reason === 'watch-new'
+            ? bi(`${when} 检查时出现了 ${fresh.length} 条新内容：${quote(relevant, 'zh')}。`, `On ${when} there were ${fresh.length} new entries: ${quote(relevant, 'en')}.`)
+            : bi(`${when} 检查时，${source.label} 的内容变了：${quote(relevant, 'zh')}。`, `On ${when} "${source.label}" changed: ${quote(relevant, 'en')}.`);
+    const link = relevant.find(i => i.url !== null)?.url ?? source.url;
+    return {
+        matterKey: `watch:${source.id}`,
+        kind: 'watch',
+        title: source.label,
+        url: link,
+        status: 'open',
+        reason,
+        note: bi(keywordMode ? `提到「${word}」` : reason === 'watch-new' ? `${fresh.length} 条新内容` : '内容有变化', keywordMode ? `mentions "${word}"` : reason === 'watch-new' ? `${fresh.length} new entries` : 'changed'),
+        explain: {
+            what,
+            why,
+            fix: bi('打开看一眼；处理完点"办完了"。不想再关注了，在设置里删掉这一条。', 'Open it and have a look; mark it done afterwards. To stop watching, delete it in Settings.'),
+            link: { label: bi('打开看看', 'Open it'), url: link },
+        },
+    };
+}
+export async function syncWatch(options) {
+    const { store, source, fetcher, now } = options;
+    const report = { at: now, id: source.id, items: 0, opened: 0, closed: 0 };
+    let body;
+    try {
+        body = await fetcher(source.url);
+    }
+    catch (error) {
+        report.error = describeWatchError(error, source);
+        store.set(watchReportKey(source.id), report);
+        return report;
+    }
+    if (body.status >= 400) {
+        report.error = body.status === 404
+            ? bi(`${source.label} 打不开了（404）：这个网址可能已经变了。`, `${source.label} is gone (404): the address may have moved.`)
+            : bi(`${source.label} 返回 ${body.status}，读不到内容。`, `${source.label} answered ${body.status}, so there was nothing to read.`);
+        store.set(watchReportKey(source.id), report);
+        return report;
+    }
+    if (body.body.trim() === '') {
+        report.error = bi(`${source.label} 这次读到的是空页面。`, `${source.label} came back empty.`);
+        store.set(watchReportKey(source.id), report);
+        return report;
+    }
+    const items = readWatchBody({ body: body.body, contentType: body.contentType, url: source.url, now });
+    if (items.length === 0) {
+        report.error = bi(`${source.label} 这次读到的是空页面。`, `${source.label} came back empty.`);
+        store.set(watchReportKey(source.id), report);
+        return report;
+    }
+    report.items = items.length;
+    const state = readState(store, source.id);
+    const { fresh, changed, digest } = diffItems(items, state);
+    const verdict = judgeWatch({ source, items, fresh, changed, first: !state.primed, now });
+    store.transaction(() => {
+        if (verdict !== undefined) {
+            const counts = { opened: 0, closed: 0 };
+            applyVerdict(store, WATCH_SOURCE, { ...verdict, activityAt: Math.max(...items.map(i => i.at), now) }, now, counts);
+            report.opened = counts.opened;
+            report.closed = counts.closed;
+        }
+        const seen = [...state.seen, ...fresh.map(i => i.key)];
+        const trimmed = seen.length > SEEN_LIMIT ? seen.slice(seen.length - SEEN_LIMIT) : seen;
+        store.set(watchStateKey(source.id), { seen: trimmed, digest, primed: true });
+        store.set(watchSeenKey(source.id), trimmed.length);
+    });
+    store.set(watchReportKey(source.id), report);
+    return report;
+}
+/** Everything about one watch the settings page shows. */
+export function describeWatch(store, source, lang) {
+    const report = store.get(watchReportKey(source.id));
+    if (report === undefined)
+        return lang === 'zh' ? '还没看过' : 'not checked yet';
+    if (report.error !== undefined)
+        return report.error[lang];
+    return lang === 'zh'
+        ? `${shortDay(report.at)} 看过，${report.items} 条内容`
+        : `checked ${shortDay(report.at)}, ${report.items} entries`;
+}
+/** The words, for showing back to you. */
+export function describeKeywords(source, lang) {
+    if (source.keywords.length === 0)
+        return lang === 'zh' ? '有任何变化就告诉我' : 'tell me about any change';
+    return lang === 'zh' ? `提到 ${source.keywords.join('、')} 时告诉我` : `tell me when it mentions ${source.keywords.join(', ')}`;
+}
+/** Guard for the settings page: an address that cannot be a watch at all. */
+export function assertWatchable(source) {
+    if (!/^https?:\/\//.test(source.url))
+        throw new MishuError(bi('只支持 http 和 https 的网址', 'only http and https addresses work'));
+}

package/lib/dsh/api.js

@@ -9,7 +9,7 @@
  * travel inward: they go straight to the keychain, and no endpoint ever
  * returns one.
  */
-import { addDays, addSeries, bi, deleteFeishu, deliver, FEISHU_WEBHOOK, notifySettings, NOTIFY_REPORT_KEY, saveFeishu, saveNotifySettings, testMessage, buildAsk, buildBoard, buildDetail, dayOf, deleteGithubToken, deleteMailAccount, describeMailError, MishuError, describeSeries, detectLang, errorText, GitHubClient, MAIL_PRESETS, mailReportKey, NEW_TOKEN_URL, normalizePassword, providerMismatch, resolveSeries, saveGithubToken, saveMailAccount, saveSettings, secretAccount, secretEnvName, setStatusByUser, snoozeByUser, stopSeries, tickManual, } from "../core/index.js";
+import { describeWatchError, addDays, addSeries, bi, deleteFeishu, deliver, FEISHU_WEBHOOK, notifySettings, NOTIFY_REPORT_KEY, saveFeishu, saveNotifySettings, testMessage, buildAsk, buildBoard, buildDetail, dayOf, deleteGithubToken, deleteMailAccount, describeMailError, MishuError, describeSeries, detectLang, errorText, GitHubClient, MAIL_PRESETS, mailReportKey, NEW_TOKEN_URL, normalizePassword, providerMismatch, resolveSeries, saveGithubToken, saveMailAccount, saveSettings, secretAccount, secretEnvName, setStatusByUser, snoozeByUser, stopSeries, tickManual, deleteWatch, describeKeywords, describeWatch, parseKeywords, readWatchBody, resolveWatch, saveWatch, watchById, watchReportKey, watchSources, } from "../core/index.js";
 import { resolveAccount } from "../core/mail/account.js";
 export const API_BASE = '/api/dsh-mishu';
 class ApiError extends Error {
@@ -62,6 +62,38 @@ function accountInput(value) {
     return out;
 }
 const password = (body) => (typeof body.password === 'string' && body.password !== '' ? body.password : undefined);
+function watchInput(value) {
+    const w = (value ?? {});
+    const text = (v) => (typeof v === 'string' ? v : undefined);
+    const out = {};
+    if (Number.isInteger(Number(w.id)) && Number(w.id) > 0)
+        out.id = Number(w.id);
+    if (text(w.label) !== undefined)
+        out.label = text(w.label);
+    if (text(w.url) !== undefined)
+        out.url = text(w.url);
+    if (typeof w.keywords === 'string' || Array.isArray(w.keywords))
+        out.keywords = w.keywords;
+    if (typeof w.enabled === 'boolean')
+        out.enabled = w.enabled;
+    if (w.intervalMinutes !== undefined && w.intervalMinutes !== null && w.intervalMinutes !== '')
+        out.intervalMinutes = Number(w.intervalMinutes);
+    return out;
+}
+/** What the settings page shows for one watch. */
+function watchView(store, source, lang) {
+    return {
+        id: source.id,
+        label: source.label,
+        url: source.url,
+        keywords: source.keywords.join(' '),
+        enabled: source.enabled,
+        intervalMinutes: source.intervalMinutes,
+        status: describeWatch(store, source, lang),
+        summary: describeKeywords(source, lang),
+        report: store.get(watchReportKey(source.id)) ?? null,
+    };
+}
 export function apiHandlers(runtime, clock = Date.now) {
     const langOf = (body) => runtime.fixedLang() ?? detectLang(typeof body.lang === 'string' ? body.lang : undefined);
     const need = (lang) => {
@@ -77,6 +109,7 @@ export function apiHandlers(runtime, clock = Date.now) {
         return buildBoard(store, {
             now: at, lang, github: { enabled: settings.githubEnabled, markRead: settings.markRead },
             mailAccounts: runtime.accounts(),
+            watches: runtime.watches(),
         });
     };
     /** Everything the settings page shows. No secret is ever included. */
@@ -108,6 +141,7 @@ export function apiHandlers(runtime, clock = Date.now) {
                 ...secrets.available && secrets.file !== undefined ? { file: { path: secrets.file.path, why: secrets.file.why[lang] } } : {},
             },
             accounts,
+            watches: watchSources(store).map(source => watchView(store, source, lang)),
             notify: {
                 settings: notifySettings(store),
                 channels: await Promise.all(['desktop', 'feishu'].map(async (id) => {
@@ -194,7 +228,7 @@ export function apiHandlers(runtime, clock = Date.now) {
         '/ask': async (body) => {
             const lang = langOf(body);
             const ask = (body.ask ?? {});
-            const kinds = ['matter', 'series', 'summary', 'github-error', 'mail-error', 'mail-setup'];
+            const kinds = ['matter', 'series', 'summary', 'github-error', 'mail-error', 'mail-setup', 'watch-error', 'watch-setup'];
             if (typeof ask.kind !== 'string' || !kinds.includes(ask.kind))
                 throw new ApiError(lang === 'zh' ? '不认识要问什么' : 'Unknown question');
             const request = {
@@ -202,6 +236,7 @@ export function apiHandlers(runtime, clock = Date.now) {
                 ...ask.id === undefined ? {} : { id: Number(ask.id) },
                 ...ask.accountId === undefined ? {} : { accountId: Number(ask.accountId) },
                 ...ask.preset === undefined ? {} : { preset: String(ask.preset) },
+                ...ask.watchId === undefined ? {} : { watchId: Number(ask.watchId) },
                 ...typeof ask.error === 'string' && ask.error !== '' ? { error: ask.error.slice(0, 1000) } : {},
             };
             const prompt = buildAsk(need(lang), request, { now: clock(), lang, markRead: runtime.settings().markRead, accounts: runtime.accounts() });
@@ -310,6 +345,61 @@ export function apiHandlers(runtime, clock = Date.now) {
             }
             return { view: await settingsView(lang) };
         },
+        // ── things you watch yourself ─────────────────────────
+        '/watch/save': async (body) => {
+            const lang = langOf(body);
+            const source = saveWatch(need(lang), watchInput(body.watch), clock());
+            return { id: source.id, view: await settingsView(lang) };
+        },
+        /**
+         * Read it once without saving: how many entries came back, and what the
+         * first one is — enough to tell a feed from a login wall.
+         */
+        '/watch/test': async (body) => {
+            const lang = langOf(body);
+            const input = watchInput(body.watch);
+            const source = resolveWatch(input, input.id ?? 0);
+            let page;
+            try {
+                page = await runtime.watchFetch(source.url);
+            }
+            catch (error) {
+                throw new MishuError(describeWatchError(error, source));
+            }
+            if (page.status >= 400)
+                throw new ApiError(lang === 'zh' ? `这个网址返回 ${page.status}` : `The address answered ${page.status}`);
+            const items = readWatchBody({ body: page.body, contentType: page.contentType, url: source.url, now: clock() });
+            if (items.length === 0)
+                throw new ApiError(lang === 'zh' ? '读到了，但里面没有内容' : 'It loaded, but there was nothing in it');
+            const first = items[0];
+            const words = parseKeywords(input.keywords);
+            const haystack = `${first.title}\n${first.text}`.toLowerCase();
+            const hit = words.find(word => haystack.includes(word));
+            return {
+                items: items.length,
+                title: first.title.slice(0, 120),
+                excerpt: first.text.slice(0, 200),
+                ...words.length === 0 ? {} : { keywordHit: hit !== undefined, ...hit === undefined ? {} : { keyword: hit } },
+            };
+        },
+        '/watch/delete': async (body) => {
+            const lang = langOf(body);
+            if (!deleteWatch(need(lang), Number(body.id), clock()))
+                throw new ApiError(lang === 'zh' ? `没有 #${body.id} 这个关注` : `There is no watch #${body.id}`);
+            return { view: await settingsView(lang) };
+        },
+        /** Look at it right now, whatever the interval says. */
+        '/watch/sync': async (body) => {
+            const lang = langOf(body);
+            const store = need(lang);
+            const source = watchById(store, Number(body.id));
+            if (source === undefined)
+                throw new ApiError(lang === 'zh' ? `没有 #${body.id} 这个关注` : `There is no watch #${body.id}`);
+            const report = await runtime.syncWatchSource(source);
+            if (report?.error !== undefined)
+                throw new ApiError(report.error[lang]);
+            return { report: report ?? null, board: board(store, lang), view: await settingsView(lang) };
+        },
         /** Whether the page's "restart DSH" button can work here, and if not, what to do instead. */
         '/restart/info': async (body) => {
             const plan = runtime.restarter.plan();

package/lib/dsh/runtime.js

@@ -4,12 +4,14 @@
  * what you set on the settings page on top), the keychain, and one sync of
  * every source at a time.
  */
-import { dayOf, detectLang, effectiveSettings, GitHubClient, ImapFetcher, mailAccounts, mailReportKey, renderBrief, buildBoard, DesktopChannel, FeishuChannel, FileSecrets, GithubDeviceLogin, KeychainOrFile, notifySettings, notifyTick, mishuPaths, resolveGithubToken, secretAccount, secretFromEnv, syncGithub, syncMail, systemSecrets, tickManual, bi, restartPlan, scheduleRestart, } from "../core/index.js";
+import { dayOf, detectLang, effectiveSettings, GitHubClient, ImapFetcher, mailAccounts, mailReportKey, renderBrief, buildBoard, DesktopChannel, FeishuChannel, FileSecrets, GithubDeviceLogin, KeychainOrFile, notifySettings, notifyTick, mishuPaths, resolveGithubToken, secretAccount, secretFromEnv, syncGithub, syncMail, systemSecrets, tickManual, bi, restartPlan, scheduleRestart, dueWatches, httpFetch, syncWatch, watchReportKey, watchSources, } from "../core/index.js";
 export class Runtime {
     store;
     config;
     secrets;
     fetcher;
+    /** How watched addresses are read; tests swap it for a fake. */
+    watchFetch = httpFetch;
     logger;
     syncing;
     /** Where reminders can go; tests swap them for recorders. */
@@ -44,6 +46,9 @@ export class Runtime {
     accounts() {
         return this.store === undefined ? [] : mailAccounts(this.store);
     }
+    watches() {
+        return this.store === undefined ? [] : watchSources(this.store);
+    }
     brief(lang = this.lang()) {
         const store = this.store;
         if (store === undefined)
@@ -55,6 +60,7 @@ export class Runtime {
             now, lang, upcomingDays: this.config.upcomingDays,
             github: { enabled: settings.githubEnabled, markRead: settings.markRead },
             mailAccounts: this.accounts(),
+            watches: this.watches(),
         });
     }
     /** The password for an account: keychain first, then the documented environment variable. */
@@ -109,6 +115,15 @@ export class Runtime {
         this.logger.info(`dsh-mishu: mail #${account.id} ${report.error === undefined ? `ok (${report.messages} unread, +${report.opened} open, ${report.closed} closed)` : 'failed'}`);
         return report;
     }
+    /** One watch; the result is also kept as its last report. */
+    async syncWatchSource(source) {
+        const store = this.store;
+        if (store === undefined)
+            return undefined;
+        const report = await syncWatch({ store, source, fetcher: this.watchFetch, now: Date.now() });
+        this.logger.info(`dsh-mishu: watch #${source.id} ${report.error === undefined ? `ok (${report.items} items, +${report.opened} open, ${report.closed} closed)` : 'failed'}`);
+        return report;
+    }
     /** The channels that are turned on and work on this computer. */
     async activeChannels() {
         const store = this.store;
@@ -125,7 +140,7 @@ export class Runtime {
     /** The board as the brief describes it. */
     board(now, lang = this.lang()) {
         const settings = this.settings();
-        return buildBoard(this.store, { now, lang, github: { enabled: settings.githubEnabled, markRead: settings.markRead }, mailAccounts: this.accounts() });
+        return buildBoard(this.store, { now, lang, github: { enabled: settings.githubEnabled, markRead: settings.markRead }, mailAccounts: this.accounts(), watches: this.watches() });
     }
     /** Send what is due now: urgent items, the daily brief. One at a time. */
     notify(now = Date.now()) {
@@ -151,6 +166,9 @@ export class Runtime {
             for (const account of this.accounts().filter(a => a.enabled)) {
                 await this.syncMailAccount(account).catch(error => this.logger.warn(`dsh-mishu: mail #${account.id} sync failed (${error.message})`));
             }
+            for (const source of dueWatches(store, Date.now())) {
+                await this.syncWatchSource(source).catch(error => this.logger.warn(`dsh-mishu: watch #${source.id} failed (${error.message})`));
+            }
             // What the sync turned up may be urgent.
             await this.notify();
         })().finally(() => { this.syncing = undefined; });