meodp 0.0.9 → 0.2.0

package/dist/config/index.d.ts

@@ -0,0 +1,47 @@
+import { R as ReporterConfig, a as ReportVerificationOptions } from '../shared/meodp.8369c4c1.js';
+import { S as SitemapOptions } from '../shared/meodp.93e06e00.js';
+import { EmailOptions } from '../notify/email.js';
+import { FeishuOptions } from '../notify/feishu.js';
+import { NotificationOptions } from '../notify/index.js';
+
+interface ScanConfig extends Omit<SitemapOptions, 'previousReport' | 'onResult'> {
+    input?: string;
+    reporter?: ReporterConfig;
+    output?: string;
+    history?: string;
+    /** Seed missing history from a committed snapshot. */
+    historySeed?: string;
+    observerMismatch?: 'error' | 'reset';
+    site?: string;
+    failOn?: 'unavailable' | 'review' | 'none';
+}
+interface NotificationConfig extends Omit<NotificationOptions, 'previousReport' | 'mode'> {
+    input: string;
+    previousReport?: string;
+    timeZone?: string;
+    maxItems?: number;
+    feishu?: FeishuOptions & {
+        mode?: NotificationOptions['mode'];
+    };
+    email?: EmailOptions & {
+        mode?: NotificationOptions['mode'];
+    };
+}
+interface MeodpConfig {
+    /** Shared reporters; command sections may override this selection. */
+    reporter?: ReporterConfig;
+    check?: ScanConfig;
+    sitemap?: ScanConfig;
+    report?: {
+        reporter?: ReporterConfig;
+        input?: string;
+        output?: string;
+        dataUrl?: string;
+        verify?: ReportVerificationOptions;
+    };
+    notify?: NotificationConfig;
+}
+/** Lightweight configuration entry; importing it does not load browser or mail clients. */
+declare function defineConfig<const T extends MeodpConfig>(config: T): T;
+
+export { type MeodpConfig, type NotificationConfig, type ScanConfig, defineConfig };

package/dist/config/index.mjs

@@ -0,0 +1,5 @@
+function defineConfig(config) {
+  return config;
+}
+
+export { defineConfig };

package/dist/notify/cli.cjs

@@ -0,0 +1,107 @@
+'use strict';
+
+const process = require('node:process');
+const node_util = require('node:util');
+const report = require('../shared/meodp.2b00b0ae.cjs');
+const load = require('../shared/meodp.63483e20.cjs');
+const notify_feishu = require('./feishu.cjs');
+const notify_index = require('./index.cjs');
+require('node:crypto');
+require('node:fs/promises');
+require('node:path');
+require('c12');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const process__default = /*#__PURE__*/_interopDefaultCompat(process);
+
+async function runNotifyCli(args = process__default.argv.slice(3)) {
+  try {
+    const { values } = node_util.parseArgs({ args, options: {
+      "config": { type: "string" },
+      "channel": { type: "string" },
+      "mode": { type: "string" },
+      "dry-run": { type: "boolean" },
+      "test": { type: "boolean" },
+      "help": { type: "boolean", short: "h" }
+    } });
+    if (values.help) {
+      console.log(`Usage: meodp notify [--channel feishu|email] [--mode off|changes|weekly] [--dry-run] [--test]
+
+Read saved reports and send configured notifications. No link scans run.
+--config <file> loads meodp.config.ts by default.
+--dry-run renders content without credentials or delivery; disabled channels stay disabled.
+--test explicitly sends a test using an optional saved snapshot, even if its mode is off.
+Exit codes: 0 = sent, previewed or skipped; 2 = configuration or delivery error.`);
+      return 0;
+    }
+    if (values.channel && !["feishu", "email"].includes(values.channel))
+      throw new Error("--channel must be feishu or email.");
+    const project = await load.loadProjectConfig(values.config);
+    const config = project.config.notify;
+    if (!config)
+      throw new Error("Configure notify in meodp.config.ts before sending notifications.");
+    const channels = values.channel ? [values.channel] : ["feishu", "email"].filter((name) => name in config);
+    if (values.test && channels.length > 1)
+      throw new Error("Choose --channel when testing a config with multiple notification channels.");
+    if (!channels.length)
+      throw new Error("Configure at least one notification channel.");
+    for (const channel of channels) {
+      const delivery = channel === "feishu" ? config.feishu : config.email;
+      if (!delivery)
+        throw new Error(`Configure notify.${channel} before using this channel.`);
+      const mode = values.mode ?? delivery.mode ?? "off";
+      if (!["off", "changes", "weekly"].includes(mode))
+        throw new Error("Notification mode must be off, changes, or weekly.");
+      if (mode === "off" && !values.test) {
+        console.log(`${channel}: notifications disabled.`);
+        continue;
+      }
+      const report$1 = await report.readReport(project.path(config.input));
+      const previous = config.previousReport ? await report.readReport(project.path(config.previousReport)) : void 0;
+      const options = { ...config, previousReport: previous, mode };
+      let message;
+      if (values.test) {
+        const snapshot = report$1 ?? previous;
+        message = {
+          ...snapshot ? notify_index.createNotification(snapshot, { ...options, previousReport: void 0, mode: "weekly" }) : {},
+          subject: `[${config.title || "MEODP"}] \u901A\u77E5\u94FE\u8DEF\u9A8C\u8BC1`,
+          test: true,
+          text: `\u8FD9\u662F\u4E00\u6761\u901A\u77E5\u5361\u7247\u6D4B\u8BD5\u3002
+\u53D1\u9001\u65F6\u95F4\uFF1A${( new Date()).toISOString()}
+\u4E0B\u65B9\u5982\u6709\u6570\u636E\uFF0C\u4F7F\u7528\u7684\u662F\u5DF2\u4FDD\u5B58\u7684\u5386\u53F2\u5FEB\u7167\uFF0C\u4E0D\u4EE3\u8868\u65B0\u68C0\u6D4B\u7ED3\u679C\u6216\u516C\u5F00\u62A5\u544A\u5DF2\u66F4\u65B0\u3002`
+        };
+      } else {
+        if (!report$1)
+          throw new Error("Missing completed report; run meodp check first.");
+        message = notify_index.createNotification(report$1, options);
+      }
+      if (!message) {
+        console.log(`${channel}: no important changes; notification skipped.`);
+        continue;
+      }
+      if (channel === "feishu") {
+        const feishu = { reportUrl: config.reportUrl, runUrl: config.runUrl, timeZone: config.timeZone, maxItems: config.maxItems, ...config.feishu };
+        if (values["dry-run"])
+          console.log(JSON.stringify(notify_feishu.createFeishuCard(message, feishu), null, 2));
+        else
+          await notify_feishu.sendFeishuNotification(message, feishu);
+      } else if (values["dry-run"]) {
+        console.log(`${message.subject}
+
+${message.text}`);
+      } else {
+        const { sendEmailNotification } = await import('./email.cjs');
+        await sendEmailNotification(message, config.email);
+      }
+      if (!values["dry-run"])
+        console.log(`${channel}: notification accepted.`);
+    }
+    return 0;
+  } catch (error) {
+    console.error(`meodp notify: ${error instanceof Error ? error.message : String(error)}`);
+    return 2;
+  }
+}
+
+exports.runNotifyCli = runNotifyCli;

package/dist/notify/cli.d.cts

@@ -0,0 +1,3 @@
+declare function runNotifyCli(args?: string[]): Promise<number>;
+
+export { runNotifyCli };

package/dist/notify/cli.d.mts

@@ -0,0 +1,3 @@
+declare function runNotifyCli(args?: string[]): Promise<number>;
+
+export { runNotifyCli };

package/dist/notify/cli.d.ts

@@ -0,0 +1,3 @@
+declare function runNotifyCli(args?: string[]): Promise<number>;
+
+export { runNotifyCli };

package/dist/notify/cli.mjs

@@ -0,0 +1,101 @@
+import process from 'node:process';
+import { parseArgs } from 'node:util';
+import { r as readReport } from '../shared/meodp.9c706389.mjs';
+import { l as loadProjectConfig } from '../shared/meodp.f96d0510.mjs';
+import { createFeishuCard, sendFeishuNotification } from './feishu.mjs';
+import { createNotification } from './index.mjs';
+import 'node:crypto';
+import 'node:fs/promises';
+import 'node:path';
+import 'c12';
+
+async function runNotifyCli(args = process.argv.slice(3)) {
+  try {
+    const { values } = parseArgs({ args, options: {
+      "config": { type: "string" },
+      "channel": { type: "string" },
+      "mode": { type: "string" },
+      "dry-run": { type: "boolean" },
+      "test": { type: "boolean" },
+      "help": { type: "boolean", short: "h" }
+    } });
+    if (values.help) {
+      console.log(`Usage: meodp notify [--channel feishu|email] [--mode off|changes|weekly] [--dry-run] [--test]
+
+Read saved reports and send configured notifications. No link scans run.
+--config <file> loads meodp.config.ts by default.
+--dry-run renders content without credentials or delivery; disabled channels stay disabled.
+--test explicitly sends a test using an optional saved snapshot, even if its mode is off.
+Exit codes: 0 = sent, previewed or skipped; 2 = configuration or delivery error.`);
+      return 0;
+    }
+    if (values.channel && !["feishu", "email"].includes(values.channel))
+      throw new Error("--channel must be feishu or email.");
+    const project = await loadProjectConfig(values.config);
+    const config = project.config.notify;
+    if (!config)
+      throw new Error("Configure notify in meodp.config.ts before sending notifications.");
+    const channels = values.channel ? [values.channel] : ["feishu", "email"].filter((name) => name in config);
+    if (values.test && channels.length > 1)
+      throw new Error("Choose --channel when testing a config with multiple notification channels.");
+    if (!channels.length)
+      throw new Error("Configure at least one notification channel.");
+    for (const channel of channels) {
+      const delivery = channel === "feishu" ? config.feishu : config.email;
+      if (!delivery)
+        throw new Error(`Configure notify.${channel} before using this channel.`);
+      const mode = values.mode ?? delivery.mode ?? "off";
+      if (!["off", "changes", "weekly"].includes(mode))
+        throw new Error("Notification mode must be off, changes, or weekly.");
+      if (mode === "off" && !values.test) {
+        console.log(`${channel}: notifications disabled.`);
+        continue;
+      }
+      const report = await readReport(project.path(config.input));
+      const previous = config.previousReport ? await readReport(project.path(config.previousReport)) : void 0;
+      const options = { ...config, previousReport: previous, mode };
+      let message;
+      if (values.test) {
+        const snapshot = report ?? previous;
+        message = {
+          ...snapshot ? createNotification(snapshot, { ...options, previousReport: void 0, mode: "weekly" }) : {},
+          subject: `[${config.title || "MEODP"}] \u901A\u77E5\u94FE\u8DEF\u9A8C\u8BC1`,
+          test: true,
+          text: `\u8FD9\u662F\u4E00\u6761\u901A\u77E5\u5361\u7247\u6D4B\u8BD5\u3002
+\u53D1\u9001\u65F6\u95F4\uFF1A${( new Date()).toISOString()}
+\u4E0B\u65B9\u5982\u6709\u6570\u636E\uFF0C\u4F7F\u7528\u7684\u662F\u5DF2\u4FDD\u5B58\u7684\u5386\u53F2\u5FEB\u7167\uFF0C\u4E0D\u4EE3\u8868\u65B0\u68C0\u6D4B\u7ED3\u679C\u6216\u516C\u5F00\u62A5\u544A\u5DF2\u66F4\u65B0\u3002`
+        };
+      } else {
+        if (!report)
+          throw new Error("Missing completed report; run meodp check first.");
+        message = createNotification(report, options);
+      }
+      if (!message) {
+        console.log(`${channel}: no important changes; notification skipped.`);
+        continue;
+      }
+      if (channel === "feishu") {
+        const feishu = { reportUrl: config.reportUrl, runUrl: config.runUrl, timeZone: config.timeZone, maxItems: config.maxItems, ...config.feishu };
+        if (values["dry-run"])
+          console.log(JSON.stringify(createFeishuCard(message, feishu), null, 2));
+        else
+          await sendFeishuNotification(message, feishu);
+      } else if (values["dry-run"]) {
+        console.log(`${message.subject}
+
+${message.text}`);
+      } else {
+        const { sendEmailNotification } = await import('./email.mjs');
+        await sendEmailNotification(message, config.email);
+      }
+      if (!values["dry-run"])
+        console.log(`${channel}: notification accepted.`);
+    }
+    return 0;
+  } catch (error) {
+    console.error(`meodp notify: ${error instanceof Error ? error.message : String(error)}`);
+    return 2;
+  }
+}
+
+export { runNotifyCli };

package/dist/notify/email.cjs

@@ -0,0 +1,38 @@
+'use strict';
+
+function smtpOptions(options) {
+  for (const key of ["host", "user", "password", "from", "to"]) {
+    if (!options[key]?.trim())
+      throw new Error(`Missing email.${key}; configure SMTP before enabling email.`);
+  }
+  const port = options.port ?? 465;
+  if (![465, 587].includes(port))
+    throw new Error("Email port must be 465 (TLS) or 587 (STARTTLS).");
+  return {
+    host: options.host,
+    port,
+    secure: port === 465,
+    requireTLS: true,
+    auth: { user: options.user, pass: options.password },
+    connectionTimeout: 15e3,
+    greetingTimeout: 15e3,
+    socketTimeout: 3e4,
+    disableFileAccess: true,
+    disableUrlAccess: true
+  };
+}
+async function sendEmailNotification(message, options) {
+  const connection = smtpOptions(options);
+  const { default: nodemailer } = await import('nodemailer');
+  const transport = nodemailer.createTransport(connection);
+  try {
+    const result = await transport.sendMail({ subject: message.subject, text: message.text, from: options.from, to: options.to });
+    if (result.rejected.length)
+      throw new Error("SMTP rejected one or more recipients.");
+  } finally {
+    transport.close();
+  }
+}
+
+exports.sendEmailNotification = sendEmailNotification;
+exports.smtpOptions = smtpOptions;

package/dist/notify/email.d.cts

@@ -0,0 +1,29 @@
+import { LinkNotification } from './index.cjs';
+import '../shared/meodp.93e06e00.cjs';
+
+interface EmailOptions {
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string;
+    from?: string;
+    to?: string;
+}
+declare function smtpOptions(options: EmailOptions): {
+    host: string | undefined;
+    port: number;
+    secure: boolean;
+    requireTLS: boolean;
+    auth: {
+        user: string | undefined;
+        pass: string | undefined;
+    };
+    connectionTimeout: number;
+    greetingTimeout: number;
+    socketTimeout: number;
+    disableFileAccess: boolean;
+    disableUrlAccess: boolean;
+};
+declare function sendEmailNotification(message: LinkNotification, options: EmailOptions): Promise<void>;
+
+export { type EmailOptions, sendEmailNotification, smtpOptions };

package/dist/notify/email.d.mts

@@ -0,0 +1,29 @@
+import { LinkNotification } from './index.mjs';
+import '../shared/meodp.93e06e00.mjs';
+
+interface EmailOptions {
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string;
+    from?: string;
+    to?: string;
+}
+declare function smtpOptions(options: EmailOptions): {
+    host: string | undefined;
+    port: number;
+    secure: boolean;
+    requireTLS: boolean;
+    auth: {
+        user: string | undefined;
+        pass: string | undefined;
+    };
+    connectionTimeout: number;
+    greetingTimeout: number;
+    socketTimeout: number;
+    disableFileAccess: boolean;
+    disableUrlAccess: boolean;
+};
+declare function sendEmailNotification(message: LinkNotification, options: EmailOptions): Promise<void>;
+
+export { type EmailOptions, sendEmailNotification, smtpOptions };

package/dist/notify/email.d.ts

@@ -0,0 +1,29 @@
+import { LinkNotification } from './index.js';
+import '../shared/meodp.93e06e00.js';
+
+interface EmailOptions {
+    host?: string;
+    port?: number;
+    user?: string;
+    password?: string;
+    from?: string;
+    to?: string;
+}
+declare function smtpOptions(options: EmailOptions): {
+    host: string | undefined;
+    port: number;
+    secure: boolean;
+    requireTLS: boolean;
+    auth: {
+        user: string | undefined;
+        pass: string | undefined;
+    };
+    connectionTimeout: number;
+    greetingTimeout: number;
+    socketTimeout: number;
+    disableFileAccess: boolean;
+    disableUrlAccess: boolean;
+};
+declare function sendEmailNotification(message: LinkNotification, options: EmailOptions): Promise<void>;
+
+export { type EmailOptions, sendEmailNotification, smtpOptions };

package/dist/notify/email.mjs

@@ -0,0 +1,35 @@
+function smtpOptions(options) {
+  for (const key of ["host", "user", "password", "from", "to"]) {
+    if (!options[key]?.trim())
+      throw new Error(`Missing email.${key}; configure SMTP before enabling email.`);
+  }
+  const port = options.port ?? 465;
+  if (![465, 587].includes(port))
+    throw new Error("Email port must be 465 (TLS) or 587 (STARTTLS).");
+  return {
+    host: options.host,
+    port,
+    secure: port === 465,
+    requireTLS: true,
+    auth: { user: options.user, pass: options.password },
+    connectionTimeout: 15e3,
+    greetingTimeout: 15e3,
+    socketTimeout: 3e4,
+    disableFileAccess: true,
+    disableUrlAccess: true
+  };
+}
+async function sendEmailNotification(message, options) {
+  const connection = smtpOptions(options);
+  const { default: nodemailer } = await import('nodemailer');
+  const transport = nodemailer.createTransport(connection);
+  try {
+    const result = await transport.sendMail({ subject: message.subject, text: message.text, from: options.from, to: options.to });
+    if (result.rejected.length)
+      throw new Error("SMTP rejected one or more recipients.");
+  } finally {
+    transport.close();
+  }
+}
+
+export { sendEmailNotification, smtpOptions };

package/dist/notify/feishu.cjs

@@ -0,0 +1,162 @@
+'use strict';
+
+const node_crypto = require('node:crypto');
+
+function truncate(text, limit) {
+  const characters = Array.from(String(text));
+  return characters.length > limit ? `${characters.slice(0, limit).join("")}
+\u2026\u5B8C\u6574\u5185\u5BB9\u8BF7\u67E5\u770B\u62A5\u544A\u3002` : characters.join("");
+}
+function safeLink(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new Error("Notification links must use HTTP(S) without credentials.");
+  }
+  if (!["http:", "https:"].includes(parsed.protocol) || parsed.username || parsed.password)
+    throw new Error("Notification links must use HTTP(S) without credentials.");
+  return parsed.href;
+}
+function signFeishu(timestamp, secret) {
+  return node_crypto.createHmac("sha256", `${timestamp}
+${secret}`).digest("base64");
+}
+function createFeishuCard(message, { keyword = "", reportUrl, runUrl, reportLabel = "\u67E5\u770B\u5B8C\u6574\u62A5\u544A", timeZone = "UTC", maxItems = 6 } = {}) {
+  if (!Number.isSafeInteger(maxItems) || maxItems < 1 || maxItems > 6)
+    throw new Error("maxItems must be between 1 and 6.");
+  const text = (content) => ({ tag: "plain_text", content });
+  const elements = [];
+  if (message.test)
+    elements.push({ tag: "div", text: text(message.text) });
+  if (message.report) {
+    const { total, reachable, restricted, unavailable } = message.report.summary;
+    elements.push({
+      tag: "div",
+      fields: [["\u{1F310} \u68C0\u6D4B\u7AD9\u70B9", total], ["\u2705 \u53EF\u8BBF\u95EE", reachable], ["\u{1F7E0} \u8BBF\u95EE\u53D7\u9650", restricted], ["\u{1F534} \u672C\u6B21\u4E0D\u53EF\u8BBF\u95EE", unavailable]].map(([label, value]) => ({ is_short: true, text: text(`${label}
+${value}`) }))
+    });
+    const date = new Date(message.report.completedAt);
+    const time = Number.isNaN(date.valueOf()) ? message.report.completedAt : new Intl.DateTimeFormat("zh-CN", {
+      timeZone,
+      dateStyle: "medium",
+      timeStyle: "short",
+      hour12: false
+    }).format(date);
+    elements.push({ tag: "note", elements: [text(`${message.test ? "\u793A\u4F8B\u5FEB\u7167" : "\u68C0\u6D4B\u5B8C\u6210"}\uFF1A${time}\uFF08${timeZone}\uFF09
+\u68C0\u6D4B\u73AF\u5883\uFF1A${truncate(message.report.observer, 80)}`)] });
+    if (message.entries?.length) {
+      elements.push({ tag: "hr" }, { tag: "markdown", content: "**\u72B6\u6001\u6458\u8981**" });
+      for (const { item, reason } of message.entries.slice(0, maxItems)) {
+        elements.push({ tag: "div", text: text(`${reason} \xB7 ${truncate(item.name || item.url, 60)}
+${truncate(item.url, 160)}
+HTTP / \u539F\u56E0\uFF1A${truncate(item.httpStatus ?? item.reason ?? "\u2014", 80)} \xB7 \u8FDE\u7EED\u5931\u8D25 ${item.consecutiveFailures} \u6B21`) });
+      }
+      if (message.entries.length > maxItems)
+        elements.push({ tag: "note", elements: [text(`\u53E6\u6709 ${message.entries.length - maxItems} \u9879\uFF0C\u70B9\u51FB\u4E0B\u65B9\u67E5\u770B\u5B8C\u6574\u62A5\u544A\u3002`)] });
+    } else {
+      elements.push({ tag: "div", text: text("\u672C\u6B21\u6CA1\u6709\u9700\u8981\u5173\u6CE8\u7684\u72B6\u6001\u53D8\u5316\u3002") });
+    }
+  } else if (!message.test) {
+    elements.push({ tag: "div", text: text(truncate(message.text, 2500)) });
+  }
+  const actions = [];
+  for (const [label, url] of [[reportLabel, reportUrl], ["\u67E5\u770B\u672C\u6B21\u8FD0\u884C", runUrl]]) {
+    if (url)
+      actions.push({ tag: "button", text: text(label), type: actions.length ? "default" : "primary", url: safeLink(url) });
+  }
+  if (actions.length)
+    elements.push({ tag: "action", actions });
+  elements.push({ tag: "note", elements: [text("\u8BBF\u95EE\u53D7\u9650\u4E0D\u7B49\u4E8E\u5931\u6548\uFF1B\u8FDE\u7EED\u5931\u8D25\u6B21\u6570\u4E0D\u4EE3\u8868\u671F\u95F4\u6301\u7EED\u5B95\u673A\u3002")] });
+  const template = message.test ? "blue" : message.report?.summary?.unavailable ? "orange" : message.report?.summary?.restricted ? "yellow" : "green";
+  return {
+    config: { wide_screen_mode: true, enable_forward: false },
+    header: { template, title: text(`${keyword ? `${truncate(keyword, 64)} \xB7 ` : ""}${truncate(message.subject, 100)}`) },
+    elements
+  };
+}
+function createFeishuPayload(message, options = {}) {
+  const payload = { msg_type: "interactive", card: createFeishuCard(message, options) };
+  if (options.secret) {
+    payload.timestamp = String(options.timestamp ?? Math.floor(Date.now() / 1e3));
+    payload.sign = signFeishu(payload.timestamp, options.secret);
+  }
+  return payload;
+}
+async function requestFeishu(url, init, fetcher, phase) {
+  let response;
+  try {
+    response = await fetcher(url, { ...init, redirect: "error", signal: AbortSignal.timeout(15e3) });
+  } catch {
+    throw new Error(`Feishu ${phase} request failed or timed out; check delivery before retrying.`);
+  }
+  if (!response.ok)
+    throw new Error(`Feishu ${phase} returned HTTP ${response.status}.`);
+  let result;
+  try {
+    result = await response.json();
+  } catch {
+    throw new Error(`Feishu ${phase} returned an invalid response; check delivery before retrying.`);
+  }
+  if (!result || typeof result !== "object")
+    throw new Error(`Feishu ${phase} returned an invalid response; check delivery before retrying.`);
+  const code = ("code" in result ? result.code : void 0) ?? ("StatusCode" in result ? result.StatusCode : void 0);
+  if (code !== 0)
+    throw new Error(`Feishu ${phase} rejected the request (code ${Number.isInteger(code) ? code : "unknown"}). Check the bot configuration and permissions.`);
+  return result;
+}
+async function sendFeishuNotification(message, options, fetcher = fetch) {
+  const transport = options.transport || "webhook";
+  if (!["app", "webhook"].includes(transport))
+    throw new Error("feishu.transport must be app or webhook.");
+  if (transport === "app") {
+    for (const [name, value] of [["feishu.appId", options.appId], ["feishu.appSecret", options.appSecret], ["feishu.receiveId", options.receiveId]]) {
+      if (!value?.trim())
+        throw new Error(`Configure ${name} in the notification configuration.`);
+    }
+    const receiveIdType = options.receiveIdType || "open_id";
+    if (!["open_id", "user_id", "union_id", "email"].includes(receiveIdType))
+      throw new Error("feishu.receiveIdType must be open_id, user_id, union_id, or email for direct messages.");
+    const card = createFeishuCard(message, options);
+    const auth = await requestFeishu("https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ app_id: options.appId, app_secret: options.appSecret })
+    }, fetcher, "authentication");
+    if (!("tenant_access_token" in auth) || typeof auth.tenant_access_token !== "string" || !auth.tenant_access_token)
+      throw new Error("Feishu authentication returned no tenant access token.");
+    const content = JSON.stringify(card);
+    const uuid = node_crypto.createHash("sha256").update(`${options.appId}
+${receiveIdType}
+${options.receiveId}
+${content}`).digest("hex").slice(0, 40);
+    const result = await requestFeishu(`https://open.feishu.cn/open-apis/im/v1/messages?receive_id_type=${receiveIdType}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "Authorization": `Bearer ${auth.tenant_access_token}` },
+      body: JSON.stringify({ receive_id: options.receiveId, msg_type: "interactive", content, uuid })
+    }, fetcher, "direct message");
+    if (!("data" in result) || !result.data || typeof result.data !== "object" || !("message_id" in result.data) || typeof result.data.message_id !== "string" || !result.data.message_id) {
+      throw new Error("Feishu returned no message ID; check delivery before retrying.");
+    }
+    return { messageId: result.data.message_id };
+  }
+  let webhook;
+  try {
+    webhook = new URL(options.webhook || "");
+  } catch {
+    throw new Error("Configure feishu.webhook in the notification configuration.");
+  }
+  if (webhook.protocol !== "https:" || !["open.feishu.cn", "open.larksuite.com"].includes(webhook.hostname) || !/^\/open-apis\/bot\/v2\/hook\/[a-z0-9-]+$/i.test(webhook.pathname) || webhook.username || webhook.password || webhook.search || webhook.hash || webhook.port) {
+    throw new Error("feishu.webhook must be an official Feishu/Lark custom bot webhook.");
+  }
+  await requestFeishu(webhook.href, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(createFeishuPayload(message, options))
+  }, fetcher, "webhook");
+}
+
+exports.createFeishuCard = createFeishuCard;
+exports.createFeishuPayload = createFeishuPayload;
+exports.sendFeishuNotification = sendFeishuNotification;
+exports.signFeishu = signFeishu;