mioku-plugin-music 1.1.0

package/runtime-core/fallback.ts

@@ -0,0 +1,56 @@
+import type { AIService } from "../../../src/services/ai/types";
+import { sendTextMessage } from "./message";
+
+function normalizeErrorMessage(error: unknown): string {
+  if (error instanceof Error && error.message) return error.message;
+  if (typeof error === "string") return error;
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+}
+
+export async function notifyFallback(options: {
+  ctx: any;
+  event: any;
+  aiService?: AIService;
+  instruction: string;
+  fallbackMessage: string;
+  error?: unknown;
+}): Promise<void> {
+  if (options.error != null) {
+    options.ctx?.logger?.error?.(
+      `[music] ${options.instruction}\n执行错误: ${normalizeErrorMessage(options.error)}`,
+    );
+  }
+
+  const chatRuntime = options.aiService?.getChatRuntime();
+  if (chatRuntime) {
+    try {
+      await chatRuntime.generateNotice({
+        event: options.event,
+        instruction: options.instruction,
+        send: true,
+        promptInjections: [
+          {
+            title: "Music Plugin Notice",
+            content:
+              "A music-related action was triggered. Judge whether the user likely intended this action or triggered it accidentally. If it looks accidental or like a casual mention, weave a natural reply into the conversation without mentioning the plugin, tools, or commands. If the user seems to want this feature, respond helpfully. Keep it concise and friendly in Chinese.",
+          },
+        ],
+      });
+      return;
+    } catch (noticeError) {
+      options.ctx?.logger?.error?.(
+        `[music] notice 发送失败: ${normalizeErrorMessage(noticeError)}`,
+      );
+    }
+  }
+
+  await sendTextMessage(
+    options.ctx,
+    options.event,
+    options.fallbackMessage,
+  );
+}

package/runtime-core/message.ts

@@ -0,0 +1,173 @@
+import * as fs from "fs/promises";
+
+function normalizeFileSource(file: string): string {
+  const value = String(file || "").trim();
+  if (!value) {
+    return value;
+  }
+  if (
+    value.startsWith("file://") ||
+    value.startsWith("base64://") ||
+    value.startsWith("http://") ||
+    value.startsWith("https://")
+  ) {
+    return value;
+  }
+  if (value.startsWith("/") || /^[A-Za-z]:[\\/]/.test(value)) {
+    return `file://${value}`;
+  }
+  return value;
+}
+
+function getBotAndTarget(ctx: any, event: any): {
+  bot: any;
+  groupId?: number;
+  userId?: number;
+} {
+  const selfId = event?.self_id != null ? Number(event.self_id) : undefined;
+  const bot =
+    selfId != null && typeof ctx?.pickBot === "function"
+      ? ctx.pickBot(selfId)
+      : undefined;
+
+  return {
+    bot,
+    groupId: event?.message_type === "group" ? Number(event.group_id) : undefined,
+    userId: event?.message_type !== "group" ? Number(event?.user_id) : undefined,
+  };
+}
+
+export async function sendTextMessage(
+  ctx: any,
+  event: any,
+  text: string,
+): Promise<void> {
+  const { bot, groupId, userId } = getBotAndTarget(ctx, event);
+  const payload: any[] = [];
+
+  payload.push(ctx?.segment?.text ? ctx.segment.text(text) : { type: "text", text });
+
+  if (bot && groupId != null) {
+    await bot.sendGroupMsg(groupId, payload);
+    return;
+  }
+  if (bot && userId != null) {
+    await bot.sendPrivateMsg(userId, payload);
+    return;
+  }
+  if (typeof event?.reply === "function") {
+    await event.reply(text);
+    return;
+  }
+  throw new Error("当前上下文不支持文本发送");
+}
+
+export async function sendImageMessage(
+  ctx: any,
+  event: any,
+  imagePath: string,
+): Promise<void> {
+  const { bot, groupId, userId } = getBotAndTarget(ctx, event);
+  const sendPayload = async (source: string) => {
+    const payload: any[] = [];
+    payload.push(
+      ctx?.segment?.image
+        ? ctx.segment.image(normalizeFileSource(source))
+        : { type: "image", file: normalizeFileSource(source) },
+    );
+
+    if (bot && groupId != null) {
+      await bot.sendGroupMsg(groupId, payload);
+      return;
+    }
+    if (bot && userId != null) {
+      await bot.sendPrivateMsg(userId, payload);
+      return;
+    }
+    if (typeof event?.reply === "function") {
+      await event.reply(payload);
+      return;
+    }
+    throw new Error("当前上下文不支持图片发送");
+  };
+
+  try {
+    await sendPayload(imagePath);
+  } catch {
+    const buffer = await fs.readFile(imagePath);
+    const base64 = `base64://${buffer.toString("base64")}`;
+    await sendPayload(base64);
+  }
+}
+
+export async function sendRecordMessage(
+  ctx: any,
+  event: any,
+  audioPath: string,
+): Promise<void> {
+  const { bot, groupId, userId } = getBotAndTarget(ctx, event);
+  const sendPayload = async (source: string) => {
+    const payload: any[] = [];
+    payload.push(
+      ctx?.segment?.record
+        ? ctx.segment.record(normalizeFileSource(source))
+        : { type: "record", file: normalizeFileSource(source) },
+    );
+
+    if (bot && groupId != null) {
+      await bot.sendGroupMsg(groupId, payload);
+      return;
+    }
+    if (bot && userId != null) {
+      await bot.sendPrivateMsg(userId, payload);
+      return;
+    }
+    if (typeof event?.reply === "function") {
+      await event.reply(payload);
+      return;
+    }
+    throw new Error("当前上下文不支持语音发送");
+  };
+
+  const canReadLocalFile =
+    audioPath.startsWith("/") || /^[A-Za-z]:[\\/]/.test(audioPath);
+
+  let fileSendError: unknown;
+  try {
+    await sendPayload(audioPath);
+    return;
+  } catch (error) {
+    fileSendError = error;
+  }
+
+  if (!canReadLocalFile) {
+    throw fileSendError instanceof Error
+      ? fileSendError
+      : new Error(String(fileSendError || "语音发送失败"));
+  }
+
+  let buffer: Buffer;
+  try {
+    buffer = await fs.readFile(audioPath);
+  } catch {
+    throw fileSendError instanceof Error
+      ? fileSendError
+      : new Error(String(fileSendError || "语音发送失败"));
+  }
+
+  const base64 = `base64://${buffer.toString("base64")}`;
+  try {
+    await sendPayload(base64);
+  } catch (base64Error) {
+    const message = String(base64Error || "");
+    const timeoutLike =
+      message.includes("timeout") ||
+      message.includes("超时") ||
+      message.includes("timed out") ||
+      message.includes("ETIMEDOUT");
+    if (timeoutLike) {
+      return;
+    }
+    throw new Error("语音发送失败：路径发送失败，base64 发送也失败");
+  }
+}

package/runtime-core/service.ts

@@ -0,0 +1,413 @@
+import type { AIService } from "../../../src/services/ai/types";
+import type { ScreenshotService } from "../../../src/services/screenshot/types";
+import type { AppleMusicServiceApi } from "../../../src/services/applemusic/types";
+import { MUSIC_DEFAULTS } from "../config";
+import {
+  createMusicProvider,
+  getMusicProviderCandidates,
+  resolveMusicProviderName,
+} from "../providers/factory";
+import { renderMusicSearchListHtml } from "../render/search-list";
+import { MusicSessionStore } from "./session-store";
+import { notifyFallback } from "./fallback";
+import {
+  sendImageMessage,
+  sendRecordMessage,
+  sendTextMessage,
+} from "./message";
+import type {
+  MusicBaseConfig,
+  MusicProviderName,
+  MusicSearchResult,
+  MusicSessionState,
+} from "../types";
+
+interface MusicPluginRuntimeDeps {
+  logger: { info: (msg: string) => void; warn: (msg: string) => void };
+  aiService?: AIService;
+  screenshotService?: ScreenshotService;
+  applemusicService?: AppleMusicServiceApi;
+}
+
+function parseListenIndex(text: string): number | null {
+  const match = text.match(/^\/?听\s*(\d{1,2})$/);
+  if (!match) {
+    return null;
+  }
+  const idx = Number(match[1]);
+  if (!Number.isFinite(idx) || idx <= 0) {
+    return null;
+  }
+  return idx;
+}
+
+function parseSearchKeyword(text: string): string | null {
+  const match = text.match(/^\/?点歌\s*(.+)$/);
+  if (!match) {
+    return null;
+  }
+  const value = String(match[1] || "").trim();
+  return value ? value : null;
+}
+
+function parseListenKeyword(text: string): string | null {
+  const match = text.match(/^\/?听\s*(.+)$/);
+  if (!match) {
+    return null;
+  }
+  const value = String(match[1] || "").trim();
+  if (!value || /^\d+$/.test(value)) {
+    return null;
+  }
+  return value;
+}
+
+export class MusicPluginRuntime {
+  private readonly deps: MusicPluginRuntimeDeps;
+  private readonly sessions = new MusicSessionStore();
+  private config: MusicBaseConfig = MUSIC_DEFAULTS;
+  private static readonly COMMAND_REACTION_FACE_ID = 60;
+
+  constructor(deps: MusicPluginRuntimeDeps) {
+    this.deps = deps;
+  }
+
+  updateConfig(nextConfig: MusicBaseConfig): void {
+    this.config = nextConfig;
+    const services = this.getProviderServices();
+    const configured = String(nextConfig.defaultProvider || "").trim();
+    const resolved = resolveMusicProviderName(configured, services);
+    if (!resolved) {
+      const candidates = getMusicProviderCandidates();
+      this.deps.logger.warn(
+        `music 未找到可用 provider。defaultProvider=${configured || "<empty>"}，候选列表=${candidates.join(", ")}`,
+      );
+      return;
+    }
+    if (configured && configured !== resolved) {
+      this.deps.logger.warn(
+        `music defaultProvider=${configured} 不可用，已回退到 ${resolved}`,
+      );
+    }
+  }
+
+  setSessionMediaUserToken(event: any, token: string): void {
+    const trimmed = String(token || "").trim();
+    if (!trimmed) {
+      return;
+    }
+    const session = this.getOrCreateSession(event);
+    this.sessions.patch(event, {
+      provider: session.provider,
+      mediaUserToken: trimmed,
+    });
+  }
+
+  getSession(event: any): MusicSessionState | undefined {
+    return this.sessions.get(event);
+  }
+
+  async handleMessage(ctx: any, event: any): Promise<boolean> {
+    const text = String(ctx.text(event) || "").trim();
+    if (!text) {
+      return false;
+    }
+
+    const searchKeyword = parseSearchKeyword(text);
+    if (searchKeyword) {
+      await this.tryReactToCommandMessage(ctx, event);
+      await this.searchAndSendList(ctx, event, searchKeyword);
+      return true;
+    }
+
+    const listenIndex = parseListenIndex(text);
+    if (listenIndex != null) {
+      await this.tryReactToCommandMessage(ctx, event);
+      await this.sendByIndex(ctx, event, listenIndex);
+      return true;
+    }
+
+    const listenKeyword = parseListenKeyword(text);
+    if (listenKeyword) {
+      await this.tryReactToCommandMessage(ctx, event);
+      await this.sendByKeyword(ctx, event, listenKeyword);
+      return true;
+    }
+
+    return false;
+  }
+
+  async searchSongs(event: any, query: string): Promise<MusicSearchResult> {
+    const session = this.getOrCreateSession(event);
+    const provider = this.createProvider(
+      session.provider,
+      session.mediaUserToken,
+    );
+    const result = await provider.searchSongs(query, this.config.searchLimit);
+    this.sessions.patch(event, {
+      lastSearch: result,
+      provider: session.provider,
+      mediaUserToken: session.mediaUserToken,
+    });
+    return result;
+  }
+
+  async getSongDetail(event: any, songId: string) {
+    const session = this.getOrCreateSession(event);
+    const provider = this.createProvider(
+      session.provider,
+      session.mediaUserToken,
+    );
+    return provider.getSongDetail(songId);
+  }
+
+  async getAlbumDetail(event: any, albumId: string) {
+    const session = this.getOrCreateSession(event);
+    const provider = this.createProvider(
+      session.provider,
+      session.mediaUserToken,
+    );
+    return provider.getAlbumDetail(albumId);
+  }
+
+  async sendSongById(ctx: any, event: any, songId: string): Promise<void> {
+    const session = this.getOrCreateSession(event);
+    const provider = this.createProvider(
+      session.provider,
+      session.mediaUserToken,
+    );
+    const result = await provider.downloadSong(songId);
+    this.deps.logger.info(
+      `[music] download songId=${songId} source=${result.sourceType} file=${result.filePath}`,
+    );
+    if (result.sourceType !== "hls") {
+      throw new Error("当前未获取到高质量 HLS 音频，请检查 media user token");
+    }
+    await sendRecordMessage(ctx, event, result.filePath);
+  }
+
+  async notifyFailure(
+    ctx: any,
+    event: any,
+    instruction: string,
+    fallbackMessage: string,
+  ): Promise<void> {
+    await notifyFallback({
+      ctx,
+      event,
+      aiService: this.deps.aiService,
+      instruction,
+      fallbackMessage,
+    });
+  }
+
+  async sendSongByQuery(ctx: any, event: any, query: string): Promise<void> {
+    const result = await this.searchSongs(event, query);
+    const first = result.tracks[0];
+    if (!first) {
+      await notifyFallback({
+        ctx,
+        event,
+        aiService: this.deps.aiService,
+        instruction: `用户说“听${query}”，但搜索不到可播放歌曲。请简短提示换关键词。`,
+        fallbackMessage: `没有找到和「${query}」相关的歌曲`,
+      });
+      return;
+    }
+
+    await this.sendSongById(ctx, event, first.id);
+  }
+
+  private async searchAndSendList(
+    ctx: any,
+    event: any,
+    keyword: string,
+  ): Promise<void> {
+    try {
+      const result = await this.searchSongs(event, keyword);
+      if (!result.tracks.length) {
+        await notifyFallback({
+          ctx,
+          event,
+          aiService: this.deps.aiService,
+          instruction: `用户点歌关键词「${keyword}」没有结果，请自然建议换关键词。`,
+          fallbackMessage: `没有找到「${keyword}」的歌曲结果`,
+        });
+        return;
+      }
+
+      if (!this.deps.screenshotService) {
+        await sendTextMessage(
+          ctx,
+          event,
+          `已找到 ${result.tracks.length} 首。发送“听1”播放第一首。`,
+        );
+        return;
+      }
+
+      const html = renderMusicSearchListHtml(result);
+      const imagePath = await this.deps.screenshotService.screenshot(html, {
+        width: 850,
+        height: 100, // 处理极端情况
+        fullPage: true,
+        type: "png",
+        themeMode: "auto",
+      });
+      await sendImageMessage(ctx, event, imagePath);
+      this.deps.logger.info(
+        `[music] search rendered query="${keyword}" count=${result.tracks.length}`,
+      );
+    } catch (error) {
+      await notifyFallback({
+        ctx,
+        event,
+        aiService: this.deps.aiService,
+        instruction: `music 插件搜索失败。错误：${String(error)}。请简短告知稍后重试。`,
+        fallbackMessage: `点歌失败：${String(error)}`,
+        error,
+      });
+    }
+  }
+
+  private async sendByIndex(
+    ctx: any,
+    event: any,
+    index: number,
+  ): Promise<void> {
+    const session = this.getOrCreateSession(event);
+    const tracks = session.lastSearch?.tracks || [];
+    const target = tracks[index - 1];
+    if (!target) {
+      await notifyFallback({
+        ctx,
+        event,
+        aiService: this.deps.aiService,
+        instruction: `用户请求听第${index}首，但当前列表不足。请提示先点歌或检查编号。`,
+        fallbackMessage: `没有第 ${index} 首，请先“点歌 关键词”再选择`,
+      });
+      return;
+    }
+
+    try {
+      await this.sendSongById(ctx, event, target.id);
+    } catch (error) {
+      await notifyFallback({
+        ctx,
+        event,
+        aiService: this.deps.aiService,
+        instruction: `用户选择听第${index}首时下载失败。错误：${String(error)}。请简短道歉并建议重试。`,
+        fallbackMessage: "播放失败，请稍后重试。",
+        error,
+      });
+    }
+  }
+
+  private async sendByKeyword(
+    ctx: any,
+    event: any,
+    keyword: string,
+  ): Promise<void> {
+    try {
+      await this.sendSongByQuery(ctx, event, keyword);
+    } catch (error) {
+      await notifyFallback({
+        ctx,
+        event,
+        aiService: this.deps.aiService,
+        instruction: `用户请求“听${keyword}”时失败。错误：${String(error)}。请简短提示后重试。`,
+        fallbackMessage: "播放失败，请稍后重试。",
+        error,
+      });
+    }
+  }
+
+  private getOrCreateSession(event: any): MusicSessionState {
+    const current = this.sessions.get(event);
+    if (current) {
+      return current;
+    }
+    const provider = this.resolveProviderName(this.config.defaultProvider);
+    const next: MusicSessionState = {
+      provider,
+      updatedAt: Date.now(),
+    };
+    this.sessions.set(event, next);
+    return next;
+  }
+
+  private createProvider(provider: MusicProviderName, mediaUserToken?: string) {
+    const resolvedProvider = this.resolveProviderName(provider);
+    const finalMediaUserToken =
+      String(mediaUserToken || "").trim() ||
+      String(this.config.applemusic.defaultMediaUserToken || "").trim() ||
+      undefined;
+
+    return createMusicProvider(
+      resolvedProvider,
+      {
+        applemusic: this.deps.applemusicService,
+      },
+      {
+        mediaUserToken: finalMediaUserToken,
+        storefront: this.config.applemusic.storefront,
+        language: this.config.applemusic.language,
+      },
+    );
+  }
+
+  private resolveProviderName(
+    preferredProviderName: unknown,
+  ): MusicProviderName {
+    const services = this.getProviderServices();
+    const resolvedProvider = resolveMusicProviderName(
+      preferredProviderName,
+      services,
+    );
+    if (resolvedProvider) {
+      return resolvedProvider;
+    }
+
+    const candidates = getMusicProviderCandidates();
+    const configured = String(preferredProviderName || "").trim();
+    const configuredHint = configured
+      ? `当前配置 defaultProvider=${configured}。`
+      : "当前配置未填写 defaultProvider。";
+    throw new Error(
+      `未找到可用的 music provider 服务。${configuredHint} 已注册 provider 列表：${candidates.join(", ")}。`,
+    );
+  }
+
+  private getProviderServices() {
+    return {
+      applemusic: this.deps.applemusicService,
+    };
+  }
+
+  private async tryReactToCommandMessage(ctx: any, event: any): Promise<void> {
+    const messageId = Number(event?.message_id);
+    if (!Number.isFinite(messageId) || messageId <= 0) {
+      return;
+    }
+
+    const selfId = Number(event?.self_id || ctx?.self_id);
+    if (!Number.isFinite(selfId) || selfId <= 0) {
+      return;
+    }
+
+    const bot =
+      typeof ctx?.pickBot === "function" ? ctx.pickBot(selfId) : undefined;
+    if (!bot || typeof bot.api !== "function") {
+      return;
+    }
+
+    try {
+      await bot.api("set_msg_emoji_like", {
+        message_id: messageId,
+        emoji_id: MusicPluginRuntime.COMMAND_REACTION_FACE_ID,
+        set: true,
+      });
+    } catch (error) {
+      this.deps.logger.warn(`music set_msg_emoji_like 失败: ${error}`);
+    }
+  }
+}

package/runtime-core/session-store.ts

@@ -0,0 +1,52 @@
+import type { MusicSessionState } from "../types";
+import { MUSIC_PROVIDER_NAMES } from "../types";
+
+const SESSION_TTL_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_PROVIDER = MUSIC_PROVIDER_NAMES[0];
+
+function buildSessionKey(event: any): string {
+  if (event?.group_id != null) {
+    return `group:${String(event.group_id)}`;
+  }
+  if (event?.user_id != null) {
+    return `private:${String(event.user_id)}`;
+  }
+  return `unknown:${Date.now()}`;
+}
+
+export class MusicSessionStore {
+  private readonly sessions = new Map<string, MusicSessionState>();
+
+  get(event: any): MusicSessionState | undefined {
+    this.cleanup();
+    return this.sessions.get(buildSessionKey(event));
+  }
+
+  set(event: any, nextState: MusicSessionState): void {
+    this.cleanup();
+    this.sessions.set(buildSessionKey(event), nextState);
+  }
+
+  patch(event: any, patchState: Partial<MusicSessionState>): MusicSessionState {
+    const current = this.get(event) || {
+      provider: DEFAULT_PROVIDER,
+      updatedAt: Date.now(),
+    };
+    const next = {
+      ...current,
+      ...patchState,
+      updatedAt: Date.now(),
+    };
+    this.set(event, next);
+    return next;
+  }
+
+  private cleanup(): void {
+    const now = Date.now();
+    for (const [key, state] of this.sessions.entries()) {
+      if (now - state.updatedAt > SESSION_TTL_MS) {
+        this.sessions.delete(key);
+      }
+    }
+  }
+}