dsh-mishu 0.6.2 → 0.7.1

package/lib/core/channels.js

@@ -0,0 +1,142 @@
+/**
+ * Where reminders go.
+ *
+ *   desktop  this computer's own notifications: macOS through osascript,
+ *            Windows through a PowerShell toast, Linux through notify-send.
+ *            A server without a desktop has none and says so.
+ *   feishu   a custom bot in a Feishu / Lark group (just you is fine). Its
+ *            webhook address and optional signing secret are secrets: they
+ *            live in the keychain (or the secrets file), never the notebook.
+ *
+ * Text reaches the helper programs as arguments to a fixed script or on
+ * stdin, never inside the script itself, so nothing in a title can run.
+ */
+import { createHmac } from 'node:crypto';
+import { findProgram, runProgram } from "./exec.js";
+import { bi, MishuError } from "./i18n.js";
+const one = (text, max) => (text.length > max ? `${text.slice(0, max - 1)}…` : text);
+export class DesktopChannel {
+    id = 'desktop';
+    platform;
+    env;
+    constructor(platform = process.platform, env = process.env) {
+        this.platform = platform;
+        this.env = env;
+    }
+    async status() {
+        if (this.platform === 'darwin')
+            return findProgram('osascript') === undefined ? { available: false, why: bi('没找到 osascript', 'osascript was not found') } : { available: true };
+        if (this.platform === 'win32')
+            return findProgram('powershell') === undefined ? { available: false, why: bi('没找到 Windows PowerShell', 'Windows PowerShell was not found') } : { available: true };
+        if (this.env.DISPLAY === undefined && this.env.WAYLAND_DISPLAY === undefined) {
+            return { available: false, why: bi('这台电脑没有桌面（比如服务器），弹不出电脑通知。用飞书就行。', 'This computer has no desktop (a server, say), so it cannot show notifications. Use Feishu instead.') };
+        }
+        return findProgram('notify-send') === undefined
+            ? { available: false, why: bi('没找到 notify-send（Debian/Ubuntu：sudo apt install libnotify-bin）', 'notify-send was not found (Debian/Ubuntu: sudo apt install libnotify-bin)') }
+            : { available: true };
+    }
+    async send(message) {
+        const title = one(message.title, 80);
+        const body = one(message.body, 200);
+        let result;
+        if (this.platform === 'darwin') {
+            result = await runProgram(findProgram('osascript'), ['-e', 'on run argv', '-e', 'display notification (item 2 of argv) with title (item 1 of argv) sound name "default"', '-e', 'end run', title, body]);
+        }
+        else if (this.platform === 'win32') {
+            result = await runProgram(findProgram('powershell'), ['-NoProfile', '-NonInteractive', '-Command', WINDOWS_TOAST], `${title}\n${body}`);
+        }
+        else {
+            result = await runProgram(findProgram('notify-send'), ['-a', 'DSH', title, body]);
+        }
+        if (result.code !== 0)
+            throw new Error(`notification failed (${(result.stderr.trim() || result.failure || `exit ${result.code}`).slice(0, 200)})`);
+    }
+}
+// Title on the first line of stdin, body after it; shown as Windows PowerShell's toast.
+const WINDOWS_TOAST = [
+    '$t=[Console]::In.ReadLine();$b=[Console]::In.ReadToEnd();',
+    '[void][Windows.UI.Notifications.ToastNotificationManager,Windows.UI.Notifications,ContentType=WindowsRuntime];',
+    '$x=[Windows.UI.Notifications.ToastNotificationManager]::GetTemplateContent([Windows.UI.Notifications.ToastTemplateType]::ToastText02);',
+    "$n=$x.GetElementsByTagName('text');[void]$n.Item(0).AppendChild($x.CreateTextNode($t));[void]$n.Item(1).AppendChild($x.CreateTextNode($b));",
+    "[Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier('{1AC14E77-02E7-4E5D-B744-2EB1AE5198B7}\\WindowsPowerShell\\v1.0\\powershell.exe').Show([Windows.UI.Notifications.ToastNotification]::new($x))",
+].join('');
+export const FEISHU_WEBHOOK = 'feishu:webhook';
+export const FEISHU_SECRET = 'feishu:secret';
+const WEBHOOK = /^https:\/\/open\.(feishu\.cn|larksuite\.com)\/open-apis\/bot\/v2\/hook\/[\w-]{8,}$/;
+/** Feishu's errors for a custom bot, said so you know what to change in the group's bot settings. */
+function feishuError(code, msg) {
+    if (code === 19024)
+        return bi('飞书拒收：消息里没有机器人设置的关键词。把关键词设成"小秘书"，或者改用签名校验。', 'Feishu refused it: the message lacks the bot\'s keyword. Set the keyword to "小秘书" or use signature verification instead.');
+    if (code === 19021)
+        return bi('飞书拒收：签名不对。把机器人"签名校验"里的密钥重新复制过来。', 'Feishu refused it: wrong signature. Copy the bot\'s signing secret again.');
+    if (code === 19022)
+        return bi('飞书拒收：这台电脑的 IP 不在机器人的 IP 白名单里。', 'Feishu refused it: this computer\'s IP is not on the bot\'s allowlist.');
+    if (code === 19001 || /not found|invalid/i.test(msg))
+        return bi('飞书找不到这个机器人：地址抄错了，或者机器人已经被删掉。', 'Feishu does not know this bot: the address is mistyped or the bot was removed.');
+    return bi(`飞书拒收（${code}：${msg}）`, `Feishu refused it (${code}: ${msg})`);
+}
+export class FeishuChannel {
+    id = 'feishu';
+    secrets;
+    post;
+    constructor(secrets, post) {
+        this.secrets = secrets;
+        this.post = post ?? globalThis.fetch;
+    }
+    async status() {
+        return await this.secrets.get(FEISHU_WEBHOOK).catch(() => undefined) === undefined
+            ? { available: false, why: bi('还没填飞书机器人的地址。', 'No Feishu bot address yet.') }
+            : { available: true };
+    }
+    async send(message) {
+        const webhook = await this.secrets.get(FEISHU_WEBHOOK);
+        if (webhook === undefined)
+            throw new MishuError(bi('还没填飞书机器人的地址。', 'No Feishu bot address yet.'));
+        await sendFeishu(this.post, webhook, await this.secrets.get(FEISHU_SECRET), message.text);
+    }
+}
+async function sendFeishu(post, webhook, secret, text, now = Date.now()) {
+    const timestamp = String(Math.floor(now / 1000));
+    // Feishu signs with HMAC-SHA256 keyed by "timestamp\nsecret" over an empty message.
+    const signed = secret === undefined ? {} : { timestamp, sign: createHmac('sha256', `${timestamp}\n${secret}`).update('').digest('base64') };
+    const response = await post(webhook, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json; charset=utf-8' },
+        body: JSON.stringify({ ...signed, msg_type: 'text', content: { text } }),
+    });
+    const raw = await response.text();
+    let answer;
+    try {
+        answer = JSON.parse(raw);
+    }
+    catch {
+        throw new MishuError(bi(`飞书没有正常回应（HTTP ${response.status}）`, `Feishu did not answer properly (HTTP ${response.status})`));
+    }
+    const code = answer.code ?? answer.StatusCode ?? 0;
+    if (code !== 0)
+        throw new MishuError(feishuError(code, answer.msg ?? answer.StatusMessage ?? ''));
+}
+/**
+ * Keep a bot address (and its signing secret, if the bot uses one) after
+ * sending a first message through it, so a wrong address never gets saved.
+ */
+export async function saveFeishu(secrets, input, lang, post) {
+    const webhook = input.webhook.trim();
+    const secret = input.secret?.trim() || undefined;
+    if (!WEBHOOK.test(webhook)) {
+        throw new MishuError(bi('这不像飞书机器人的地址：应该以 https://open.feishu.cn/open-apis/bot/v2/hook/ 开头。', 'That is not a Feishu bot address: it starts with https://open.feishu.cn/open-apis/bot/v2/hook/.'));
+    }
+    const status = await secrets.status();
+    if (!status.available)
+        throw new MishuError(bi(`没法保存：${status.why.zh}`, `Cannot save it: ${status.why.en}`));
+    await sendFeishu(post ?? globalThis.fetch, webhook, secret, lang === 'zh' ? '小秘书已经连上这个群，以后的提醒会发到这里。' : 'The secretary is connected to this group; reminders will come here.');
+    await secrets.set(FEISHU_WEBHOOK, webhook);
+    if (secret === undefined)
+        await secrets.delete(FEISHU_SECRET);
+    else
+        await secrets.set(FEISHU_SECRET, secret);
+}
+export async function deleteFeishu(secrets) {
+    await secrets.delete(FEISHU_WEBHOOK);
+    await secrets.delete(FEISHU_SECRET);
+}

package/lib/core/index.js

@@ -24,6 +24,8 @@ export { ImapFetcher } from "./mail/imap.js";
 export { judgeMail } from "./mail/rules.js";
 export { describeMailError, MAIL_SOURCE, mailReportKey, syncMail } from "./mail/sync.js";
 export { findProgram } from "./exec.js";
+export { deleteFeishu, DesktopChannel, FeishuChannel, saveFeishu, FEISHU_WEBHOOK } from "./channels.js";
+export { DEFAULT_NOTIFY, deliver, inQuiet, localClock, notifySettings, notifyTick, NOTIFY_REPORT_KEY, saveNotifySettings, testMessage, URGENT_REASONS, } from "./notify.js";
 export { restartPlan, scheduleRestart } from "./restart.js";
 export { FileSecrets, KeychainOrFile, MemorySecrets, secretEnvName, secretFromEnv, systemSecrets } from "./secrets.js";
 export { deleteMailAccount, effectiveSettings, mailAccounts, saveMailAccount, saveSettings } from "./settings.js";

package/lib/core/notify.js

@@ -0,0 +1,198 @@
+/**
+ * Reaching you without you opening the board: a daily brief, urgent items
+ * as they come, and quiet hours.
+ *
+ * Urgent means someone is waiting on you or it is due today:
+ *   - things you told it: due today or overdue
+ *   - GitHub: a review requested, a mention, an assignment
+ *   - mail: a meeting invitation
+ * Everything else waits for the daily brief. Each urgent item is sent once
+ * (again only when it changes reason or due day); turning reminders on does
+ * not send what was already on the board. During quiet hours nothing is
+ * sent; what came up is sent when they end.
+ *
+ * Times are read in the time zone your browser reported, so a server
+ * running on UTC still sends the brief at your morning.
+ */
+import { reasonLabel } from "./brief.js";
+import { bi, decode, MishuError } from "./i18n.js";
+import { isActive } from "./matters.js";
+import { dayOf } from "./time.js";
+export const DEFAULT_NOTIFY = {
+    brief: { enabled: true, time: '09:00' },
+    urgent: true,
+    quiet: { enabled: true, from: '22:00', to: '08:00' },
+    timeZone: '',
+    channels: { desktop: true, feishu: false },
+};
+export const URGENT_REASONS = ['review-requested', 'mentioned', 'assigned', 'mail-invite'];
+const SETTINGS_KEY = 'notify.settings';
+const STATE_KEY = 'notify.state';
+export const NOTIFY_REPORT_KEY = 'notify.last';
+export function notifySettings(store) {
+    const saved = store.get(SETTINGS_KEY) ?? {};
+    return {
+        brief: { ...DEFAULT_NOTIFY.brief, ...saved.brief },
+        urgent: saved.urgent ?? DEFAULT_NOTIFY.urgent,
+        quiet: { ...DEFAULT_NOTIFY.quiet, ...saved.quiet },
+        timeZone: saved.timeZone ?? DEFAULT_NOTIFY.timeZone,
+        channels: { ...DEFAULT_NOTIFY.channels, ...saved.channels },
+    };
+}
+const TIME = /^([01]\d|2[0-3]):[0-5]\d$/;
+/** Check what the page sent and keep it; throws a sentence a person can act on. */
+export function saveNotifySettings(store, input, now) {
+    const current = notifySettings(store);
+    const next = {
+        brief: { ...current.brief, ...input.brief },
+        urgent: input.urgent ?? current.urgent,
+        quiet: { ...current.quiet, ...input.quiet },
+        timeZone: input.timeZone ?? current.timeZone,
+        channels: { ...current.channels, ...input.channels },
+    };
+    for (const time of [next.brief.time, next.quiet.from, next.quiet.to]) {
+        if (!TIME.test(time))
+            throw new MishuError(bi(`时间要写成 08:30 这样：${time}`, `Write times like 08:30: ${time}`));
+    }
+    if (next.timeZone !== '') {
+        try {
+            new Intl.DateTimeFormat('en', { timeZone: next.timeZone });
+        }
+        catch {
+            throw new MishuError(bi(`不认识这个时区：${next.timeZone}`, `Unknown time zone: ${next.timeZone}`));
+        }
+    }
+    store.set(SETTINGS_KEY, next);
+    store.log(now, 'notify-settings', next);
+    return next;
+}
+/** The day and minute of the day in a time zone ('' = this computer's). */
+export function localClock(now, timeZone) {
+    const parts = new Intl.DateTimeFormat('en-CA', {
+        ...timeZone === '' ? {} : { timeZone },
+        year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', hourCycle: 'h23',
+    }).formatToParts(new Date(now));
+    const part = (type) => parts.find(p => p.type === type)?.value ?? '00';
+    return { day: `${part('year')}-${part('month')}-${part('day')}`, minutes: Number(part('hour')) * 60 + Number(part('minute')) };
+}
+const minutesOf = (time) => Number(time.slice(0, 2)) * 60 + Number(time.slice(3, 5));
+/** Whether a minute of the day is inside quiet hours, which may run past midnight. */
+export function inQuiet(minutes, quiet) {
+    if (!quiet.enabled)
+        return false;
+    const from = minutesOf(quiet.from);
+    const to = minutesOf(quiet.to);
+    if (from === to)
+        return false;
+    return from < to ? minutes >= from && minutes < to : minutes >= from || minutes < to;
+}
+/** Open items someone is waiting on, or due today. */
+export function urgentMatters(store, today) {
+    return store.openMatters().filter(m => isActive(m, today) && (m.source === 'manual' ? m.dueDay !== null && m.dueDay <= today : URGENT_REASONS.includes(m.reason ?? '')));
+}
+const urgentKey = (m) => `${m.id}:${m.reason ?? ''}:${m.dueDay ?? ''}`;
+const SIGN = bi('打开小秘书看板处理。', 'Open the secretary board to handle them.');
+function urgentMessage(matters, lang) {
+    const zh = lang === 'zh';
+    const line = (m) => {
+        const why = m.source === 'manual' ? (zh ? `${m.dueDay} 到期` : `due ${m.dueDay}`) : reasonLabel(m.reason, lang);
+        return `• ${decode(m.title, lang)}${why === '' ? '' : `（${why}）`}`;
+    };
+    const first = decode(matters[0].title, lang);
+    return {
+        kind: 'urgent',
+        title: zh ? `小秘书：${matters.length} 件急事` : `Secretary: ${matters.length} urgent`,
+        body: matters.length === 1 ? first : (zh ? `${first} 等 ${matters.length} 件` : `${first} and ${matters.length - 1} more`),
+        text: [zh ? `小秘书：${matters.length} 件急事` : `Secretary: ${matters.length} urgent`, ...matters.slice(0, 10).map(line),
+            ...matters.length > 10 ? [zh ? `…还有 ${matters.length - 10} 件` : `…and ${matters.length - 10} more`] : [], SIGN[lang]].join('\n'),
+    };
+}
+/** The brief, from what the board shows; `undefined` when there is nothing to tell. */
+export function briefMessage(board, lang) {
+    const zh = lang === 'zh';
+    const { handle, remember } = board.columns;
+    if (handle.length === 0 && board.metrics.dueSoon === 0)
+        return undefined;
+    const lines = handle.slice(0, 10).map(card => `• ${card.title}（${card.meta}）`);
+    const soon = remember.filter(card => card.tone !== 'normal').slice(0, 5).map(card => `• ${card.title}（${card.meta}）`);
+    const title = zh ? '小秘书 · 今日简报' : 'Secretary · daily brief';
+    return {
+        kind: 'brief',
+        title,
+        body: board.summary,
+        text: [title, board.summary,
+            ...lines.length > 0 ? ['', zh ? '要你处理：' : 'To handle:', ...lines] : [],
+            ...handle.length > 10 ? [zh ? `…还有 ${handle.length - 10} 件` : `…and ${handle.length - 10} more`] : [],
+            ...soon.length > 0 ? ['', zh ? '快到期：' : 'Coming up:', ...soon] : [],
+            '', SIGN[lang]].join('\n'),
+    };
+}
+export function testMessage(lang) {
+    return lang === 'zh'
+        ? { kind: 'test', title: '小秘书', body: '提醒能送到这里。', text: '小秘书：提醒能送到这里。' }
+        : { kind: 'test', title: 'Secretary', body: 'Reminders reach you here.', text: 'Secretary: reminders reach you here.' };
+}
+/** Send to every enabled channel; one failing does not stop the others. */
+export async function deliver(store, channels, message, count, now) {
+    const results = [];
+    for (const channel of channels) {
+        try {
+            await channel.send(message);
+            results.push({ channel: channel.id, ok: true });
+        }
+        catch (error) {
+            results.push({ channel: channel.id, ok: false, error: error instanceof MishuError ? error.text.en : error.message });
+        }
+    }
+    const report = { at: now, kind: message.kind, count, results };
+    if (message.kind !== 'test')
+        store.set(NOTIFY_REPORT_KEY, report);
+    // Counts and channels only: titles never go to the log.
+    store.log(now, 'notify', { kind: message.kind, count, results: results.map(r => ({ channel: r.channel, ok: r.ok })) });
+    return report;
+}
+/**
+ * One look at the clock: send what is due. Called every minute and after
+ * each sync. `channels` are the enabled ones; `board` builds the brief.
+ */
+export async function notifyTick(options) {
+    const { store, now, lang, channels } = options;
+    const settings = notifySettings(store);
+    if (channels.length === 0)
+        return [];
+    const clock = localClock(now, settings.timeZone);
+    const today = dayOf(now);
+    const urgent = urgentMatters(store, today);
+    let state = store.get(STATE_KEY);
+    if (state === undefined) {
+        // First look: what is already on the board is not news, and a brief whose time has passed waits for tomorrow.
+        state = { sent: Object.fromEntries(urgent.map(m => [urgentKey(m), now])) };
+        if (clock.minutes >= minutesOf(settings.brief.time))
+            state.briefDay = clock.day;
+        store.set(STATE_KEY, state);
+        return [];
+    }
+    const reports = [];
+    if (!inQuiet(clock.minutes, settings.quiet)) {
+        const fresh = settings.urgent ? urgent.filter(m => state.sent[urgentKey(m)] === undefined) : [];
+        if (fresh.length > 0) {
+            reports.push(await deliver(store, channels, urgentMessage(fresh, lang), fresh.length, now));
+            for (const m of fresh)
+                state.sent[urgentKey(m)] = now;
+        }
+        if (settings.brief.enabled && state.briefDay !== clock.day && clock.minutes >= minutesOf(settings.brief.time)) {
+            state.briefDay = clock.day;
+            const board = options.board();
+            const message = briefMessage(board, lang);
+            if (message !== undefined)
+                reports.push(await deliver(store, channels, message, board.columns.handle.length, now));
+        }
+    }
+    // Forget what was sent for items closed a week ago.
+    const open = new Set(urgent.map(urgentKey));
+    for (const [key, at] of Object.entries(state.sent))
+        if (!open.has(key) && now - at > 7 * 86_400_000)
+            delete state.sent[key];
+    store.set(STATE_KEY, state);
+    return reports;
+}

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, 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 { 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 { resolveAccount } from "../core/mail/account.js";
 export const API_BASE = '/api/dsh-mishu';
 class ApiError extends Error {
@@ -108,6 +108,15 @@ export function apiHandlers(runtime, clock = Date.now) {
                 ...secrets.available && secrets.file !== undefined ? { file: { path: secrets.file.path, why: secrets.file.why[lang] } } : {},
             },
             accounts,
+            notify: {
+                settings: notifySettings(store),
+                channels: await Promise.all(['desktop', 'feishu'].map(async (id) => {
+                    const status = await runtime.channels[id].status();
+                    return { id, enabled: notifySettings(store).channels[id], available: status.available, ...status.available ? {} : { why: status.why[lang] } };
+                })),
+                feishu: { configured: (await runtime.secrets.get(FEISHU_WEBHOOK).catch(() => undefined)) !== undefined },
+                last: store.get(NOTIFY_REPORT_KEY) ?? null,
+            },
             presets: MAIL_PRESETS.map(p => ({
                 id: p.id, label: p.label[lang], host: p.host, port: p.port, secure: p.secure, supported: p.supported, howTo: p.howTo[lang],
                 domains: p.domains, passwordLength: p.passwordLength ?? null,
@@ -234,6 +243,43 @@ export function apiHandlers(runtime, clock = Date.now) {
             await deleteGithubToken(runtime.secrets);
             return { view: await settingsView(langOf(body)) };
         },
+        // ── reminders ─────────────────────────────────────────
+        '/notify/save': async (body) => {
+            const lang = langOf(body);
+            saveNotifySettings(need(lang), (body.notify ?? {}), clock());
+            return { view: await settingsView(lang) };
+        },
+        /** One test message through one channel, turned on or not. */
+        '/notify/test': async (body) => {
+            const lang = langOf(body);
+            const id = String(body.channel);
+            const channel = runtime.channels[id];
+            if (channel === undefined)
+                throw new ApiError(lang === 'zh' ? '没有这个渠道' : 'No such channel');
+            const status = await channel.status();
+            if (!status.available)
+                throw new ApiError(status.why[lang]);
+            const report = await deliver(need(lang), [channel], testMessage(lang), 0, clock());
+            const failed = report.results.find(r => !r.ok);
+            if (failed !== undefined)
+                throw new ApiError(failed.error ?? '');
+            return { sent: true };
+        },
+        /** A Feishu bot: tried with a first message, then kept as a secret; reminders go there from now on. */
+        '/feishu/save': async (body) => {
+            const lang = langOf(body);
+            const store = need(lang);
+            await saveFeishu(runtime.secrets, { webhook: String(body.webhook ?? ''), ...typeof body.secret === 'string' ? { secret: body.secret } : {} }, lang);
+            saveNotifySettings(store, { channels: { ...notifySettings(store).channels, feishu: true } }, clock());
+            return { view: await settingsView(lang) };
+        },
+        '/feishu/delete': async (body) => {
+            const lang = langOf(body);
+            const store = need(lang);
+            await deleteFeishu(runtime.secrets);
+            saveNotifySettings(store, { channels: { ...notifySettings(store).channels, feishu: false } }, clock());
+            return { view: await settingsView(lang) };
+        },
         '/mail/save': async (body) => {
             const lang = langOf(body);
             const account = await saveMailAccount(need(lang), runtime.secrets, accountInput(body.account), password(body), clock());

package/lib/dsh/plugin.js

@@ -64,12 +64,16 @@ export function apply(ctx, config, runtime = new Runtime(config, ctx.logger)) {
         firstSync.unref();
         const syncTimer = setInterval(() => { void runtime.syncAll(); }, config.github.intervalMinutes * 60_000);
         syncTimer.unref();
+        // Reminders look at the clock every minute: the brief's time, the end of quiet hours.
+        const notifyTimer = setInterval(() => { void runtime.notify(); }, 60_000);
+        notifyTimer.unref();
         const settings = runtime.settings();
         ctx.logger.info(`dsh-mishu: notebook ${paths.db}; language ${runtime.lang()}; github ${settings.githubEnabled ? `every ${config.github.intervalMinutes} min, mark read ${settings.markRead}` : 'off'}; ${runtime.accounts().length} mail account(s); secrets in ${runtime.secrets.kind}`);
         return async () => {
             clearInterval(tickTimer);
             clearTimeout(firstSync);
             clearInterval(syncTimer);
+            clearInterval(notifyTimer);
             await Promise.race([runtime.idle(), new Promise(resolve => setTimeout(resolve, 5000).unref())]);
             opened.close();
             runtime.store = undefined;

package/lib/dsh/runtime.js

@@ -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 { dayOf, detectLang, effectiveSettings, GitHubClient, ImapFetcher, mailAccounts, mailReportKey, renderBrief, FileSecrets, GithubDeviceLogin, KeychainOrFile, 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, } from "../core/index.js";
 export class Runtime {
     store;
     config;
@@ -12,6 +12,9 @@ export class Runtime {
     fetcher;
     logger;
     syncing;
+    /** Where reminders can go; tests swap them for recorders. */
+    channels;
+    notifying;
     /** "Sign in with GitHub" in progress, if any; tests swap it to replay GitHub. */
     githubLogin;
     /** How DSH restarts; tests swap it so they never restart anything. */
@@ -21,6 +24,7 @@ export class Runtime {
         this.logger = logger;
         this.secrets = secrets;
         this.githubLogin = new GithubDeviceLogin({ clientId: config.github.clientId, secrets });
+        this.channels = { desktop: new DesktopChannel(), feishu: new FeishuChannel(secrets) };
         this.fetcher = fetcher;
     }
     defaults() {
@@ -105,6 +109,38 @@ 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;
     }
+    /** The channels that are turned on and work on this computer. */
+    async activeChannels() {
+        const store = this.store;
+        if (store === undefined)
+            return [];
+        const enabled = notifySettings(store).channels;
+        const active = [];
+        for (const id of Object.keys(enabled)) {
+            if (enabled[id] && (await this.channels[id].status()).available)
+                active.push(this.channels[id]);
+        }
+        return active;
+    }
+    /** 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() });
+    }
+    /** Send what is due now: urgent items, the daily brief. One at a time. */
+    notify(now = Date.now()) {
+        const store = this.store;
+        if (store === undefined)
+            return Promise.resolve([]);
+        this.notifying ??= (async () => {
+            const lang = this.lang();
+            return notifyTick({ store, now, lang, channels: await this.activeChannels(), board: () => this.board(now, lang) });
+        })().catch((error) => {
+            this.logger.warn(`dsh-mishu: reminders failed (${error.message})`);
+            return [];
+        }).finally(() => { this.notifying = undefined; });
+        return this.notifying;
+    }
     /** Every source once; concurrent callers share the sync in flight. */
     syncAll() {
         const store = this.store;
@@ -115,6 +151,8 @@ 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})`));
             }
+            // What the sync turned up may be urgent.
+            await this.notify();
         })().finally(() => { this.syncing = undefined; });
         return this.syncing;
     }

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

@@ -0,0 +1,61 @@
+/**
+ * Where reminders go.
+ *
+ *   desktop  this computer's own notifications: macOS through osascript,
+ *            Windows through a PowerShell toast, Linux through notify-send.
+ *            A server without a desktop has none and says so.
+ *   feishu   a custom bot in a Feishu / Lark group (just you is fine). Its
+ *            webhook address and optional signing secret are secrets: they
+ *            live in the keychain (or the secrets file), never the notebook.
+ *
+ * Text reaches the helper programs as arguments to a fixed script or on
+ * stdin, never inside the script itself, so nothing in a title can run.
+ */
+import { type Bi } from './i18n.ts';
+import type { Channel, Message } from './notify.ts';
+import type { SecretStore } from './secrets.ts';
+export declare class DesktopChannel implements Channel {
+    readonly id: "desktop";
+    private readonly platform;
+    private readonly env;
+    constructor(platform?: NodeJS.Platform, env?: NodeJS.ProcessEnv);
+    status(): Promise<{
+        available: true;
+    } | {
+        available: false;
+        why: Bi;
+    }>;
+    send(message: Message): Promise<void>;
+}
+export declare const FEISHU_WEBHOOK = "feishu:webhook";
+export declare const FEISHU_SECRET = "feishu:secret";
+export type JsonPost = (url: string, init: {
+    method: 'POST';
+    headers: Record<string, string>;
+    body: string;
+}) => Promise<{
+    status: number;
+    text(): Promise<string>;
+}>;
+export declare class FeishuChannel implements Channel {
+    readonly id: "feishu";
+    private readonly secrets;
+    private readonly post;
+    constructor(secrets: SecretStore, post?: JsonPost);
+    status(): Promise<{
+        available: true;
+    } | {
+        available: false;
+        why: Bi;
+    }>;
+    send(message: Message): Promise<void>;
+}
+/**
+ * Keep a bot address (and its signing secret, if the bot uses one) after
+ * sending a first message through it, so a wrong address never gets saved.
+ */
+export declare function saveFeishu(secrets: SecretStore, input: {
+    webhook: string;
+    secret?: string;
+}, lang: 'zh' | 'en', post?: JsonPost): Promise<void>;
+export declare function deleteFeishu(secrets: SecretStore): Promise<void>;

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

@@ -23,6 +23,8 @@ export { ImapFetcher } from './mail/imap.ts';
 export { judgeMail } from './mail/rules.ts';
 export { describeMailError, MAIL_SOURCE, mailReportKey, syncMail, type MailSyncReport } from './mail/sync.ts';
 export { findProgram } from './exec.ts';
+export { deleteFeishu, DesktopChannel, FeishuChannel, saveFeishu, FEISHU_WEBHOOK } from './channels.ts';
+export { DEFAULT_NOTIFY, deliver, inQuiet, localClock, notifySettings, notifyTick, NOTIFY_REPORT_KEY, saveNotifySettings, testMessage, URGENT_REASONS, type Channel, type ChannelId, type Message, type NotifyReport, type NotifySettings, } from './notify.ts';
 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';