dsh-mishu 0.7.1 → 0.7.3

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; });

package/lib/types/core/ask.d.ts

@@ -29,6 +29,11 @@ export type AskRequest = {
     kind: 'mail-setup';
     preset: string;
     error?: string;
+} | {
+    kind: 'watch-error';
+    watchId: number;
+} | {
+    kind: 'watch-setup';
 };
 export interface AskOptions {
     now: number;

package/lib/types/core/board.d.ts

@@ -17,7 +17,7 @@ export interface BoardCard {
     /** Matter id, or series id for a series card. */
     id: number;
     target: 'matter' | 'series';
-    source: 'github' | 'mail' | 'manual';
+    source: 'github' | 'mail' | 'manual' | 'watch';
     title: string;
     /** One short line: when it is due, or why it is here. */
     meta: string;
@@ -58,6 +58,12 @@ export interface BoardData {
             state: 'never' | 'ok' | 'error';
             text: string;
         }>;
+        watch: Array<{
+            id: number;
+            label: string;
+            state: 'never' | 'ok' | 'error';
+            text: string;
+        }>;
     };
     markRead: MarkReadMode;
     columns: {
@@ -83,6 +89,11 @@ export interface BoardOptions {
         id: number;
         label: string;
     }>;
+    /** Things you watch yourself, for their status line. */
+    watches?: Array<{
+        id: number;
+        label: string;
+    }>;
 }
 export declare function buildBoard(store: MishuStore, options: BoardOptions): BoardData;
 export interface MatterDetail {

package/lib/types/core/brief.d.ts

@@ -27,6 +27,11 @@ export interface BriefOptions {
         id: number;
         label: string;
     }>;
+    /** Things you watch yourself, for their status lines. */
+    watches?: Array<{
+        id: number;
+        label: string;
+    }>;
 }
 export declare function renderBrief(store: MishuStore, options: BriefOptions): string;
 /** Recently closed matters with reasons, so a wrong closure can be reopened. */

package/lib/types/core/index.d.ts

@@ -28,6 +28,9 @@ export { DEFAULT_NOTIFY, deliver, inQuiet, localClock, notifySettings, notifyTic
 export { restartPlan, scheduleRestart, type RestartPlan, type RestartStarted } from './restart.ts';
 export { FileSecrets, KeychainOrFile, MemorySecrets, secretEnvName, secretFromEnv, systemSecrets, type SecretStatus, type SecretStore } from './secrets.ts';
 export { deleteMailAccount, effectiveSettings, mailAccounts, saveMailAccount, saveSettings, type Defaults, type UserSettings } from './settings.ts';
+export { deleteWatch, dueWatches, entryKey, parseKeywords, resolveWatch, saveWatch, watchById, watchReportKey, watchSources, WATCH_SOURCE, type WatchInput, type WatchReport, type WatchSource, } from './watch/source.ts';
+export { describeWatchError, httpFetch, parseFeed, parseJson, parsePage, plainText, readWatchBody, type WatchFetch, type WatchItem } from './watch/fetch.ts';
+export { describeKeywords, describeWatch, diffItems, judgeWatch, syncWatch } from './watch/sync.ts';
 export declare const DEFAULT_HOME = "~/.mishu";
 /** `~` and `~/…` expand to the home directory on every platform. */
 export declare function expandHome(path: string): string;

package/lib/types/core/watch/fetch.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 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 { type Bi } from '../i18n.ts';
+import { type WatchSource } from './source.ts';
+export interface WatchItem {
+    /** Stable across checks: the same entry twice is the same item. */
+    key: string;
+    title: string;
+    /** The text to look for keywords in, and to quote back. */
+    text: string;
+    url: string | null;
+    /** When the source says it happened; the fetch time when it does not. */
+    at: number;
+}
+export interface WatchFetch {
+    (url: string): Promise<{
+        status: number;
+        body: string;
+        contentType: string;
+    }>;
+}
+/** The real fetch: a plain GET with a short timeout and no cookies. */
+export declare const httpFetch: WatchFetch;
+/** Markup out, whitespace collapsed. */
+export declare function plainText(markup: string): string;
+/** RSS `<item>` and Atom `<entry>` blocks, whichever the document has. */
+export declare function parseFeed(body: string, now: number, base: string): WatchItem[] | undefined;
+/**
+ * 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 declare function parseJson(body: string, now: number, base: string): WatchItem[] | undefined;
+/** A page with no feed: its title and text, as one item keyed by a hash of the text. */
+export declare function parsePage(body: string, now: number, base: string): WatchItem[];
+/** Whatever the address returned, as items. */
+export declare function readWatchBody(options: {
+    body: string;
+    contentType: string;
+    url: string;
+    now: number;
+}): WatchItem[];
+/** The sentence shown when a watch cannot be read. */
+export declare function describeWatchError(error: unknown, source: WatchSource): Bi;

package/lib/types/core/watch/source.d.ts

@@ -0,0 +1,68 @@
+/**
+ * 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 { type Bi } from '../i18n.ts';
+import type { MishuStore } from '../store.ts';
+export declare const WATCH_SOURCE = "watch";
+export interface WatchSource {
+    id: number;
+    /** What you call it: "补丁公告", "机票价格". */
+    label: string;
+    url: string;
+    /**
+     * Words to watch for, lower-cased. Empty: any change is worth a card.
+     * A feed is read per entry; a page is read as one text.
+     */
+    keywords: string[];
+    enabled: boolean;
+    /** Minutes between checks. */
+    intervalMinutes: number;
+}
+export interface WatchInput {
+    id?: number;
+    label?: string;
+    url?: string;
+    keywords?: string | string[];
+    enabled?: boolean;
+    intervalMinutes?: number;
+}
+export interface WatchReport {
+    at: number;
+    id: number;
+    /** Entries or text pieces the fetch turned up. */
+    items: number;
+    opened: number;
+    closed: number;
+    error?: Bi;
+}
+export declare function watchSources(store: MishuStore): WatchSource[];
+export declare function watchById(store: MishuStore, id: number): WatchSource | undefined;
+export declare function watchReportKey(id: number): string;
+/** Where one watch keeps what it has already seen. */
+export declare function watchStateKey(id: number): string;
+export declare function watchSeenKey(id: number): string;
+/** A stable id for a feed entry: its guid, else its link, else its title. */
+export declare function entryKey(entry: {
+    id?: string;
+    link?: string;
+    title?: string;
+}): string;
+/** Split what you typed into words: commas, 、, spaces or new lines all work. */
+export declare function parseKeywords(value: string | string[] | undefined): string[];
+/** Check and complete what the settings page sent; throws a sentence a person can act on. */
+export declare function resolveWatch(input: WatchInput, id: number): WatchSource;
+/** Add (no id) or update one watch. */
+export declare function saveWatch(store: MishuStore, input: WatchInput, now: number): WatchSource;
+/** Remove one watch and close whatever it still has open. */
+export declare function deleteWatch(store: MishuStore, id: number, now: number): boolean;
+/** The watches whose next check is due. */
+export declare function dueWatches(store: MishuStore, now: number): WatchSource[];

package/lib/types/core/watch/sync.d.ts

@@ -0,0 +1,51 @@
+/**
+ * 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 type { MishuStore } from '../store.ts';
+import type { Verdict } from '../github/rules.ts';
+import { type WatchFetch, type WatchItem } from './fetch.ts';
+import { type WatchReport, type WatchSource } from './source.ts';
+interface WatchState {
+    /** Keys of entries already reported, newest last. */
+    seen: string[];
+    /** Fingerprint of the whole page, for addresses that are not feeds. */
+    digest?: string;
+    /** First check done. */
+    primed: boolean;
+}
+/** Which items are new since last time, and whether the whole page changed. */
+export declare function diffItems(items: WatchItem[], state: WatchState): {
+    fresh: WatchItem[];
+    changed: boolean;
+    digest: string;
+};
+export declare function judgeWatch(options: {
+    source: WatchSource;
+    items: WatchItem[];
+    fresh: WatchItem[];
+    changed: boolean;
+    first: boolean;
+    now: number;
+}): Verdict | undefined;
+export declare function syncWatch(options: {
+    store: MishuStore;
+    source: WatchSource;
+    fetcher: WatchFetch;
+    now: number;
+}): Promise<WatchReport>;
+/** Everything about one watch the settings page shows. */
+export declare function describeWatch(store: MishuStore, source: WatchSource, lang: 'zh' | 'en'): string;
+/** The words, for showing back to you. */
+export declare function describeKeywords(source: WatchSource, lang: 'zh' | 'en'): string;
+/** Guard for the settings page: an address that cannot be a watch at all. */
+export declare function assertWatchable(source: WatchSource): void;
+export {};

package/lib/types/dsh/runtime.d.ts

@@ -4,7 +4,7 @@
  * what you set on the settings page on top), the keychain, and one sync of
  * every source at a time.
  */
-import { GithubDeviceLogin, type Defaults, type Lang, type MailAccount, type MailFetcher, type MailSyncReport, type MishuStore, type Channel, type ChannelId, type NotifyReport, type RestartPlan, type RestartStarted, type SecretStore, type TokenResult } from '../core/index.ts';
+import { GithubDeviceLogin, type Defaults, type Lang, type MailAccount, type MailFetcher, type MailSyncReport, type MishuStore, type Channel, type ChannelId, type NotifyReport, type RestartPlan, type RestartStarted, type SecretStore, type TokenResult, type WatchFetch, type WatchReport, type WatchSource } from '../core/index.ts';
 import type { MishuConfig } from './config.ts';
 interface Logger {
     info(message: string): void;
@@ -15,6 +15,8 @@ export declare class Runtime {
     readonly config: MishuConfig;
     readonly secrets: SecretStore;
     readonly fetcher: MailFetcher;
+    /** How watched addresses are read; tests swap it for a fake. */
+    watchFetch: WatchFetch;
     private readonly logger;
     private syncing;
     /** Where reminders can go; tests swap them for recorders. */
@@ -36,6 +38,7 @@ export declare class Runtime {
     fixedLang(): Lang | undefined;
     lang(): Lang;
     accounts(): MailAccount[];
+    watches(): WatchSource[];
     brief(lang?: Lang): string;
     /** The password for an account: keychain first, then the documented environment variable. */
     mailPassword(id: number): Promise<string | undefined>;
@@ -44,6 +47,8 @@ export declare class Runtime {
     private syncGithubNow;
     /** One account; the result is also kept as its last report. */
     syncMailAccount(account: MailAccount): Promise<MailSyncReport | undefined>;
+    /** One watch; the result is also kept as its last report. */
+    syncWatchSource(source: WatchSource): Promise<WatchReport | undefined>;
     /** The channels that are turned on and work on this computer. */
     activeChannels(): Promise<Channel[]>;
     /** The board as the brief describes it. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-mishu",
-  "version": "0.7.1",
+  "version": "0.7.3",
   "description": "DSH secretary (小秘书) for DeepSeek Harness (dsh): watches GitHub notifications and the dated things you tell it (bills, renewals, documents, birthdays), closes what is already resolved, and keeps a short list of what actually needs you. Bilingual (中文 / English), macOS / Windows / Linux. · DSH 小秘书：提醒、通知、待办、消息、收件箱、秘书。GitHub 通知按当前状态分诊，交代一句就记下到期和周期事项。",
   "type": "module",
   "main": "lib/index.js",