mioku-plugin-media 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mioku Lab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,42 @@
+# mioku-plugin-media
+
+流媒体解析插件，自动识别并解析哔哩哔哩、抖音、小红书和快手平台的视频/图文链接。
+
+## 功能
+
+- 自动检测消息中的平台链接，无需命令前缀
+- 支持哔哩哔哩、抖音、小红书、快手四大平台
+- 返回封面图、标题、作者、简介和视频文件
+- 可选配置各平台 Cookies 以获取更高质量的视频
+
+## 支持平台
+
+### 哔哩哔哩
+- 域名：bilibili.com、b23.tv、t.bilibili.com、bili2233.cn
+- 支持纯 BV 号（BV...）和 av 号（av...）格式
+
+### 抖音
+- 域名：douyin.com、iesdouyin.com 及子域名（www, v, jx, m, jingxuan）
+
+### 快手
+- 域名：kuaishou.com、v.kuaishou.com
+- 支持 APP 分享文本格式（如"快手...快手"）
+
+### 小红书
+- 域名：xiaohongshu.com、xhslink.com
+
+## 配置
+
+通过 WebUI 配置页面或直接编辑配置文件：
+
+```json
+{
+  "cookies": {
+    "bilibili": "",
+    "douyin": "",
+    "kuaishou": "",
+    "xiaohongshu": ""
+  },
+  "debug": false
+}
+```

package/config.md

@@ -0,0 +1,29 @@
+---
+title: 媒体解析配置
+description: 配置各平台 Cookie 和调试选项
+fields:
+  - key: base.cookies.bilibili
+    label: 哔哩哔哩 Cookie
+    type: textarea
+    description: B站 Cookie，配置后可获取更高质量的视频流。留空则使用基础解析。
+
+  - key: base.cookies.douyin
+    label: 抖音 Cookie
+    type: textarea
+    description: 抖音 Cookie，配置后可获取无水印视频。留空则使用基础解析。
+
+  - key: base.cookies.kuaishou
+    label: 快手 Cookie
+    type: textarea
+    description: 快手 Cookie，配置后可获取更完整的视频信息。留空则使用基础解析。
+
+  - key: base.cookies.xiaohongshu
+    label: 小红书 Cookie
+    type: textarea
+    description: 小红书 Cookie，配置后可获取笔记详情和视频。留空则使用基础解析。
+
+  - key: base.debug
+    label: 调试模式
+    type: switch
+    description: 开启后解析失败时直接发送错误信息，不走 AI 通知
+---

package/config.ts

@@ -0,0 +1,19 @@
+export interface MediaConfig {
+  cookies: {
+    bilibili: string;
+    douyin: string;
+    kuaishou: string;
+    xiaohongshu: string;
+  };
+  debug: boolean;
+}
+
+export const MEDIA_DEFAULTS: MediaConfig = {
+  cookies: {
+    bilibili: "",
+    douyin: "",
+    kuaishou: "",
+    xiaohongshu: "",
+  },
+  debug: false,
+};

package/index.ts

@@ -0,0 +1,124 @@
+import { definePlugin, type MiokiContext } from "mioki";
+import type { ConfigService } from "../../src/services/config/tpyes";
+import type { MediaConfig } from "./types";
+import { MEDIA_DEFAULTS } from "./config";
+import { createMediaAmagiClient } from "./platforms/amagi-client";
+import { extractMediaUrlFromEvent, resolveShortUrl, isShortUrl } from "./platforms/url-parser";
+import { resolveMedia } from "./platforms/resolvers";
+import { sendMediaResult } from "./utils/message";
+import { handleMediaError } from "./utils/error-handler";
+import { setMediaRuntimeState, resetMediaRuntimeState } from "./runtime";
+
+const REACTION_EMOJI_ID = 60;
+
+function cloneConfig<T>(value: T): T {
+  return JSON.parse(JSON.stringify(value)) as T;
+}
+
+async function addReaction(bot: any, messageId: number | string): Promise<void> {
+  if (!bot || messageId == null) return;
+  try {
+    await bot.api("set_msg_emoji_like", {
+      message_id: messageId,
+      emoji_id: REACTION_EMOJI_ID,
+      set: true,
+    });
+  } catch {
+    // ignore reaction errors
+  }
+}
+
+export default definePlugin({
+  name: "media",
+  version: "1.0.0",
+  description: "流媒体解析插件，支持哔哩哔哩、抖音、小红书和快手平台",
+
+  async setup(ctx: MiokiContext) {
+    const configService = ctx.services?.config as ConfigService | undefined;
+    let config = cloneConfig(MEDIA_DEFAULTS);
+
+    if (configService) {
+      await configService.registerConfig("media", "base", config);
+      const saved = await configService.getConfig("media", "base");
+      if (saved) {
+        config = saved as MediaConfig;
+      }
+    } else {
+      ctx.logger.warn("config-service 未加载，media 插件将使用默认配置");
+    }
+
+    let amagiClient = createMediaAmagiClient(config);
+
+    setMediaRuntimeState({ config, amagiClient });
+
+    const disposers: Array<() => void> = [];
+    if (configService) {
+      disposers.push(
+        configService.onConfigChange("media", "base", (next) => {
+          config = next as MediaConfig;
+          amagiClient = createMediaAmagiClient(config);
+          setMediaRuntimeState({ config, amagiClient });
+        }),
+      );
+    }
+
+    ctx.handle("message", async (event: any) => {
+      if (event.user_id === event.self_id) return;
+
+      const parsed = extractMediaUrlFromEvent(event);
+      if (!parsed) return;
+
+      const messageId = event.message_id ?? event.message_seq;
+
+      const platformLabel =
+        parsed.platform === "bilibili"
+          ? "B站"
+          : parsed.platform === "douyin"
+            ? "抖音"
+            : parsed.platform === "kuaishou"
+              ? "快手"
+              : "小红书";
+
+      ctx.logger.info(`[media] 检测到${platformLabel}链接，开始解析...`);
+
+      const selfId = event?.self_id != null ? Number(event.self_id) : undefined;
+      const bot =
+        selfId != null && typeof ctx?.pickBot === "function"
+          ? ctx.pickBot(selfId)
+          : undefined;
+
+      await addReaction(bot, messageId);
+
+      try {
+        if (isShortUrl(parsed)) {
+          ctx.logger.info(`[media] 检测到短链接，正在解析: ${parsed.id}`);
+          const resolvedUrl = await resolveShortUrl(parsed.id);
+          const reParsed = extractMediaUrlFromEvent({ raw_message: resolvedUrl, message: [{ type: "text", data: { text: resolvedUrl } }] });
+          if (reParsed) {
+            Object.assign(parsed, reParsed);
+          } else {
+            ctx.logger.warn(`[media] 短链接解析后无法识别: ${resolvedUrl}`);
+          }
+        }
+
+        const result = await resolveMedia(amagiClient, parsed);
+        await sendMediaResult(ctx, event, parsed, result);
+      } catch (error) {
+        await handleMediaError({
+          ctx,
+          event,
+          error,
+          platform: platformLabel,
+          config,
+        });
+      }
+    });
+
+    return () => {
+      for (const dispose of disposers) {
+        dispose();
+      }
+      resetMediaRuntimeState();
+    };
+  },
+});

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "mioku-plugin-media",
+  "version": "1.0.0",
+  "description": "流媒体解析插件，支持哔哩哔哩、抖音、小红书和快手平台",
+  "main": "index.ts",
+  "keywords": [
+    "mioku"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mioku-lab/mioku-plugin-media.git"
+  },
+  "dependencies": {
+    "@ikenxuan/amagi": "^6.1.2"
+  },
+  "mioku": {
+    "services": [
+      "config",
+      "ai"
+    ],
+    "help": {
+      "title": "媒体解析",
+      "description": "自动识别并解析哔哩哔哩、抖音、小红书、快手的视频/图文链接",
+      "commands": [
+        {
+          "cmd": "发送包含平台链接的消息",
+          "desc": "自动识别并解析消息中的B站/抖音/小红书/快手链接，返回视频信息和视频文件",
+          "role": "member"
+        }
+      ]
+    }
+  }
+}

package/platforms/amagi-client.ts

@@ -0,0 +1,24 @@
+import { createAmagiClient } from "@ikenxuan/amagi";
+import type { MediaConfig } from "../types";
+
+export function createMediaAmagiClient(config: MediaConfig): any {
+  const cookies: Record<string, string> = {};
+
+  if (config.cookies.bilibili?.trim()) {
+    cookies.bilibili = config.cookies.bilibili.trim();
+  }
+  if (config.cookies.douyin?.trim()) {
+    cookies.douyin = config.cookies.douyin.trim();
+  }
+  if (config.cookies.kuaishou?.trim()) {
+    cookies.kuaishou = config.cookies.kuaishou.trim();
+  }
+  if (config.cookies.xiaohongshu?.trim()) {
+    cookies.xiaohongshu = config.cookies.xiaohongshu.trim();
+  }
+
+  return createAmagiClient({
+    cookies,
+    request: { timeout: 15000 },
+  });
+}

package/platforms/resolvers/bilibili.ts

@@ -0,0 +1,95 @@
+import type { ParsedMediaResult } from "../../types";
+import type { ParsedMediaUrl } from "../types";
+import type { PlatformResolver } from "./types";
+
+export class BilibiliResolver implements PlatformResolver {
+  async resolve(client: any, parsed: ParsedMediaUrl): Promise<ParsedMediaResult> {
+    let bvid = parsed.id;
+    let avid: number | undefined;
+
+    if (bvid.startsWith("av")) {
+      avid = parseInt(bvid.slice(2), 10);
+    }
+
+    if (bvid.startsWith("http")) {
+      const infoResult = await client.bilibili.fetcher.fetchVideoInfo({ bvid: "" });
+      if (!infoResult.success) {
+        throw new Error(`B站视频信息获取失败: ${infoResult.message}`);
+      }
+      const data = infoResult.data?.data || infoResult.data;
+      bvid = data?.bvid || "";
+      avid = data?.aid;
+      if (!bvid) {
+        throw new Error("B站短链接解析失败，无法获取BV号");
+      }
+    }
+
+    const infoResult = await client.bilibili.fetcher.fetchVideoInfo({ bvid });
+    if (!infoResult.success) {
+      throw new Error(`B站视频信息获取失败: ${infoResult.message}`);
+    }
+
+    const infoData = infoResult.data?.data || infoResult.data;
+    if (!infoData) {
+      throw new Error("B站视频信息为空");
+    }
+
+    const title = infoData.title || "未知标题";
+    const author = infoData.owner?.name || "未知作者";
+    const description = infoData.desc || "";
+    const coverUrl = infoData.pic || "";
+    const cid = infoData.cid || infoData.pages?.[0]?.cid;
+    const aid = infoData.aid || avid || 0;
+    const duration = infoData.duration;
+
+    let videoUrl = "";
+
+    if (aid && cid) {
+      try {
+        const streamResult = await client.bilibili.fetcher.fetchVideoStreamUrl({
+          avid: aid,
+          cid,
+        });
+
+        if (streamResult.success) {
+          const streamData = streamResult.data?.data || streamResult.data;
+          if (streamData?.durl?.length) {
+            videoUrl = streamData.durl[0].url || "";
+          } else if (streamData?.dash?.video?.length) {
+            const videoItem = streamData.dash.video[0];
+            const audioItem = streamData.dash.audio?.[0];
+            videoUrl = videoItem.baseUrl || videoItem.base_url || "";
+            if (!videoUrl && videoItem.backupUrl?.length) {
+              videoUrl = videoItem.backupUrl[0];
+            }
+            if (!videoUrl && videoItem.backup_url?.length) {
+              videoUrl = videoItem.backup_url[0];
+            }
+          }
+        }
+      } catch {
+        videoUrl = "";
+      }
+    }
+
+    const stat = infoData.stat || {};
+
+    return {
+      title,
+      author,
+      description,
+      coverUrl,
+      videoUrl,
+      duration,
+      stats: {
+        likes: stat.like,
+        coins: stat.coin,
+        favorites: stat.favorite,
+        shares: stat.share,
+        views: stat.view,
+        comments: stat.reply,
+        danmaku: stat.danmaku,
+      },
+    };
+  }
+}

package/platforms/resolvers/douyin.ts

@@ -0,0 +1,80 @@
+import type { ParsedMediaResult } from "../../types";
+import type { ParsedMediaUrl } from "../types";
+import type { PlatformResolver } from "./types";
+
+export class DouyinResolver implements PlatformResolver {
+  async resolve(client: any, parsed: ParsedMediaUrl): Promise<ParsedMediaResult> {
+    const awemeId = parsed.id;
+
+    const result = await client.douyin.fetcher.parseWork({ aweme_id: awemeId });
+    if (!result.success) {
+      const err = new Error(`抖音作品解析失败: ${result.message}`);
+      (err as any).cause = result;
+      throw err;
+    }
+
+    const data = result.data;
+    if (!data) {
+      throw new Error("抖音作品数据为空");
+    }
+
+    const detail = data.aweme_detail || data;
+    const title = detail.desc || detail.item_title || "未知标题";
+    const author = detail.author?.nickname || "未知作者";
+    const description = detail.desc || "";
+    const coverUrl =
+      detail.video?.cover?.url_list?.[0] ||
+      detail.video?.origin_cover?.url_list?.[0] ||
+      detail.video?.dynamic_cover?.url_list?.[0] ||
+      "";
+    const duration = detail.duration;
+
+    let videoUrl = "";
+
+    if (detail.video) {
+      videoUrl =
+        detail.video?.play_addr?.url_list?.[0] ||
+        detail.video?.download_addr?.url_list?.[0] ||
+        "";
+
+      if (!videoUrl && detail.video?.bit_rate?.length) {
+        const bestBitrate = detail.video.bit_rate.reduce(
+          (best: any, curr: any) =>
+            (curr.bit_rate || 0) > (best.bit_rate || 0) ? curr : best,
+          detail.video.bit_rate[0],
+        );
+        videoUrl =
+          bestBitrate?.play_addr?.url_list?.[0] || "";
+      }
+    }
+
+    const images: string[] = [];
+    if (detail.images && Array.isArray(detail.images)) {
+      for (const img of detail.images) {
+        const url =
+          img?.url_list?.[0] ||
+          img?.download_addr?.url_list?.[0] ||
+          "";
+        if (url) images.push(url);
+      }
+    }
+
+    const statistics = detail.statistics || detail.stats || {};
+
+    return {
+      title,
+      author,
+      description,
+      coverUrl,
+      videoUrl,
+      duration,
+      stats: {
+        likes: statistics.digg_count,
+        favorites: statistics.collect_count,
+        shares: statistics.share_count,
+        comments: statistics.comment_count,
+        views: statistics.play_count,
+      },
+    };
+  }
+}

package/platforms/resolvers/index.ts

@@ -0,0 +1,27 @@
+import type { ParsedMediaUrl } from "../types";
+import type { ParsedMediaResult } from "../../types";
+import type { PlatformResolver } from "./types";
+import { BilibiliResolver } from "./bilibili";
+import { DouyinResolver } from "./douyin";
+import { KuaishouResolver } from "./kuaishou";
+import { XiaohongshuResolver } from "./xiaohongshu";
+
+const resolvers: Record<string, PlatformResolver> = {
+  bilibili: new BilibiliResolver(),
+  douyin: new DouyinResolver(),
+  kuaishou: new KuaishouResolver(),
+  xiaohongshu: new XiaohongshuResolver(),
+};
+
+export async function resolveMedia(
+  client: any,
+  parsed: ParsedMediaUrl,
+): Promise<ParsedMediaResult> {
+  const resolver = resolvers[parsed.platform];
+  if (!resolver) {
+    throw new Error(`不支持的平台: ${parsed.platform}`);
+  }
+  return resolver.resolve(client, parsed);
+}
+
+export { BilibiliResolver, DouyinResolver, KuaishouResolver, XiaohongshuResolver };

package/platforms/resolvers/kuaishou.ts

@@ -0,0 +1,58 @@
+import type { ParsedMediaResult } from "../../types";
+import type { ParsedMediaUrl } from "../types";
+import type { PlatformResolver } from "./types";
+
+export class KuaishouResolver implements PlatformResolver {
+  async resolve(client: any, parsed: ParsedMediaUrl): Promise<ParsedMediaResult> {
+    const photoId = parsed.id;
+
+    const result = await client.kuaishou.fetcher.fetchVideoWork({ photoId });
+    if (!result.success) {
+      throw new Error(`快手作品解析失败: ${result.message}`);
+    }
+
+    const data = result.data;
+    if (!data) {
+      throw new Error("快手作品数据为空");
+    }
+
+    const detail = data.data?.visionVideoDetail || data;
+    const photo = detail.photo || {};
+    const authorInfo = detail.author || {};
+
+    const title = photo.caption || "未知标题";
+    const author = authorInfo.name || "未知作者";
+    const description = photo.caption || "";
+    const coverUrl = photo.coverUrl || "";
+    const duration = photo.duration;
+
+    let videoUrl = "";
+
+    if (photo.photoUrl) {
+      videoUrl = photo.photoUrl;
+    } else if (photo.croppedPhotoUrl) {
+      videoUrl = photo.croppedPhotoUrl;
+    } else if (photo.videoResource?.h264?.adaptationSet?.[0]?.representation?.[0]?.url) {
+      videoUrl = photo.videoResource.h264.adaptationSet[0].representation[0].url;
+    } else if (photo.videoResource?.hevc?.adaptationSet?.[0]?.representation?.[0]?.url) {
+      videoUrl = photo.videoResource.hevc.adaptationSet[0].representation[0].url;
+    } else if (photo.manifest?.adaptationSet?.[0]?.representation?.[0]?.url) {
+      videoUrl = photo.manifest.adaptationSet[0].representation[0].url;
+    }
+
+    return {
+      title,
+      author,
+      description,
+      coverUrl,
+      videoUrl,
+      duration,
+      stats: {
+        likes: photo.likeCount || photo.likeCnt,
+        comments: photo.commentCount || photo.commentCnt,
+        views: photo.viewCount || photo.viewCnt,
+        shares: photo.shareCount || photo.shareCnt,
+      },
+    };
+  }
+}

package/platforms/resolvers/types.ts

@@ -0,0 +1,6 @@
+import type { ParsedMediaResult } from "../../types";
+import type { ParsedMediaUrl } from "../types";
+
+export interface PlatformResolver {
+  resolve(client: any, parsed: ParsedMediaUrl): Promise<ParsedMediaResult>;
+}

package/platforms/resolvers/xiaohongshu.ts

@@ -0,0 +1,92 @@
+import type { ParsedMediaResult } from "../../types";
+import type { ParsedMediaUrl } from "../types";
+import type { PlatformResolver } from "./types";
+
+export class XiaohongshuResolver implements PlatformResolver {
+  async resolve(client: any, parsed: ParsedMediaUrl): Promise<ParsedMediaResult> {
+    const noteId = parsed.id;
+    const xsecToken = parsed.extra?.xsec_token || "";
+
+    if (!xsecToken && !parsed.id.startsWith("http")) {
+      throw new Error("小红书笔记解析需要 xsec_token，请确保链接包含完整参数");
+    }
+
+    const result = await client.xiaohongshu.fetcher.fetchNoteDetail({
+      note_id: noteId,
+      xsec_token: xsecToken,
+    });
+
+    if (!result.success) {
+      throw new Error(`小红书笔记解析失败: ${result.message}`);
+    }
+
+    const data = result.data;
+    if (!data) {
+      throw new Error("小红书笔记数据为空");
+    }
+
+    const items = data.data?.items || data.items || [];
+    const noteCard = items[0]?.note_card || items[0]?.note_card;
+
+    if (!noteCard) {
+      const noteData = data.data || data;
+      const title = noteData.title || "未知标题";
+      const author = noteData.user?.nickname || "未知作者";
+      const description = noteData.desc || "";
+      const coverUrl =
+        noteData.image_list?.[0]?.url ||
+        noteData.image_list?.[0]?.url_default ||
+        noteData.image_list?.[0]?.url_pre ||
+        "";
+
+      return {
+        title,
+        author,
+        description,
+        coverUrl,
+        videoUrl: "",
+        stats: buildXhsStats(noteData.interact_info),
+      };
+    }
+
+    const title = noteCard.title || "未知标题";
+    const author = noteCard.user?.nickname || "未知作者";
+    const description = noteCard.desc || "";
+    const coverUrl =
+      noteCard.image_list?.[0]?.url ||
+      noteCard.image_list?.[0]?.url_default ||
+      noteCard.image_list?.[0]?.url_pre ||
+      "";
+
+    let videoUrl = "";
+    if (noteCard.type === "video" && noteCard.video) {
+      const video = noteCard.video;
+      videoUrl =
+        video.media?.stream?.h264?.[0]?.master_url ||
+        video.media?.stream?.h264?.[0]?.backup_urls?.[0] ||
+        video.media?.stream?.h265?.[0]?.master_url ||
+        video.media?.stream?.h265?.[0]?.backup_urls?.[0] ||
+        video.consumer?.origin_video_key ||
+        "";
+    }
+
+    return {
+      title,
+      author,
+      description,
+      coverUrl,
+      videoUrl,
+      stats: buildXhsStats(noteCard.interact_info),
+    };
+  }
+}
+
+function buildXhsStats(interactInfo: any): import("../../types").MediaStats {
+  if (!interactInfo) return {};
+  return {
+    likes: parseInt(interactInfo.like_count, 10) || undefined,
+    favorites: parseInt(interactInfo.collect_count, 10) || undefined,
+    comments: parseInt(interactInfo.comment_count, 10) || undefined,
+    shares: parseInt(interactInfo.share_count, 10) || undefined,
+  };
+}

package/platforms/types.ts

@@ -0,0 +1,8 @@
+export type Platform = "bilibili" | "douyin" | "kuaishou" | "xiaohongshu";
+
+export interface ParsedMediaUrl {
+  platform: Platform;
+  id: string;
+  subtype?: "video" | "article" | "note" | "bangumi";
+  extra?: Record<string, string>;
+}