koishi-plugin-bilibili-notify-dynamic 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+## [0.0.1] - 2026-04-04
+
+### Added
+
+- 首次作为独立插件发布（原属核心包）
+- 通过 cron 定时轮询 UP 主最新动态（默认每 2 分钟）
+- 支持图文、视频、专栏、转发等各类动态类型
+- 动态屏蔽过滤（关键词、正则、白名单）
+- 视频动态支持附带 BV 号链接
+- 可选接入 `bilibili-notify-image` 生成动态卡片图片

package/README.md

@@ -0,0 +1,24 @@
+# koishi-plugin-bilibili-notify-dynamic
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-bilibili-notify-dynamic?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-bilibili-notify-dynamic)
+
+`koishi-plugin-bilibili-notify` 的动态推送插件，通过定时轮询获取 B 站 UP 主最新动态。
+
+> [!NOTE]
+> 需要先安装并配置 `koishi-plugin-bilibili-notify` 核心插件
+
+## 功能
+
+- 定时轮询 UP 主动态（cron 表达式可配置，默认每 2 分钟）
+- 支持推送图文、视频、专栏、转发等各类动态
+- 可配置动态屏蔽规则（关键词、正则、白名单）
+- 可选生成动态卡片图片（需安装 `koishi-plugin-bilibili-notify-image`）
+- 视频动态支持附带 BV 号链接
+
+## 安装
+
+在 Koishi 插件市场中搜索 `bilibili-notify-dynamic` 并安装。
+
+## License
+
+MIT

package/lib/index.cjs

@@ -0,0 +1,292 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let koishi = require("koishi");
+let _bilibili_notify_internal = require("@bilibili-notify/internal");
+let _bilibili_notify_push = require("@bilibili-notify/push");
+let cron = require("cron");
+require("koishi-plugin-bilibili-notify");
+let luxon = require("luxon");
+//#region src/config.ts
+const BilibiliNotifyDynamicSchema = koishi.Schema.object({
+	logLevel: koishi.Schema.number().min(1).max(3).step(1).default(1).description("这里可以设置日志等级喔～3 是最详细的调试信息，1 是只显示错误信息。主人可以根据需要选择合适的等级，让女仆更好地为您服务 (๑•̀ㅂ•́)و✧"),
+	dynamicUrl: koishi.Schema.boolean().default(false).description("发送动态时要不要顺便发链接呢？但如果主人用的是 QQ 官方机器人，这个开关不要开喔～不然会出事的 (；>_<)！"),
+	dynamicCron: koishi.Schema.string().default("*/2 * * * *").description("主人想多久检查一次动态呢？这里填写 cron 表达式～太短太频繁会吓到女仆的，请温柔一点 (〃ﾉωﾉ)"),
+	dynamicVideoUrlToBV: koishi.Schema.boolean().default(false).description("如果是视频动态，开启后会把链接换成 BV 号哦～方便主人的其他用途 (*´･ω･`)"),
+	pushImgsInDynamic: koishi.Schema.boolean().default(false).description("要不要把动态里的图片也一起推送呢？但、但是可能会触发 QQ 的风控，女仆会有点害怕 (；>_<) 请主人小心决定…"),
+	filter: koishi.Schema.intersect([koishi.Schema.object({ enable: koishi.Schema.boolean().default(false).description("要开启吗？") }).description("这里是动态屏蔽设置～如果有不想看到的内容，女仆可以帮主人过滤掉 (＞﹏＜)！"), koishi.Schema.union([koishi.Schema.object({
+		enable: koishi.Schema.const(true).required(),
+		notify: koishi.Schema.boolean().default(false).description("当动态被屏蔽时，要不要让女仆通知主人呢？"),
+		regex: koishi.Schema.string().description("这里可以填写正则表达式，用来屏蔽特定动态～女仆会努力匹配的！"),
+		keywords: koishi.Schema.array(String).description("这里填写关键字，每一个都是单独的一项～有这些词的动态女仆都会贴心地拦下来 (*´∀`)"),
+		forward: koishi.Schema.boolean().default(false).description("要不要屏蔽转发动态呢？主人说了算！"),
+		article: koishi.Schema.boolean().default(false).description("是否屏蔽专栏动态～女仆会按照主人的喜好来处理 (๑•̀ㅂ•́)و✧"),
+		whitelistEnable: koishi.Schema.boolean().default(false).description("是否启用白名单过滤（仅推送匹配白名单规则的动态）"),
+		whitelistRegex: koishi.Schema.string().description("白名单正则表达式，命中时允许推送该动态"),
+		whitelistKeywords: koishi.Schema.array(String).description("白名单关键词，命中任意关键词时允许推送该动态")
+	}), koishi.Schema.object({})])])
+});
+//#endregion
+//#region src/types.ts
+let DynamicFilterReason = /* @__PURE__ */ function(DynamicFilterReason) {
+	DynamicFilterReason["BlacklistKeyword"] = "blacklist-keyword";
+	DynamicFilterReason["BlacklistForward"] = "blacklist-forward";
+	DynamicFilterReason["BlacklistArticle"] = "blacklist-article";
+	DynamicFilterReason["WhitelistUnmatched"] = "whitelist-unmatched";
+	return DynamicFilterReason;
+}({});
+//#endregion
+//#region src/dynamic-filter.ts
+function collectRichText(dynamic, texts) {
+	const richTextNodes = dynamic.modules?.module_dynamic?.desc?.rich_text_nodes;
+	if (richTextNodes?.length) texts.push(richTextNodes.map((n) => n.text ?? "").join(""));
+	const summaryNodes = dynamic.modules?.module_dynamic?.major?.opus?.summary?.rich_text_nodes;
+	if (summaryNodes?.length) texts.push(summaryNodes.map((n) => n.text ?? "").join(""));
+	const title = dynamic.modules?.module_dynamic?.major?.opus?.title;
+	if (title) texts.push(title);
+	const archiveTitle = dynamic.modules?.module_dynamic?.major?.archive?.title;
+	if (archiveTitle) texts.push(archiveTitle);
+}
+function getDynamicText(dynamic) {
+	const texts = [];
+	collectRichText(dynamic, texts);
+	if (dynamic.orig) collectRichText(dynamic.orig, texts);
+	return texts.join("\n");
+}
+function safeRegexTest(pattern, text) {
+	if (!pattern) return false;
+	try {
+		return new RegExp(pattern).test(text);
+	} catch (e) {
+		console.warn(`[bilibili-notify-dynamic] 无效的正则表达式 "${pattern}": ${e.message}`);
+		return false;
+	}
+}
+function testKeywordMatched(text, keywords) {
+	if (!keywords?.length) return false;
+	return keywords.some((kw) => kw && text.includes(kw));
+}
+function filterDynamic(dynamic, config) {
+	const cfg = {
+		enable: false,
+		regex: "",
+		keywords: [],
+		forward: false,
+		article: false,
+		whitelistEnable: false,
+		whitelistRegex: "",
+		whitelistKeywords: [],
+		...config
+	};
+	const text = getDynamicText(dynamic);
+	if (cfg.enable) {
+		if (cfg.forward && dynamic.type === "DYNAMIC_TYPE_FORWARD") return {
+			blocked: true,
+			reason: DynamicFilterReason.BlacklistForward
+		};
+		if (cfg.article && dynamic.type === "DYNAMIC_TYPE_ARTICLE") return {
+			blocked: true,
+			reason: DynamicFilterReason.BlacklistArticle
+		};
+		if (safeRegexTest(cfg.regex, text) || testKeywordMatched(text, cfg.keywords)) return {
+			blocked: true,
+			reason: DynamicFilterReason.BlacklistKeyword
+		};
+	}
+	if (cfg.whitelistEnable) {
+		if ((!!cfg.whitelistRegex || cfg.whitelistKeywords.length > 0) && !safeRegexTest(cfg.whitelistRegex, text) && !testKeywordMatched(text, cfg.whitelistKeywords)) return {
+			blocked: true,
+			reason: DynamicFilterReason.WhitelistUnmatched
+		};
+	}
+	return { blocked: false };
+}
+//#endregion
+//#region src/dynamic-service.ts
+const SERVICE_NAME = "bilibili-notify-dynamic";
+/** Simple async lock: if the previous run is still executing, skip. */
+function withLock(fn) {
+	let locked = false;
+	return () => {
+		if (locked) return;
+		locked = true;
+		fn().catch((err) => {
+			console.error("[bilibili-notify-dynamic] Execution error:", err);
+		}).finally(() => {
+			locked = false;
+		});
+	};
+}
+var BilibiliNotifyDynamic = class extends koishi.Service {
+	static [koishi.Service.provide] = SERVICE_NAME;
+	dynamicLogger;
+	api;
+	push;
+	dynamicJob;
+	dynamicSubManager = /* @__PURE__ */ new Map();
+	dynamicTimelineManager = /* @__PURE__ */ new Map();
+	constructor(ctx, config) {
+		super(ctx, SERVICE_NAME);
+		this.config = config;
+		this.dynamicLogger = new koishi.Logger(SERVICE_NAME);
+		this.dynamicLogger.level = config.logLevel;
+	}
+	start() {
+		const internals = this.ctx["bilibili-notify"].getInternals(_bilibili_notify_internal.BILIBILI_NOTIFY_TOKEN);
+		if (!internals) throw new Error("无法获取 bilibili-notify 内部实例，请确认核心插件已启动");
+		this.api = internals.api;
+		this.push = internals.push;
+		this.dynamicTimelineManager = /* @__PURE__ */ new Map();
+		if (internals.subs) this.startDynamicDetector(internals.subs);
+		this.ctx.on("bilibili-notify/subscription-changed", (subs) => {
+			this.startDynamicDetector(subs);
+		});
+	}
+	stop() {
+		if (this.dynamicJob) {
+			this.dynamicJob.stop();
+			this.dynamicLogger.info("动态检测任务已停止");
+		}
+	}
+	get isActive() {
+		return this.dynamicJob?.running ?? false;
+	}
+	startDynamicDetector(subs) {
+		if (this.dynamicJob) {
+			this.dynamicJob.stop();
+			this.dynamicJob = void 0;
+		}
+		const dynamicSubManager = /* @__PURE__ */ new Map();
+		for (const sub of Object.values(subs)) if (sub.dynamic) {
+			if (!this.dynamicTimelineManager.has(sub.uid)) this.dynamicTimelineManager.set(sub.uid, Math.floor(luxon.DateTime.now().toSeconds()));
+			dynamicSubManager.set(sub.uid, sub);
+		}
+		for (const uid of this.dynamicTimelineManager.keys()) if (!dynamicSubManager.has(uid)) this.dynamicTimelineManager.delete(uid);
+		if (dynamicSubManager.size === 0) {
+			this.dynamicLogger.info("没有需要动态检测的订阅对象");
+			return;
+		}
+		this.dynamicSubManager = dynamicSubManager;
+		this.dynamicJob = new cron.CronJob(this.config.dynamicCron, withLock(() => this.detectDynamics()));
+		this.dynamicJob.start();
+		this.dynamicLogger.info("动态检测任务已启动");
+	}
+	async detectDynamics() {
+		this.dynamicLogger.debug("开始获取动态信息");
+		let content;
+		try {
+			content = await this.api.getAllDynamic();
+		} catch (e) {
+			this.dynamicLogger.error(`获取动态失败：${e}`);
+			return;
+		}
+		if (!content) return;
+		if (content.code !== 0) {
+			await this.handleApiError(content.code, content.message);
+			return;
+		}
+		this.dynamicLogger.debug("成功获取动态信息，开始处理");
+		const currentPushDyn = {};
+		for (const item of content.data.items) {
+			if (!item) continue;
+			const postTime = item.modules.module_author.pub_ts;
+			if (typeof postTime !== "number" || !Number.isFinite(postTime)) {
+				this.dynamicLogger.warn(`跳过无效动态：pub_ts 缺失或非数字，ID=${item.id_str ?? "unknown"}`);
+				continue;
+			}
+			const uid = item.modules.module_author.mid.toString();
+			const name = item.modules.module_author.name;
+			const timeline = this.dynamicTimelineManager.get(uid);
+			if (timeline === void 0) continue;
+			this.dynamicLogger.debug(`检查动态 UP=${name} UID=${uid} 发布时间=${luxon.DateTime.fromSeconds(postTime).toFormat("yyyy-MM-dd HH:mm:ss")}`);
+			if (timeline >= postTime) continue;
+			const filterResult = filterDynamic(item, this.config.filter ?? {});
+			if (filterResult.blocked) {
+				if (this.config.filter?.notify) {
+					const msgs = {
+						[DynamicFilterReason.BlacklistKeyword]: `${name}发布了一条含有屏蔽关键字的动态`,
+						[DynamicFilterReason.BlacklistForward]: `${name}转发了一条动态，已屏蔽`,
+						[DynamicFilterReason.BlacklistArticle]: `${name}投稿了一条专栏，已屏蔽`,
+						[DynamicFilterReason.WhitelistUnmatched]: `${name}发布了一条不在白名单范围内的动态，已屏蔽`
+					};
+					await this.push.broadcastToTargets(uid, (0, koishi.h)("message", msgs[filterResult.reason]), _bilibili_notify_push.PushType.Dynamic);
+				}
+				continue;
+			}
+			const sub = this.dynamicSubManager.get(uid);
+			const imageService = this.ctx["bilibili-notify-image"];
+			let buffer;
+			try {
+				if (imageService?.generateDynamicCard) buffer = await imageService.generateDynamicCard(item, sub?.customCardStyle?.enable ? sub.customCardStyle : void 0);
+			} catch (e) {
+				const err = e;
+				if (err.message === "直播开播动态，不做处理") continue;
+				this.dynamicLogger.error(`生成动态图片失败：${err.message}，动态检测已停止`);
+				await this.push.sendErrorMsg(`生成动态图片失败：${err.message}，动态检测已停止`);
+				this.dynamicJob?.stop();
+				this.dynamicJob = void 0;
+				this.ctx.emit("bilibili-notify/plugin-error", SERVICE_NAME, `生成动态图片失败：${err.message}`);
+				return;
+			}
+			let dUrl = "";
+			if (this.config.dynamicUrl) if (item.type === "DYNAMIC_TYPE_AV") {
+				const jumpUrl = item.modules.module_dynamic.major?.archive?.jump_url ?? "";
+				if (this.config.dynamicVideoUrlToBV) {
+					const bvMatch = jumpUrl.match(/BV[0-9A-Za-z]+/);
+					dUrl = bvMatch ? bvMatch[0] : "";
+				} else dUrl = `${name}发布了新视频：https:${jumpUrl}`;
+			} else dUrl = `${name}发布了一条动态：https://t.bilibili.com/${item.id_str}`;
+			const msgContent = buffer ? [koishi.h.image(buffer, "image/jpeg"), koishi.h.text(dUrl)] : [koishi.h.text(`${name}发布了一条动态${dUrl ? `：${dUrl}` : ""}`)];
+			await this.push.broadcastToTargets(uid, (0, koishi.h)("message", msgContent), _bilibili_notify_push.PushType.Dynamic);
+			if (this.config.pushImgsInDynamic && item.type === "DYNAMIC_TYPE_DRAW") {
+				const pics = item.modules?.module_dynamic?.major?.opus?.pics;
+				if (pics?.length) {
+					const picsMsg = (0, koishi.h)("message", { forward: true }, pics.map((p) => koishi.h.img(p.url)));
+					await this.push.broadcastToTargets(uid, picsMsg, _bilibili_notify_push.PushType.Dynamic);
+				}
+			}
+			if (!currentPushDyn[uid]) currentPushDyn[uid] = item;
+		}
+		for (const [uid, item] of Object.entries(currentPushDyn)) {
+			const postTime = item.modules.module_author.pub_ts;
+			this.dynamicTimelineManager.set(uid, postTime);
+			this.dynamicLogger.debug(`更新时间线 UID=${uid} 时间=${luxon.DateTime.fromSeconds(postTime).toFormat("yyyy-MM-dd HH:mm:ss")}`);
+		}
+		this.dynamicLogger.debug(`本次推送 ${Object.keys(currentPushDyn).length} 条动态`);
+	}
+	async handleApiError(code, message) {
+		this.dynamicJob?.stop();
+		this.dynamicJob = void 0;
+		switch (code) {
+			case -101:
+				this.dynamicLogger.error("账号未登录，动态检测已停止");
+				await this.push.sendPrivateMsg("账号未登录，请先登录");
+				this.ctx.emit("bilibili-notify/plugin-error", SERVICE_NAME, "账号未登录");
+				break;
+			case -352:
+				this.dynamicLogger.error("账号被风控，动态检测已停止");
+				await this.push.sendPrivateMsg("账号被风控，请使用 `bili cap` 指令解除风控");
+				this.ctx.emit("bilibili-notify/plugin-error", SERVICE_NAME, "账号被风控");
+				break;
+			default:
+				this.dynamicLogger.error(`获取动态信息失败，错误码：${code}，${message}`);
+				await this.push.sendPrivateMsg(`获取动态信息失败，错误码：${code}`);
+				this.ctx.emit("bilibili-notify/plugin-error", SERVICE_NAME, `获取动态失败，错误码：${code}`);
+		}
+	}
+};
+//#endregion
+//#region src/index.ts
+const name = "bilibili-notify-dynamic";
+const inject = {
+	required: ["bilibili-notify"],
+	optional: ["bilibili-notify-image"]
+};
+const Config = BilibiliNotifyDynamicSchema;
+function apply(ctx, config) {
+	ctx.plugin(BilibiliNotifyDynamic, config);
+}
+//#endregion
+exports.BilibiliNotifyDynamic = BilibiliNotifyDynamic;
+exports.Config = Config;
+exports.apply = apply;
+exports.inject = inject;
+exports.name = name;

package/lib/index.d.cts

@@ -0,0 +1,295 @@
+import { Awaitable, Context, Service } from "koishi";
+import { Subscriptions } from "@bilibili-notify/push";
+
+//#region \0rolldown/runtime.js
+//#endregion
+//#region ../../node_modules/cosmokit/lib/index.d.ts
+type Dict<T = any, K extends string | symbol = string> = { [key in K]: T };
+declare function isArrayBufferLike(value: any): value is ArrayBufferLike;
+declare function isArrayBufferSource(value: any): value is Binary.Source;
+declare namespace Binary {
+  type Source<T extends ArrayBufferLike = ArrayBufferLike> = T | ArrayBufferView<T>;
+  const is: typeof isArrayBufferLike;
+  const isSource: typeof isArrayBufferSource;
+  function fromSource<T extends ArrayBufferLike>(source: Source<T>): T;
+  function toBase64(source: Source): string;
+  function fromBase64(source: string): ArrayBuffer | Uint8Array<ArrayBuffer>;
+  function toHex(source: Source): string;
+  function fromHex(source: string): ArrayBuffer;
+}
+//#endregion
+//#region ../../node_modules/@standard-schema/spec/dist/index.d.ts
+/** The Standard Typed interface. This is a base type extended by other specs. */
+interface StandardTypedV1<Input = unknown, Output = Input> {
+  /** The Standard properties. */
+  readonly "~standard": StandardTypedV1.Props<Input, Output>;
+}
+declare namespace StandardTypedV1 {
+  /** The Standard Typed properties interface. */
+  interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The Standard Typed types interface. */
+  interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Typed. */
+  type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["input"];
+  /** Infers the output type of a Standard Typed. */
+  type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema["~standard"]["types"]>["output"];
+}
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly "~standard": StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown, options?: StandardSchemaV1.Options | undefined) => Result<Output> | Promise<Result<Output>>;
+  }
+  /** The result interface of the validate function. */
+  type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** A falsy value for `issues` indicates success. */
+    readonly issues?: undefined;
+  }
+  interface Options {
+    /** Explicit support for additional vendor-specific parameters, if needed. */
+    readonly libraryOptions?: Record<string, unknown> | undefined;
+  }
+  /** The result interface if validation fails. */
+  interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard types interface. */
+  interface Types<Input = unknown, Output = Input> extends StandardTypedV1.Types<Input, Output> {}
+  /** Infers the input type of a Standard. */
+  type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+  /** Infers the output type of a Standard. */
+  type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+/** The Standard JSON Schema interface. */
+declare namespace index_d_exports {
+  export { Schema as default };
+}
+declare const kSchema: unique symbol;
+declare global {
+  namespace Schemastery {
+    type From<X> = X extends string | number | boolean ? Schema<X> : X extends Schema ? X : X extends typeof String ? Schema<string> : X extends typeof Number ? Schema<number> : X extends typeof Boolean ? Schema<boolean> : X extends typeof Function ? Schema<Function, (...args: any[]) => any> : X extends Constructor<infer S> ? Schema<S> : never;
+    type TypeS1<X> = X extends Schema<infer S, unknown> ? S : never;
+    type Inverse<X> = X extends Schema<any, infer Y> ? (arg: Y) => void : never;
+    type TypeS<X> = TypeS1<From<X>>;
+    type TypeT<X> = ReturnType<From<X>>;
+    type Resolve = (data: any, schema: Schema, options: Options, strict?: boolean) => [any, any?];
+    type IntersectS<X> = From<X> extends Schema<infer S, unknown> ? S : never;
+    type IntersectT<X> = Inverse<From<X>> extends ((arg: infer T) => void) ? T : never;
+    type TupleS<X extends readonly any[]> = X extends readonly [infer L, ...infer R] ? [TypeS<L>?, ...TupleS<R>] : any[];
+    type TupleT<X extends readonly any[]> = X extends readonly [infer L, ...infer R] ? [TypeT<L>?, ...TupleT<R>] : any[];
+    type ObjectS<X extends Dict> = { [K in keyof X]?: TypeS<X[K]> | null } & Dict;
+    type ObjectT<X extends Dict> = { [K in keyof X]: TypeT<X[K]> } & Dict;
+    type Constructor<T = any> = new (...args: any[]) => T;
+    interface Static {
+      <T = any>(options: Partial<Schema<T>>): Schema<T>;
+      new <T = any>(options: Partial<Schema<T>>): Schema<T>;
+      prototype: Schema;
+      resolve: Resolve;
+      from<X = any>(source?: X): From<X>;
+      extend(type: string, resolve: Resolve): void;
+      any<T = any>(): Schema<T>;
+      never(): Schema<never>;
+      const<const T>(value: T): Schema<T>;
+      string(): Schema<string>;
+      number(): Schema<number>;
+      natural(): Schema<number>;
+      percent(): Schema<number>;
+      boolean(): Schema<boolean>;
+      date(): Schema<string | Date, Date>;
+      regExp(flag?: string): Schema<string | RegExp, RegExp>;
+      arrayBuffer(): Schema<Binary.Source, ArrayBufferLike>;
+      arrayBuffer(encoding: 'hex' | 'base64'): Schema<Binary.Source | string, ArrayBufferLike>;
+      bitset<K extends string>(bits: Partial<Record<K, number>>): Schema<number | readonly K[], number>;
+      function(): Schema<Function, (...args: any[]) => any>;
+      is(constructor: string): Schema;
+      is<T>(constructor: Constructor<T>): Schema<T>;
+      array<X>(inner: X): Schema<TypeS<X>[], TypeT<X>[]>;
+      dict<X, Y extends Schema<any, string> = Schema<string>>(inner: X, sKey?: Y): Schema<Dict<TypeS<X>, TypeS<Y>>, Dict<TypeT<X>, TypeT<Y>>>;
+      tuple<const X extends readonly any[]>(list: X): Schema<TupleS<X>, TupleT<X>>;
+      object<X extends Dict>(dict: X): Schema<ObjectS<X>, ObjectT<X>>;
+      union<const X>(list: readonly X[]): Schema<TypeS<X>, TypeT<X>>;
+      intersect<const X>(list: readonly X[]): Schema<IntersectS<X>, IntersectT<X>>;
+      transform<X, T>(inner: X, callback: (value: TypeS<X>, options: Schemastery.Options) => T, preserve?: boolean): Schema<TypeS<X>, T>;
+      lazy<X extends Schema>(callback: () => X): X;
+      ValidationError: typeof ValidationError;
+    }
+    interface Options {
+      autofix?: boolean;
+      ignore?(data: any, schema: Schema): boolean;
+      path?: (keyof any)[];
+    }
+    interface Meta<T = any> {
+      default?: T extends {} ? Partial<T> : T;
+      required?: boolean;
+      disabled?: boolean;
+      collapse?: boolean;
+      badges?: {
+        text: string;
+        type: string;
+      }[];
+      hidden?: boolean;
+      loose?: boolean;
+      role?: string;
+      extra?: any;
+      link?: string;
+      description?: string | Dict<string>;
+      comment?: string;
+      pattern?: {
+        source: string;
+        flags?: string;
+      };
+      max?: number;
+      min?: number;
+      step?: number;
+    }
+  }
+  interface Schemastery<S = any, T = S> {
+    (data?: S | null, options?: Schemastery.Options): T;
+    new (data?: S | null, options?: Schemastery.Options): T;
+    [kSchema]: true;
+    uid: number;
+    meta: Schemastery.Meta<T>;
+    type: string;
+    sKey?: Schema;
+    inner?: Schema;
+    list?: Schema[];
+    dict?: Dict<Schema>;
+    bits?: Dict<number>;
+    callback?: Function;
+    constructor?: string | Function;
+    builder?: Function;
+    value?: T;
+    refs?: Dict<Schema>;
+    preserve?: boolean;
+    '~standard': StandardSchemaV1.Props;
+    toString(inline?: boolean): string;
+    toJSON(): Schema<S, T>;
+    required(value?: boolean): Schema<S, T>;
+    hidden(value?: boolean): Schema<S, T>;
+    loose(value?: boolean): Schema<S, T>;
+    role(text: string, extra?: any): Schema<S, T>;
+    link(link: string): Schema<S, T>;
+    default(value: T): Schema<S, T>;
+    comment(text: string): Schema<S, T>;
+    description(text: string): Schema<S, T>;
+    disabled(value?: boolean): Schema<S, T>;
+    collapse(value?: boolean): Schema<S, T>;
+    deprecated(): Schema<S, T>;
+    experimental(): Schema<S, T>;
+    pattern(regexp: RegExp): Schema<S, T>;
+    max(value: number): Schema<S, T>;
+    min(value: number): Schema<S, T>;
+    step(value: number): Schema<S, T>;
+    set(key: string, value: Schema): Schema<S, T>;
+    push(value: Schema): Schema<S, T>;
+    simplify(value?: any): any;
+    i18n(messages: Dict): Schema<S, T>;
+    extra<K extends keyof Schemastery.Meta>(key: K, value: Schemastery.Meta[K]): Schema<S, T>;
+  }
+}
+declare class ValidationError extends TypeError {
+  options: Schemastery.Options;
+  name: string;
+  constructor(message: string, options: Schemastery.Options);
+  static is(error: any): error is ValidationError;
+}
+type Schema<S = any, T = S> = Schemastery<S, T>;
+declare const Schema: Schemastery.Static;
+//#endregion
+//#region src/types.d.ts
+interface DynamicFilterConfig {
+  enable?: boolean;
+  notify?: boolean;
+  regex?: string;
+  keywords?: string[];
+  forward?: boolean;
+  article?: boolean;
+  whitelistEnable?: boolean;
+  whitelistRegex?: string;
+  whitelistKeywords?: string[];
+}
+//#endregion
+//#region src/config.d.ts
+interface BilibiliNotifyDynamicConfig {
+  logLevel: number;
+  dynamicUrl: boolean;
+  dynamicCron: string;
+  dynamicVideoUrlToBV: boolean;
+  pushImgsInDynamic: boolean;
+  filter: DynamicFilterConfig & {
+    notify?: boolean;
+  };
+}
+//#endregion
+//#region src/dynamic-service.d.ts
+declare module "koishi" {
+  interface Context {
+    "bilibili-notify-dynamic": BilibiliNotifyDynamic;
+  }
+  interface Events {
+    "bilibili-notify/subscription-changed"(subs: Subscriptions): void;
+    "bilibili-notify/plugin-error"(source: string, message: string): void;
+  }
+}
+declare class BilibiliNotifyDynamic extends Service<BilibiliNotifyDynamicConfig> {
+  static readonly [Service.provide] = "bilibili-notify-dynamic";
+  private readonly dynamicLogger;
+  private api;
+  private push;
+  private dynamicJob?;
+  private dynamicSubManager;
+  private dynamicTimelineManager;
+  constructor(ctx: Context, config: BilibiliNotifyDynamicConfig);
+  protected start(): Awaitable<void>;
+  protected stop(): Awaitable<void>;
+  get isActive(): boolean;
+  startDynamicDetector(subs: Subscriptions): void;
+  private detectDynamics;
+  private handleApiError;
+}
+//#endregion
+//#region src/index.d.ts
+declare const name = "bilibili-notify-dynamic";
+declare const inject: {
+  required: string[];
+  optional: string[];
+};
+type Config = BilibiliNotifyDynamicConfig;
+declare const Config: index_d_exports<BilibiliNotifyDynamicConfig>;
+declare function apply(ctx: Context, config: Config): void;
+//#endregion
+export { BilibiliNotifyDynamic, Config, type DynamicFilterConfig, apply, inject, name };

package/package.json

@@ -0,0 +1,60 @@
+{
+	"name": "koishi-plugin-bilibili-notify-dynamic",
+	"version": "0.0.1",
+	"description": "Bilibili 动态推送插件（bilibili-notify 可选插件）",
+	"type": "module",
+	"main": "./lib/index.cjs",
+	"types": "./lib/index.d.cts",
+	"exports": {
+		".": "./lib/index.cjs",
+		"./package.json": "./package.json"
+	},
+	"license": "MIT",
+	"keywords": [
+		"chatbot",
+		"koishi",
+		"plugin",
+		"bilibili",
+		"bilibili-notify"
+	],
+	"scripts": {
+		"build": "tsdown",
+		"typecheck": "tsc --noEmit"
+	},
+	"dependencies": {
+		"@bilibili-notify/api": "workspace:^",
+		"@bilibili-notify/internal": "workspace:^",
+		"@bilibili-notify/push": "workspace:^",
+		"cron": "^3.1.7",
+		"luxon": "^3.5.0"
+	},
+	"devDependencies": {
+		"@types/luxon": "^3.4.2",
+		"koishi-plugin-bilibili-notify": "workspace:^"
+	},
+	"peerDependencies": {
+		"koishi": "^4.18.11",
+		"koishi-plugin-bilibili-notify": "workspace:^"
+	},
+	"engines": {
+		"node": ">=20.0.0"
+	},
+	"koishi": {
+		"service": {
+			"required": [
+				"bilibili-notify"
+			],
+			"optional": [
+				"bilibili-notify-image"
+			]
+		},
+		"description": {
+			"zh": "Bilibili 动态推送插件"
+		}
+	},
+	"inlinedDependencies": {
+		"@standard-schema/spec": "1.1.0",
+		"cosmokit": "1.8.1",
+		"schemastery": "3.18.0"
+	}
+}

package/src/config.ts

@@ -0,0 +1,71 @@
+import { Schema } from "koishi";
+import type { DynamicFilterConfig } from "./types";
+
+export interface BilibiliNotifyDynamicConfig {
+	logLevel: number;
+	dynamicUrl: boolean;
+	dynamicCron: string;
+	dynamicVideoUrlToBV: boolean;
+	pushImgsInDynamic: boolean;
+	filter: DynamicFilterConfig & { notify?: boolean };
+}
+
+export const BilibiliNotifyDynamicSchema: Schema<BilibiliNotifyDynamicConfig> = Schema.object({
+	logLevel: Schema.number()
+		.min(1)
+		.max(3)
+		.step(1)
+		.default(1)
+		.description(
+			"这里可以设置日志等级喔～3 是最详细的调试信息，1 是只显示错误信息。主人可以根据需要选择合适的等级，让女仆更好地为您服务 (๑•̀ㅂ•́)و✧",
+		),
+	dynamicUrl: Schema.boolean()
+		.default(false)
+		.description(
+			"发送动态时要不要顺便发链接呢？但如果主人用的是 QQ 官方机器人，这个开关不要开喔～不然会出事的 (；>_<)！",
+		),
+	dynamicCron: Schema.string()
+		.default("*/2 * * * *")
+		.description(
+			"主人想多久检查一次动态呢？这里填写 cron 表达式～太短太频繁会吓到女仆的，请温柔一点 (〃ﾉωﾉ)",
+		),
+	dynamicVideoUrlToBV: Schema.boolean()
+		.default(false)
+		.description("如果是视频动态，开启后会把链接换成 BV 号哦～方便主人的其他用途 (*´･ω･`)"),
+	pushImgsInDynamic: Schema.boolean()
+		.default(false)
+		.description(
+			"要不要把动态里的图片也一起推送呢？但、但是可能会触发 QQ 的风控，女仆会有点害怕 (；>_<) 请主人小心决定…",
+		),
+	filter: Schema.intersect([
+		Schema.object({
+			enable: Schema.boolean().default(false).description("要开启吗？"),
+		}).description("这里是动态屏蔽设置～如果有不想看到的内容，女仆可以帮主人过滤掉 (＞﹏＜)！"),
+		Schema.union([
+			Schema.object({
+				enable: Schema.const(true).required(),
+				notify: Schema.boolean()
+					.default(false)
+					.description("当动态被屏蔽时，要不要让女仆通知主人呢？"),
+				regex: Schema.string().description(
+					"这里可以填写正则表达式，用来屏蔽特定动态～女仆会努力匹配的！",
+				),
+				keywords: Schema.array(String).description(
+					"这里填写关键字，每一个都是单独的一项～有这些词的动态女仆都会贴心地拦下来 (*´∀`)",
+				),
+				forward: Schema.boolean().default(false).description("要不要屏蔽转发动态呢？主人说了算！"),
+				article: Schema.boolean()
+					.default(false)
+					.description("是否屏蔽专栏动态～女仆会按照主人的喜好来处理 (๑•̀ㅂ•́)و✧"),
+				whitelistEnable: Schema.boolean()
+					.default(false)
+					.description("是否启用白名单过滤（仅推送匹配白名单规则的动态）"),
+				whitelistRegex: Schema.string().description("白名单正则表达式，命中时允许推送该动态"),
+				whitelistKeywords: Schema.array(String).description(
+					"白名单关键词，命中任意关键词时允许推送该动态",
+				),
+			}),
+			Schema.object({}),
+		]),
+	]),
+});

package/src/dynamic-filter.ts

@@ -0,0 +1,85 @@
+import type { Dynamic, DynamicFilterConfig, DynamicFilterResult } from "./types";
+import { DynamicFilterReason as Reason } from "./types";
+
+function collectRichText(dynamic: Dynamic, texts: string[]): void {
+	const richTextNodes = dynamic.modules?.module_dynamic?.desc?.rich_text_nodes;
+	if (richTextNodes?.length) {
+		texts.push(richTextNodes.map((n) => n.text ?? "").join(""));
+	}
+	const summaryNodes = dynamic.modules?.module_dynamic?.major?.opus?.summary?.rich_text_nodes;
+	if (summaryNodes?.length) {
+		texts.push(summaryNodes.map((n) => n.text ?? "").join(""));
+	}
+	const title = dynamic.modules?.module_dynamic?.major?.opus?.title;
+	if (title) texts.push(title);
+	const archiveTitle = dynamic.modules?.module_dynamic?.major?.archive?.title;
+	if (archiveTitle) texts.push(archiveTitle);
+}
+
+function getDynamicText(dynamic: Dynamic): string {
+	const texts: string[] = [];
+	collectRichText(dynamic, texts);
+	if (dynamic.orig) collectRichText(dynamic.orig, texts);
+	return texts.join("\n");
+}
+
+function safeRegexTest(pattern: string | undefined, text: string): boolean {
+	if (!pattern) return false;
+	try {
+		return new RegExp(pattern).test(text);
+	} catch (e) {
+		console.warn(
+			`[bilibili-notify-dynamic] 无效的正则表达式 "${pattern}": ${(e as Error).message}`,
+		);
+		return false;
+	}
+}
+
+function testKeywordMatched(text: string, keywords: string[] | undefined): boolean {
+	if (!keywords?.length) return false;
+	return keywords.some((kw) => kw && text.includes(kw));
+}
+
+export function filterDynamic(dynamic: Dynamic, config: DynamicFilterConfig): DynamicFilterResult {
+	const cfg = {
+		enable: false,
+		regex: "",
+		keywords: [] as string[],
+		forward: false,
+		article: false,
+		whitelistEnable: false,
+		whitelistRegex: "",
+		whitelistKeywords: [] as string[],
+		...config,
+	};
+
+	const text = getDynamicText(dynamic);
+
+	if (cfg.enable) {
+		if (cfg.forward && dynamic.type === "DYNAMIC_TYPE_FORWARD") {
+			return { blocked: true, reason: Reason.BlacklistForward };
+		}
+		if (cfg.article && dynamic.type === "DYNAMIC_TYPE_ARTICLE") {
+			return { blocked: true, reason: Reason.BlacklistArticle };
+		}
+		if (safeRegexTest(cfg.regex, text) || testKeywordMatched(text, cfg.keywords)) {
+			return { blocked: true, reason: Reason.BlacklistKeyword };
+		}
+	}
+
+	if (cfg.whitelistEnable) {
+		const hasRule = !!cfg.whitelistRegex || cfg.whitelistKeywords.length > 0;
+		if (
+			hasRule &&
+			!safeRegexTest(cfg.whitelistRegex, text) &&
+			!testKeywordMatched(text, cfg.whitelistKeywords)
+		) {
+			return { blocked: true, reason: Reason.WhitelistUnmatched };
+		}
+	}
+
+	return { blocked: false };
+}
+
+export type { DynamicFilterConfig, DynamicFilterResult };
+export { Reason as DynamicFilterReason };

package/src/dynamic-service.ts

@@ -0,0 +1,299 @@
+import type { BilibiliAPI } from "@bilibili-notify/api";
+import { BILIBILI_NOTIFY_TOKEN } from "@bilibili-notify/internal";
+import type { BilibiliPush, SubManager, Subscriptions } from "@bilibili-notify/push";
+import { PushType } from "@bilibili-notify/push";
+import { CronJob } from "cron";
+import { type Awaitable, type Context, h, Logger, Service } from "koishi";
+// biome-ignore lint/correctness/noUnusedImports: <empty import> is needed to make sure the type augmentation works
+import {} from "koishi-plugin-bilibili-notify";
+import { DateTime } from "luxon";
+import type { BilibiliNotifyDynamicConfig } from "./config";
+import { DynamicFilterReason, filterDynamic } from "./dynamic-filter";
+import type { AllDynamicInfo, Dynamic, DynamicTimelineManager } from "./types";
+
+declare module "koishi" {
+	interface Context {
+		"bilibili-notify-dynamic": BilibiliNotifyDynamic;
+	}
+	interface Events {
+		"bilibili-notify/subscription-changed"(subs: Subscriptions): void;
+		"bilibili-notify/plugin-error"(source: string, message: string): void;
+	}
+}
+
+const SERVICE_NAME = "bilibili-notify-dynamic";
+
+/** Simple async lock: if the previous run is still executing, skip. */
+function withLock(fn: () => Promise<void>): () => void {
+	let locked = false;
+	return () => {
+		if (locked) return;
+		locked = true;
+		fn()
+			.catch((err) => {
+				console.error("[bilibili-notify-dynamic] Execution error:", err);
+			})
+			.finally(() => {
+				locked = false;
+			});
+	};
+}
+
+export class BilibiliNotifyDynamic extends Service<BilibiliNotifyDynamicConfig> {
+	static readonly [Service.provide] = SERVICE_NAME;
+
+	private readonly dynamicLogger: Logger;
+	private api!: BilibiliAPI;
+	private push!: BilibiliPush;
+	private dynamicJob?: CronJob;
+	private dynamicSubManager: SubManager = new Map();
+	private dynamicTimelineManager: DynamicTimelineManager = new Map();
+
+	constructor(ctx: Context, config: BilibiliNotifyDynamicConfig) {
+		super(ctx, SERVICE_NAME);
+		this.config = config;
+		this.dynamicLogger = new Logger(SERVICE_NAME);
+		this.dynamicLogger.level = config.logLevel;
+	}
+
+	protected start(): Awaitable<void> {
+		const internals = this.ctx["bilibili-notify"].getInternals(BILIBILI_NOTIFY_TOKEN);
+		if (!internals) throw new Error("无法获取 bilibili-notify 内部实例，请确认核心插件已启动");
+		this.api = internals.api;
+		this.push = internals.push;
+		this.dynamicTimelineManager = new Map();
+		// If subscriptions were already loaded before this plugin started, start immediately
+		if (internals.subs) {
+			this.startDynamicDetector(internals.subs);
+		}
+		// Listen for future subscription changes from core
+		this.ctx.on("bilibili-notify/subscription-changed", (subs: Subscriptions) => {
+			this.startDynamicDetector(subs);
+		});
+	}
+
+	protected stop(): Awaitable<void> {
+		if (this.dynamicJob) {
+			this.dynamicJob.stop();
+			this.dynamicLogger.info("动态检测任务已停止");
+		}
+	}
+
+	get isActive(): boolean {
+		return this.dynamicJob?.running ?? false;
+	}
+
+	startDynamicDetector(subs: Subscriptions): void {
+		// Stop existing job first
+		if (this.dynamicJob) {
+			this.dynamicJob.stop();
+			this.dynamicJob = undefined;
+		}
+
+		// Build sub manager with only dynamic-enabled subs
+		const dynamicSubManager: SubManager = new Map();
+		for (const sub of Object.values(subs)) {
+			if (sub.dynamic) {
+				// 只为新增 UID 设置初始时间戳，保留已有 UID 的时间戳避免重推旧动态
+				if (!this.dynamicTimelineManager.has(sub.uid)) {
+					this.dynamicTimelineManager.set(sub.uid, Math.floor(DateTime.now().toSeconds()));
+				}
+				dynamicSubManager.set(sub.uid, sub);
+			}
+		}
+		// 清理已移除 UID 的时间戳记录
+		for (const uid of this.dynamicTimelineManager.keys()) {
+			if (!dynamicSubManager.has(uid)) {
+				this.dynamicTimelineManager.delete(uid);
+			}
+		}
+
+		if (dynamicSubManager.size === 0) {
+			this.dynamicLogger.info("没有需要动态检测的订阅对象");
+			return;
+		}
+
+		this.dynamicSubManager = dynamicSubManager;
+
+		this.dynamicJob = new CronJob(
+			this.config.dynamicCron,
+			withLock(() => this.detectDynamics()),
+		);
+		this.dynamicJob.start();
+		this.dynamicLogger.info("动态检测任务已启动");
+	}
+
+	private async detectDynamics(): Promise<void> {
+		this.dynamicLogger.debug("开始获取动态信息");
+
+		let content: AllDynamicInfo | undefined;
+		try {
+			content = (await this.api.getAllDynamic()) as AllDynamicInfo;
+		} catch (e) {
+			this.dynamicLogger.error(`获取动态失败：${e}`);
+			return;
+		}
+
+		if (!content) return;
+
+		if (content.code !== 0) {
+			await this.handleApiError(content.code, content.message);
+			return;
+		}
+
+		this.dynamicLogger.debug("成功获取动态信息，开始处理");
+
+		const currentPushDyn: Record<string, Dynamic> = {};
+
+		for (const item of content.data.items) {
+			if (!item) continue;
+
+			const postTime = item.modules.module_author.pub_ts;
+			if (typeof postTime !== "number" || !Number.isFinite(postTime)) {
+				this.dynamicLogger.warn(
+					`跳过无效动态：pub_ts 缺失或非数字，ID=${item.id_str ?? "unknown"}`,
+				);
+				continue;
+			}
+
+			const uid = item.modules.module_author.mid.toString();
+			const name = item.modules.module_author.name;
+
+			const timeline = this.dynamicTimelineManager.get(uid);
+			if (timeline === undefined) continue; // not subscribed
+
+			this.dynamicLogger.debug(
+				`检查动态 UP=${name} UID=${uid} 发布时间=${DateTime.fromSeconds(postTime).toFormat("yyyy-MM-dd HH:mm:ss")}`,
+			);
+
+			if (timeline >= postTime) continue; // already pushed
+
+			// Filter
+			const filterResult = filterDynamic(item, this.config.filter ?? {});
+			if (filterResult.blocked) {
+				if (this.config.filter?.notify) {
+					const msgs: Record<DynamicFilterReason, string> = {
+						[DynamicFilterReason.BlacklistKeyword]: `${name}发布了一条含有屏蔽关键字的动态`,
+						[DynamicFilterReason.BlacklistForward]: `${name}转发了一条动态，已屏蔽`,
+						[DynamicFilterReason.BlacklistArticle]: `${name}投稿了一条专栏，已屏蔽`,
+						[DynamicFilterReason.WhitelistUnmatched]: `${name}发布了一条不在白名单范围内的动态，已屏蔽`,
+					};
+					await this.push.broadcastToTargets(
+						uid,
+						h("message", msgs[filterResult.reason as DynamicFilterReason]),
+						PushType.Dynamic,
+					);
+				}
+				continue;
+			}
+
+			// Render card
+			const sub = this.dynamicSubManager.get(uid);
+			// biome-ignore lint/suspicious/noExplicitAny: optional image service
+			const imageService = (this.ctx as any)["bilibili-notify-image"];
+			// biome-ignore lint/suspicious/noExplicitAny: image buffer
+			let buffer: any;
+			try {
+				if (imageService?.generateDynamicCard) {
+					buffer = await imageService.generateDynamicCard(
+						item,
+						sub?.customCardStyle?.enable ? sub.customCardStyle : undefined,
+					);
+				}
+			} catch (e) {
+				const err = e as Error;
+				if (err.message === "直播开播动态，不做处理") continue;
+				this.dynamicLogger.error(`生成动态图片失败：${err.message}，动态检测已停止`);
+				await this.push.sendErrorMsg(`生成动态图片失败：${err.message}，动态检测已停止`);
+				this.dynamicJob?.stop();
+				this.dynamicJob = undefined;
+				this.ctx.emit(
+					"bilibili-notify/plugin-error",
+					SERVICE_NAME,
+					`生成动态图片失败：${err.message}`,
+				);
+				return;
+			}
+
+			// Build URL suffix
+			let dUrl = "";
+			if (this.config.dynamicUrl) {
+				if (item.type === "DYNAMIC_TYPE_AV") {
+					const jumpUrl = item.modules.module_dynamic.major?.archive?.jump_url ?? "";
+					if (this.config.dynamicVideoUrlToBV) {
+						const bvMatch = jumpUrl.match(/BV[0-9A-Za-z]+/);
+						dUrl = bvMatch ? bvMatch[0] : "";
+					} else {
+						dUrl = `${name}发布了新视频：https:${jumpUrl}`;
+					}
+				} else {
+					dUrl = `${name}发布了一条动态：https://t.bilibili.com/${item.id_str}`;
+				}
+			}
+
+			// Send
+			const msgContent = buffer
+				? [h.image(buffer, "image/jpeg"), h.text(dUrl)]
+				: [h.text(`${name}发布了一条动态${dUrl ? `：${dUrl}` : ""}`)];
+			await this.push.broadcastToTargets(uid, h("message", msgContent), PushType.Dynamic);
+
+			// Push extra images from draw dynamics
+			if (this.config.pushImgsInDynamic && item.type === "DYNAMIC_TYPE_DRAW") {
+				const pics = item.modules?.module_dynamic?.major?.opus?.pics;
+				if (pics?.length) {
+					const picsMsg = h(
+						"message",
+						{ forward: true },
+						pics.map((p) => h.img(p.url)),
+					);
+					await this.push.broadcastToTargets(uid, picsMsg, PushType.Dynamic);
+				}
+			}
+
+			// Track the earliest new dynamic per UID
+			if (!currentPushDyn[uid]) {
+				currentPushDyn[uid] = item;
+			}
+		}
+
+		// Update timelines
+		for (const [uid, item] of Object.entries(currentPushDyn)) {
+			const postTime = item.modules.module_author.pub_ts;
+			this.dynamicTimelineManager.set(uid, postTime);
+			this.dynamicLogger.debug(
+				`更新时间线 UID=${uid} 时间=${DateTime.fromSeconds(postTime).toFormat("yyyy-MM-dd HH:mm:ss")}`,
+			);
+		}
+
+		this.dynamicLogger.debug(`本次推送 ${Object.keys(currentPushDyn).length} 条动态`);
+	}
+
+	private async handleApiError(code: number, message: string): Promise<void> {
+		// Stop dynamic detector first
+		this.dynamicJob?.stop();
+		this.dynamicJob = undefined;
+		switch (code) {
+			case -101: {
+				this.dynamicLogger.error("账号未登录，动态检测已停止");
+				await this.push.sendPrivateMsg("账号未登录，请先登录");
+				this.ctx.emit("bilibili-notify/plugin-error", SERVICE_NAME, "账号未登录");
+				break;
+			}
+			case -352: {
+				this.dynamicLogger.error("账号被风控，动态检测已停止");
+				await this.push.sendPrivateMsg("账号被风控，请使用 `bili cap` 指令解除风控");
+				this.ctx.emit("bilibili-notify/plugin-error", SERVICE_NAME, "账号被风控");
+				break;
+			}
+			default: {
+				this.dynamicLogger.error(`获取动态信息失败，错误码：${code}，${message}`);
+				await this.push.sendPrivateMsg(`获取动态信息失败，错误码：${code}`);
+				this.ctx.emit(
+					"bilibili-notify/plugin-error",
+					SERVICE_NAME,
+					`获取动态失败，错误码：${code}`,
+				);
+			}
+		}
+	}
+}

package/src/index.ts

@@ -0,0 +1,21 @@
+import type { Context } from "koishi";
+import { type BilibiliNotifyDynamicConfig, BilibiliNotifyDynamicSchema } from "./config";
+import { BilibiliNotifyDynamic } from "./dynamic-service";
+import type { DynamicFilterConfig } from "./types";
+
+export type { DynamicFilterConfig };
+export { BilibiliNotifyDynamic };
+
+export const name = "bilibili-notify-dynamic";
+
+export const inject = {
+	required: ["bilibili-notify"],
+	optional: ["bilibili-notify-image"],
+};
+
+export type Config = BilibiliNotifyDynamicConfig;
+export const Config = BilibiliNotifyDynamicSchema;
+
+export function apply(ctx: Context, config: Config): void {
+	ctx.plugin(BilibiliNotifyDynamic, config);
+}

package/src/types.ts

@@ -0,0 +1,111 @@
+// ---- Dynamic API response types ----
+
+export type RichTextNode = {
+	orig_text: string;
+	text: string;
+	type: string;
+	emoji?: { icon_url: string; size: number; text: string; type: number };
+	jump_url?: string;
+	rid?: string;
+	// biome-ignore lint/suspicious/noExplicitAny: API response
+	goods?: any;
+	icon_name?: string;
+};
+
+export type Dynamic = {
+	// biome-ignore lint/complexity/noBannedTypes: API response shape
+	basic: Object;
+	id_str: string;
+	type: string;
+	orig?: Dynamic;
+	modules: {
+		module_author: {
+			face: string;
+			following: boolean;
+			jump_url: string;
+			label: string;
+			mid: number;
+			name: string;
+			pub_action: string;
+			pub_time: string;
+			pub_ts: number;
+			type: string;
+			// biome-ignore lint/suspicious/noExplicitAny: API response
+			[key: string]: any;
+		};
+		module_dynamic: {
+			// biome-ignore lint/suspicious/noExplicitAny: API response
+			additional?: any;
+			desc?: {
+				rich_text_nodes: RichTextNode[];
+				text: string;
+			};
+			major?: {
+				opus?: {
+					fold_action: string[];
+					jump_url: string;
+					pics: Array<{
+						height: number;
+						live_url: string;
+						size: number;
+						url: string;
+						width: number;
+					}>;
+					summary: {
+						rich_text_nodes: RichTextNode[];
+						text: string;
+					};
+					title: string;
+				};
+				archive?: {
+					title: string;
+					jump_url: string;
+					// biome-ignore lint/suspicious/noExplicitAny: API response
+					[key: string]: any;
+				};
+				// biome-ignore lint/suspicious/noExplicitAny: API response
+				[key: string]: any;
+			};
+		};
+	};
+};
+
+export type AllDynamicInfo = {
+	code: number;
+	message: string;
+	data: {
+		has_more: boolean;
+		items: Dynamic[];
+		offset: string;
+		update_baseline: string;
+		update_num: number;
+	};
+};
+
+export type DynamicTimelineManager = Map<string, number>;
+
+// ---- Filter types ----
+
+export interface DynamicFilterConfig {
+	enable?: boolean;
+	notify?: boolean;
+	regex?: string;
+	keywords?: string[];
+	forward?: boolean;
+	article?: boolean;
+	whitelistEnable?: boolean;
+	whitelistRegex?: string;
+	whitelistKeywords?: string[];
+}
+
+export enum DynamicFilterReason {
+	BlacklistKeyword = "blacklist-keyword",
+	BlacklistForward = "blacklist-forward",
+	BlacklistArticle = "blacklist-article",
+	WhitelistUnmatched = "whitelist-unmatched",
+}
+
+export interface DynamicFilterResult {
+	blocked: boolean;
+	reason?: DynamicFilterReason;
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+	"extends": "../../tsconfig.base.json",
+	"compilerOptions": {
+		"rootDir": "src",
+		"outDir": "lib"
+	},
+	"include": ["src"]
+}

package/tsdown.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+	entry: ["src/index.ts"],
+	format: ["cjs"],
+	dts: true,
+	clean: true,
+	outDir: "lib",
+	exports: true,
+});