@zhin.js/plugin-music 7.0.8 → 7.0.10

package/src/session.ts

@@ -0,0 +1,60 @@
+import type { MusicInfo, MusicSource } from './types.js';
+
+export interface PendingSearch {
+  readonly results: readonly MusicInfo[];
+  readonly source: MusicSource;
+  readonly keyword: string;
+  readonly timestamp: number;
+}
+
+const SEARCH_TIMEOUT_MS = 3 * 60 * 1000;
+
+const pendingSessions = new Map<string, PendingSearch>();
+
+export function sessionKey(
+  endpointId: string,
+  conversationId: string,
+  senderId: string,
+): string {
+  return `${endpointId}:${conversationId}:${senderId}`;
+}
+
+export function resolveMessageIds(input: {
+  metadata?: Record<string, unknown>;
+  conversation?: { id?: unknown; endpoint?: { id?: unknown } };
+  sender?: { id?: unknown };
+}): { endpointId: string; conversationId: string; senderId: string } | null {
+  const meta = input.metadata ?? {};
+  const endpointId = String(meta.endpointId ?? input.conversation?.endpoint?.id ?? '');
+  const conversationId = String(input.conversation?.id ?? '');
+  const senderId = String(input.sender?.id ?? '');
+  if (!endpointId || !conversationId || !senderId) return null;
+  return { endpointId, conversationId, senderId };
+}
+
+export function setPending(key: string, search: PendingSearch): void {
+  pendingSessions.set(key, search);
+}
+
+export function getPending(key: string): PendingSearch | undefined {
+  const session = pendingSessions.get(key);
+  if (!session) return undefined;
+  if (Date.now() - session.timestamp > SEARCH_TIMEOUT_MS) {
+    pendingSessions.delete(key);
+    return undefined;
+  }
+  return session;
+}
+
+export function clearPending(key: string): void {
+  pendingSessions.delete(key);
+}
+
+export function cleanExpired(): void {
+  const now = Date.now();
+  for (const [key, session] of pendingSessions) {
+    if (now - session.timestamp > SEARCH_TIMEOUT_MS) {
+      pendingSessions.delete(key);
+    }
+  }
+}

package/src/sources/index.ts

@@ -1,13 +1,17 @@
-// plugins/utils/music/src/sources/index.ts
-import { QQMusicService } from './qq.js'
-import { NeteaseMusicService } from './netease.js'
-import type { MusicSource, MusicSearchService } from '../types.js'
+import { QQMusicService } from './qq.js';
+import { NeteaseMusicService } from './netease.js';
+import { KuwoMusicService } from './kuwo.js';
+import { KugouMusicService } from './kugou.js';
+import type { MusicSource, MusicSearchService } from '../types.js';
 
-/** 音乐源服务映射 */
 export const musicServices: Record<MusicSource, MusicSearchService> = {
   qq: new QQMusicService(),
   netease: new NeteaseMusicService(),
-}
+  kuwo: new KuwoMusicService(),
+  kugou: new KugouMusicService(),
+};
 
-export * from './qq.js'
-export * from './netease.js'
+export * from './qq.js';
+export * from './netease.js';
+export * from './kuwo.js';
+export * from './kugou.js';

package/src/sources/kugou.ts

@@ -0,0 +1,78 @@
+import type { MusicSearchService, MusicDetail, MusicInfo } from '../types.js';
+
+interface KugouSearchItem {
+  hash: string;
+  songname: string;
+  singername: string;
+  album_name?: string;
+  duration: number;
+  album_id?: string;
+}
+
+export class KugouMusicService implements MusicSearchService {
+  async search(keyword: string, limit = 10): Promise<MusicInfo[]> {
+    try {
+      const url = new URL('https://mobilecdn.kugou.com/api/v3/search/song');
+      url.searchParams.set('format', 'json');
+      url.searchParams.set('keyword', keyword);
+      url.searchParams.set('page', '1');
+      url.searchParams.set('pagesize', String(limit));
+      url.searchParams.set('showtype', '1');
+
+      const response = await fetch(url, { method: 'GET' });
+      const data = (await response.json()) as {
+        data?: { info?: KugouSearchItem[] };
+      };
+
+      const items = data.data?.info ?? [];
+      return items.slice(0, limit).map((item) => ({
+        id: item.hash,
+        source: 'kugou' as const,
+        title: item.songname?.replace(/<[^>]+>/g, '') ?? '',
+        artist: item.singername,
+        album: item.album_name,
+        duration: item.duration,
+        url: `https://www.kugou.com/song/#hash=${item.hash}`,
+      }));
+    } catch {
+      return [];
+    }
+  }
+
+  async getDetail(id: string): Promise<MusicDetail> {
+    const url = new URL('https://wwwapi.kugou.com/yy/index.php');
+    url.searchParams.set('r', 'play/getdata');
+    url.searchParams.set('hash', id);
+    url.searchParams.set('mid', 'music');
+    url.searchParams.set('platid', '4');
+
+    const response = await fetch(url, { method: 'GET' });
+    const result = (await response.json()) as {
+      data?: {
+        song_name?: string;
+        author_name?: string;
+        album_name?: string;
+        img?: string;
+        play_url?: string;
+        timelength?: number;
+      };
+    };
+    const info = result.data;
+    if (!info) throw new Error('Music not found');
+
+    const audio = info.play_url ?? '';
+    if (!audio) throw new Error('Audio URL not found');
+
+    return {
+      id,
+      source: 'kugou',
+      title: info.song_name ?? '',
+      artist: info.author_name,
+      album: info.album_name,
+      url: `https://www.kugou.com/song/#hash=${id}`,
+      image: info.img ?? '',
+      audio,
+      duration: info.timelength ? Math.floor(info.timelength / 1000) : undefined,
+    };
+  }
+}

package/src/sources/kuwo.ts

@@ -0,0 +1,94 @@
+import type { MusicSearchService, MusicDetail, MusicInfo } from '../types.js';
+
+interface KuwoSearchItem {
+  rid: number;
+  name: string;
+  artist: string;
+  album: string;
+  duration: number;
+  pic?: string;
+  albumpic?: string;
+}
+
+export class KuwoMusicService implements MusicSearchService {
+  async search(keyword: string, limit = 10): Promise<MusicInfo[]> {
+    try {
+      const url = new URL('https://search.kuwo.cn/r.s');
+      url.searchParams.set('client', 'kt');
+      url.searchParams.set('all', keyword);
+      url.searchParams.set('pn', '0');
+      url.searchParams.set('rn', String(limit));
+      url.searchParams.set('ft', 'music');
+      url.searchParams.set('encoding', 'utf8');
+      url.searchParams.set('rformat', 'json');
+      url.searchParams.set('mobi', '1');
+      url.searchParams.set('vipver', '1');
+
+      const response = await fetch(url, { method: 'GET' });
+      const text = await response.text();
+      const data = JSON.parse(text.replace(/'/g, '"')) as {
+        abslist?: KuwoSearchItem[];
+      };
+
+      const items = data.abslist ?? [];
+      return items.slice(0, limit).map((item) => ({
+        id: String(item.rid),
+        source: 'kuwo' as const,
+        title: item.name?.replace(/&nbsp;/g, ' ') ?? '',
+        artist: item.artist?.replace(/&nbsp;/g, ' '),
+        album: item.album?.replace(/&nbsp;/g, ' '),
+        duration: item.duration,
+        url: `https://www.kuwo.cn/play_detail/${item.rid}`,
+      }));
+    } catch {
+      return [];
+    }
+  }
+
+  async getDetail(id: string): Promise<MusicDetail> {
+    const url = new URL('https://www.kuwo.cn/api/www/music/musicInfo');
+    url.searchParams.set('mid', id);
+    url.searchParams.set('httpsStatus', '1');
+
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: { Referer: 'https://www.kuwo.cn/', csrf: id },
+    });
+    const result = (await response.json()) as {
+      data?: {
+        name?: string;
+        artist?: string;
+        album?: string;
+        pic?: string;
+        albumpic?: string;
+        duration?: number;
+      };
+    };
+    const info = result.data;
+    if (!info) throw new Error('Music not found');
+
+    return {
+      id,
+      source: 'kuwo',
+      title: info.name ?? '',
+      artist: info.artist,
+      album: info.album,
+      url: `https://www.kuwo.cn/play_detail/${id}`,
+      image: info.pic ?? info.albumpic ?? '',
+      audio: await this.getAudioUrl(id),
+      duration: info.duration,
+    };
+  }
+
+  async getAudioUrl(id: string): Promise<string> {
+    const url = `https://antiserver.kuwo.cn/anti.s?type=convert_url3&rid=${id}&format=mp3`;
+    const response = await fetch(url, {
+      method: 'GET',
+      redirect: 'follow',
+    });
+    const text = await response.text();
+    const match = /http[^\s]+/.exec(text);
+    if (match) return match[0];
+    throw new Error('Audio URL not found');
+  }
+}

package/src/sources/netease.ts

@@ -1,5 +1,6 @@
 // plugins/utils/music/src/sources/netease.ts
-import type { MusicSearchService, MusicDetail,MusicInfo, Music163 } from '../types.js'
+import type { MusicSearchService, MusicDetail, MusicInfo, Music163 } from '../types.js';
+import { getCredential } from '../credential-store.js';
 
 /** 网易云音乐搜索服务 */
 export class NeteaseMusicService implements MusicSearchService {
@@ -70,16 +71,32 @@ export class NeteaseMusicService implements MusicSearchService {
    * @param metingAPI Meting API 地址（可选）
    * @returns 音频直链 URL
    */
-  async getAudioUrl(id: string, metingAPI?: string): Promise<string> {
-    // 默认使用 Meting API
-      const apiUrl = metingAPI || 'https://api.injahow.cn/meting/'
-      const url = `${apiUrl}?type=url&id=${id}`
-      
-      const response = await fetch(url, { method: 'GET' })
-      const data = await response.json() as { url?: string, data?: { url?: string } }
-      if (!data.url && !data.data?.url) throw new Error('Audio URL not found')
-      const audioUrl = data.url ?? data.data?.url
-      if (!audioUrl) throw new Error('Audio URL not found')
-      return audioUrl
+  async getAudioUrl(id: string): Promise<string> {
+    const cookie = await getCredential('netease', 'cookie');
+    if (cookie) {
+      try {
+        const response = await fetch(
+          `https://music.163.com/api/song/enhance/player/url?ids=[${id}]&br=320000`,
+          {
+            method: 'GET',
+            headers: { Cookie: cookie },
+          },
+        );
+        const result = await response.json() as {
+          data?: Array<{ url?: string | null }>;
+        };
+        const audioUrl = result.data?.[0]?.url;
+        if (audioUrl) return audioUrl;
+      } catch {
+        // cookie-based fetch failed, fall through to public API
+      }
+    }
+    const apiUrl = 'https://api.injahow.cn/meting/';
+    const url = `${apiUrl}?type=url&id=${id}`;
+    const response = await fetch(url, { method: 'GET' });
+    const data = await response.json() as { url?: string; data?: { url?: string } };
+    const audioUrl = data.url ?? data.data?.url;
+    if (!audioUrl) throw new Error('Audio URL not found');
+    return audioUrl;
   }
 }

package/src/sources/qq.ts

@@ -1,147 +1,180 @@
-// plugins/utils/music/src/sources/qq.ts
-import type { MusicSearchService, MusicDetail,MusicInfo, MusicQQ } from '../types.js'
+import * as crypto from 'node:crypto';
+import type { MusicSearchService, MusicDetail, MusicInfo } from '../types.js';
+import { getCredential } from '../credential-store.js';
+
+const md5 = (text: string) => crypto.createHash('md5').update(text).digest('hex');
+
+const MUSICU_API = 'https://u.y.qq.com/cgi-bin/musicu.fcg';
+
+function getHeaders(cookie?: string | null) {
+  return {
+    Referer: 'https://y.qq.com',
+    Cookie: cookie ?? '',
+    'Content-Type': 'application/json; charset=UTF-8',
+  };
+}
 
-/** QQ 音乐搜索服务 */
 export class QQMusicService implements MusicSearchService {
   async search(keyword: string, limit = 10): Promise<MusicInfo[]> {
     try {
-      const url = new URL('https://c.y.qq.com/splcloud/fcgi-bin/smartbox_new.fcg')
-      url.searchParams.set('key', keyword)
-      url.searchParams.set('format', 'json')
-      
-      const response = await fetch(url, { method: 'GET' })
-      const data = await response.json() as { data: { song: { itemlist: MusicQQ[] } } }
-      
-      const items = data.data?.song?.itemlist || []
-      return items.slice(0, limit).map(music => ({
-        id: music.id,
-        source: 'qq' as const,
-        title: music.name,
-        url: `https://y.qq.com/n/yqq/song/${music.mid}.html`
-      }))
-    } catch (error) {
-      console.error('QQ Music search failed:', error)
-      return []
-    }
-  }
+      const cookie = await getCredential('qq', 'cookie');
+      const response = await fetch(MUSICU_API, {
+        method: 'POST',
+        headers: getHeaders(cookie),
+        body: JSON.stringify({
+          comm: { uin: '0', authst: '', ct: 29 },
+          search: {
+            method: 'DoSearchForQQMusicMobile',
+            module: 'music.search.SearchCgiService',
+            param: {
+              query: keyword,
+              grp: 1,
+              num_per_page: limit,
+              page_num: 1,
+              search_type: 0,
+              searchid: String(Date.now()),
+            },
+          },
+        }),
+      });
 
-  async getCover(id: string): Promise<string | null> {
-    try {
-      const url = new URL('https://u.y.qq.com/cgi-bin/musicu.fcg')
-      url.searchParams.set('format', 'json')
-      url.searchParams.set('inCharset', 'utf8')
-      url.searchParams.set('outCharset', 'utf-8')
-      url.searchParams.set('notice', '0')
-      url.searchParams.set('platform', 'yqq.json')
-      url.searchParams.set('needNewCode', '0')
-      url.searchParams.set('data', JSON.stringify({
-        comm: { ct: 24, cv: 0 },
-        songinfo: {
-          method: 'get_song_detail_yqq',
-          param: { song_type: 0, song_mid: '', song_id: parseInt(id) },
-          module: 'music.pf_song_detail_svr'
-        }
-      }))
-
-      const response = await fetch(url, { method: 'GET' })
-      const result = await response.json()
-      
-      const albumMid = result?.songinfo?.data?.track_info?.album?.mid
-      if (!albumMid) return null
-      
-      return `https://y.gtimg.cn/music/photo_new/T002R300x300M000${albumMid}.jpg`
+      const data = (await response.json()) as { code?: number; search?: { data?: { body?: { song?: { list?: any[] }; item_song?: any[] } } } };
+      if (data.code !== undefined && +data.code !== 0) return [];
+
+      const body = data.search?.data?.body ?? {};
+      const list = (body.song?.list ?? body.item_song ?? []) as any[];
+
+      return list.slice(0, limit).map((e) => {
+        const mid = e?.mid ?? '';
+        const albumMid = e?.album?.pmid ?? e?.album?.mid ?? '';
+        const singerMid = e?.singer?.[0]?.pmid ?? e?.singer?.[0]?.mid ?? '';
+        const cover = albumMid
+          ? `https://y.gtimg.cn/music/photo_new/T002R300x300M000${albumMid}.jpg`
+          : singerMid
+            ? `https://y.qq.com/music/photo_new/T001R300x300M000${singerMid}.jpg`
+            : '';
+
+        return {
+          id: String(e.id),
+          source: 'qq' as const,
+          title: e.name,
+          artist: (e.singer ?? []).map((s: any) => s.name).join('/'),
+          album: e.album?.name,
+          url: `https://y.qq.com/n/ryqq/songDetail/${mid}`,
+          image: cover,
+          duration: e.interval,
+          _mid: mid,
+          _mediaMid: e.file?.media_mid,
+        };
+      });
     } catch (error) {
-      console.error('QQ Music get cover failed:', error)
-      return null
+      console.error('QQ Music search failed:', error);
+      return [];
     }
   }
 
   async getDetail(id: string): Promise<MusicDetail> {
-    const url = new URL('https://u.y.qq.com/cgi-bin/musicu.fcg')
-      url.searchParams.set('format', 'json')
-      url.searchParams.set('data', JSON.stringify({
-        comm: { ct: 24, cv: 0 },
-        songinfo: {
-          method: 'get_song_detail_yqq',
-          param: { song_type: 0, song_mid: '', song_id: parseInt(id) },
-          module: 'music.pf_song_detail_svr'
-        }
-      }))
-
-      const response = await fetch(url, { method: 'GET' })
-      const result = await response.json()
-      
-      const trackInfo = result?.songinfo?.data?.track_info
-      if (!trackInfo) throw new Error('Music not found')
-
-      const albumMid = trackInfo.album?.mid
-      const image = albumMid 
-        ? `https://y.gtimg.cn/music/photo_new/T002R300x300M000${albumMid}.jpg`
-        : undefined
-
-      return {
-        id,
-        source: 'qq',
-        title: trackInfo.name,
-        url: `https://y.qq.com/n/yqq/song/${trackInfo.mid}.html`,
-        audio: await this.getAudioUrl(id),
-        image: image || '',
-        duration: trackInfo.interval,
-      }
+    const url = new URL(MUSICU_API);
+    url.searchParams.set('format', 'json');
+    url.searchParams.set('data', JSON.stringify({
+      comm: { ct: 24, cv: 0 },
+      songinfo: {
+        method: 'get_song_detail_yqq',
+        param: { song_type: 0, song_mid: '', song_id: parseInt(id) },
+        module: 'music.pf_song_detail_svr',
+      },
+    }));
+
+    const response = await fetch(url, { method: 'GET' });
+    const result = await response.json() as any;
+
+    const trackInfo = result?.songinfo?.data?.track_info;
+    if (!trackInfo) throw new Error('Music not found');
+
+    const albumMid = trackInfo.album?.mid;
+    const image = albumMid
+      ? `https://y.gtimg.cn/music/photo_new/T002R300x300M000${albumMid}.jpg`
+      : '';
+
+    return {
+      id,
+      source: 'qq',
+      title: trackInfo.name,
+      url: `https://y.qq.com/n/ryqq/songDetail/${trackInfo.mid}`,
+      audio: await this.getAudioUrl(id, trackInfo.mid, trackInfo.file?.media_mid),
+      image,
+      duration: trackInfo.interval,
+    };
   }
 
-  /**
-   * 获取音频直链（需要第三方 API）
-   * @param id 音乐 ID
-   * @param metingAPI Meting API 地址（可选）
-   * @returns 音频直链 URL
-   */
-  async getAudioUrl(id: string, metingAPI?: string): Promise<string> {
-    // QQ 音乐需要使用第三方 API
-      const apiUrl = metingAPI || 'https://api.injahow.cn/meting/'
-      const url = `${apiUrl}?type=url&id=${id}&source=qq`
-      
-      const response = await fetch(url, { method: 'GET' })
-      const data = await response.json() as { url?: string, data?: { url?: string } }
-      if (!data.url && !data.data?.url) {
-        throw new Error('Audio URL not found')
+  async getAudioUrl(id: string, mid?: string, mediaMid?: string): Promise<string> {
+    const cookie = await getCredential('qq', 'cookie');
+    if (cookie) {
+      try {
+        const uin = /uin=o?(\d+)/.exec(cookie)?.[1] ?? '0';
+        const songMid = mid ?? id;
+        const response = await fetch(MUSICU_API, {
+          method: 'POST',
+          headers: getHeaders(cookie),
+          body: JSON.stringify({
+            comm: {
+              ct: 19,
+              cv: '1891',
+              uin: '0',
+              guid: md5(`${uin}music`),
+              tmeAppID: 'qqmusic',
+              tmeLoginType: 2,
+            },
+            vkey: {
+              module: 'vkey.GetVkeyServer',
+              method: 'CgiGetVkey',
+              param: {
+                guid: md5(String(Date.now())),
+                songmid: [songMid],
+                songtype: [0],
+                uin: '0',
+                ctx: 1,
+                filename: [`C400${id}${mediaMid ?? songMid}.m4a`],
+              },
+            },
+          }),
+        });
+
+        const result = await response.json() as any;
+        if (result.vkey && +result.vkey.code === 0) {
+          const purl = result.vkey.data?.midurlinfo?.[0]?.purl;
+          if (purl) return `https://ws.stream.qqmusic.qq.com/${purl}`;
+        }
+      } catch {
+        // fall through to public fallback
       }
-      const audioUrl = data.url ?? data.data?.url
-      if (!audioUrl) throw new Error('Audio URL not found')
-      return audioUrl
+    }
+
+    // 无 cookie 的公开 fallback：md5 签名直链
+    const songMid = mid ?? id;
+    const code = md5(`${songMid}q;z(&l~sdf2!nK`).substring(0, 5).toUpperCase();
+    return `https://c6.y.qq.com/rsc/fcgi-bin/fcg_pyq_play.fcg?songmid=${songMid}&code=${code}`;
   }
 
-  /**
-   * 获取歌词
-   * @param id 音乐 ID
-   * @returns 歌词文本
-   */
   async getLyric(id: string): Promise<string | null> {
     try {
-      const url = new URL('https://c.y.qq.com/lyric/fcgi-bin/fcg_query_lyric_new.fcg')
-      url.searchParams.set('songmid', id)
-      url.searchParams.set('g_tk', '5381')
-      url.searchParams.set('format', 'json')
-      url.searchParams.set('inCharset', 'utf8')
-      url.searchParams.set('outCharset', 'utf-8')
-      url.searchParams.set('nobase64', '1')
-
-      const response = await fetch(url, { 
+      const url = new URL('https://c.y.qq.com/lyric/fcgi-bin/fcg_query_lyric_new.fcg');
+      url.searchParams.set('songmid', id);
+      url.searchParams.set('g_tk', '5381');
+      url.searchParams.set('format', 'json');
+      url.searchParams.set('inCharset', 'utf8');
+      url.searchParams.set('outCharset', 'utf-8');
+      url.searchParams.set('nobase64', '1');
+
+      const response = await fetch(url, {
         method: 'GET',
-        headers: {
-          'Referer': 'https://y.qq.com'
-        }
-      })
-      const data = await response.json() as { lyric?: string }
-      
-      if (!data.lyric) return null
-      
-      // 请求已带 nobase64=1，返回的是明文歌词，直接返回；
-      // 再按 base64 解码会得到乱码（Buffer.from(x,'base64') 对明文也不会抛错）
-      return data.lyric
+        headers: { Referer: 'https://y.qq.com' },
+      });
+      const data = (await response.json()) as { lyric?: string };
+      return data.lyric ?? null;
     } catch (error) {
-      console.error('QQ Music get lyric failed:', error)
-      return null
+      console.error('QQ Music get lyric failed:', error);
+      return null;
     }
   }
 }