@zhin.js/plugin-music 1.0.25 → 1.1.0

package/src/login/qq.ts

@@ -0,0 +1,154 @@
+import type { QrLoginProvider, QrCreateResult, QrPollResult } from './types.js';
+import { extractSetCookies } from './types.js';
+
+function hashPtqrtoken(qrsig: string): number {
+  let hash = 0;
+  for (let i = 0; i < qrsig.length; i++) {
+    hash += (hash << 5) + qrsig.charCodeAt(i);
+  }
+  return hash & 0x7fffffff;
+}
+
+const APPID = '716027609';
+const DAID = '383';
+const PT_3RD_AID = '100497308';
+const REFERER = 'https://xui.ptlogin2.qq.com/';
+const USER_AGENT =
+  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36';
+
+function commonHeaders(extra?: Record<string, string>): Record<string, string> {
+  return { 'User-Agent': USER_AGENT, Referer: REFERER, ...extra };
+}
+
+export class QQLoginProvider implements QrLoginProvider {
+  async createQr(): Promise<QrCreateResult> {
+    // Step 1: 访问 xlogin 页面获取 pt_login_sig
+    const xloginUrl = new URL('https://xui.ptlogin2.qq.com/cgi-bin/xlogin');
+    xloginUrl.searchParams.set('appid', APPID);
+    xloginUrl.searchParams.set('daid', DAID);
+    xloginUrl.searchParams.set('pt_3rd_aid', PT_3RD_AID);
+    xloginUrl.searchParams.set('s_url', 'https://y.qq.com/');
+    xloginUrl.searchParams.set('style', '33');
+    xloginUrl.searchParams.set('low_login', '0');
+    xloginUrl.searchParams.set('qlogin_auto_login', '1');
+
+    const xloginResp = await fetch(xloginUrl.toString(), {
+      headers: commonHeaders(),
+      redirect: 'manual',
+    });
+    const xloginCookies = extractSetCookies(xloginResp.headers);
+    const loginSigMatch = xloginCookies.match(/pt_login_sig=([^;]+)/);
+    const loginSig = loginSigMatch?.[1] ?? '';
+
+    // Step 2: 获取二维码图片 + qrsig cookie
+    const qrUrl = new URL('https://ssl.ptlogin2.qq.com/ptqrshow');
+    qrUrl.searchParams.set('appid', APPID);
+    qrUrl.searchParams.set('e', '2');
+    qrUrl.searchParams.set('l', 'M');
+    qrUrl.searchParams.set('s', '3');
+    qrUrl.searchParams.set('d', '72');
+    qrUrl.searchParams.set('v', '4');
+    qrUrl.searchParams.set('t', String(Math.random()));
+    qrUrl.searchParams.set('daid', DAID);
+    qrUrl.searchParams.set('pt_3rd_aid', PT_3RD_AID);
+
+    const qrResp = await fetch(qrUrl.toString(), {
+      headers: commonHeaders({
+        Cookie: loginSig ? `pt_login_sig=${loginSig}` : '',
+      }),
+      redirect: 'manual',
+    });
+    const qrCookies = extractSetCookies(qrResp.headers);
+    const qrsigMatch = qrCookies.match(/qrsig=([^;]+)/);
+    const qrsig = qrsigMatch?.[1] ?? '';
+
+    const buffer = Buffer.from(await qrResp.arrayBuffer());
+    const imageBase64 = buffer.toString('base64');
+    const ptqrtoken = String(hashPtqrtoken(qrsig));
+
+    return {
+      imageSegment: {
+        type: 'image',
+        data: { base64: imageBase64, mime_type: 'image/png' },
+      },
+      pollData: { ptqrtoken, qrsig, loginSig },
+    };
+  }
+
+  async pollQr(pollData: Record<string, string>): Promise<QrPollResult> {
+    const { ptqrtoken, qrsig, loginSig } = pollData;
+    const url = new URL('https://ssl.ptlogin2.qq.com/ptqrlogin');
+    url.searchParams.set('u1', 'https://y.qq.com/');
+    url.searchParams.set('ptqrtoken', ptqrtoken!);
+    url.searchParams.set('ptredirect', '0');
+    url.searchParams.set('h', '1');
+    url.searchParams.set('t', '1');
+    url.searchParams.set('g', '1');
+    url.searchParams.set('from_ui', '1');
+    url.searchParams.set('ptlang', '2052');
+    url.searchParams.set('action', `0-0-${Date.now()}`);
+    url.searchParams.set('js_ver', '24112817');
+    url.searchParams.set('js_type', '1');
+    url.searchParams.set('login_sig', loginSig ?? '');
+    url.searchParams.set('pt_uistyle', '40');
+    url.searchParams.set('aid', APPID);
+    url.searchParams.set('daid', DAID);
+    url.searchParams.set('pt_3rd_aid', PT_3RD_AID);
+    url.searchParams.set('has_signing', '1');
+
+    try {
+      const cookieParts = [`qrsig=${qrsig}`];
+      if (loginSig) cookieParts.push(`pt_login_sig=${loginSig}`);
+
+      const response = await fetch(url.toString(), {
+        headers: commonHeaders({ Cookie: cookieParts.join('; ') }),
+        redirect: 'manual',
+      });
+      const text = await response.text();
+
+      if (text.includes('二维码未失效')) {
+        return { status: 'waiting', message: '等待扫码...' };
+      }
+      if (text.includes('二维码认证中') || text.includes('已扫码')) {
+        return { status: 'scanned', message: '已扫码，请在手机上确认登录' };
+      }
+      if (text.includes('二维码已失效')) {
+        return { status: 'expired', message: '二维码已过期，请重新发起登录' };
+      }
+      if (text.includes('登录成功') || text.includes('ptsigx')) {
+        return this.handleLoginSuccess(text, response.headers);
+      }
+
+      if (!text) {
+        return { status: 'error', message: `服务端返回空响应 (HTTP ${response.status})` };
+      }
+
+      return { status: 'waiting', message: '等待扫码...' };
+    } catch (err) {
+      return {
+        status: 'error',
+        message: `轮询失败：${err instanceof Error ? err.message : String(err)}`,
+      };
+    }
+  }
+
+  private async handleLoginSuccess(text: string, headers: Headers): Promise<QrPollResult> {
+    const redirectMatch = text.match(/'(https?:\/\/[^']+)'/);
+    if (redirectMatch) {
+      const redirectResp = await fetch(redirectMatch[1]!, {
+        headers: commonHeaders(),
+        redirect: 'manual',
+      });
+      const cookie = extractSetCookies(redirectResp.headers);
+      if (cookie) {
+        return { status: 'confirmed', message: '登录成功', cookie };
+      }
+    }
+    const cookie = extractSetCookies(headers);
+    return {
+      status: cookie ? 'confirmed' : 'error',
+      message: cookie ? '登录成功' : '登录成功但获取 cookie 失败',
+      cookie: cookie || undefined,
+    };
+  }
+}

package/src/login/types.ts

@@ -0,0 +1,27 @@
+export type QrLoginSource = 'qq' | 'netease';
+
+export interface QrPollResult {
+  status: 'waiting' | 'scanned' | 'confirmed' | 'expired' | 'error';
+  message: string;
+  cookie?: string;
+}
+
+export interface QrCreateResult {
+  imageSegment: { type: 'image'; data: Record<string, unknown> };
+  pollData: Record<string, string>;
+}
+
+export interface QrLoginProvider {
+  createQr(): Promise<QrCreateResult>;
+  pollQr(pollData: Record<string, string>): Promise<QrPollResult>;
+}
+
+export function extractSetCookies(headers: Headers): string {
+  const raw = headers.getSetCookie?.() ?? [];
+  const cookies: string[] = [];
+  for (const entry of raw) {
+    const match = entry.match(/^([^;]+)/);
+    if (match) cookies.push(match[1]!);
+  }
+  return cookies.join('; ');
+}

package/src/music-lib.ts

@@ -0,0 +1,70 @@
+import { musicServices } from './sources/index.js';
+import { sourceConfigMap, SOURCE_DISPLAY_NAME, formatDuration } from './config.js';
+import type { MusicInfo, MusicDetail, MusicSource } from './types.js';
+
+export async function searchMusic(
+  keyword: string,
+  source?: MusicSource,
+  limit = 5,
+): Promise<{
+  success: true;
+  keyword: string;
+  source: MusicSource;
+  results: MusicInfo[];
+  total: number;
+}> {
+  const s: MusicSource = source ?? 'qq';
+  const service = musicServices[s];
+  const results = await service.search(keyword, limit);
+  return {
+    success: true,
+    keyword,
+    source: s,
+    results,
+    total: results.length,
+  };
+}
+
+export async function shareMusicDetail(id: string, source: MusicSource) {
+  const service = musicServices[source];
+  if (!service) {
+    return { success: false as const, error: `不支持的音乐源: ${source}` };
+  }
+  try {
+    const detail = await service.getDetail(id);
+    return { success: true as const, music: detail };
+  } catch (error) {
+    return {
+      success: false as const,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+export function formatSearchResults(results: readonly MusicInfo[], source: MusicSource): string {
+  const sourceName = SOURCE_DISPLAY_NAME[source] ?? source;
+  if (results.length === 0) return `[${sourceName}] 未找到相关歌曲`;
+  const lines = results.map((m, i) => {
+    const parts = [m.title];
+    if (m.artist) parts.push(m.artist);
+    const duration = m.duration ? ` [${formatDuration(m.duration)}]` : '';
+    return `${i + 1}. ${parts.join(' - ')}${duration}`;
+  });
+  return `[${sourceName}] 搜索结果：\n${lines.join('\n')}\n\n回复序号播放，回复"取消"取消选择`;
+}
+
+export function buildMusicShareSegment(detail: MusicDetail) {
+  const config = sourceConfigMap[detail.source];
+  return {
+    type: 'share' as const,
+    data: {
+      title: detail.title,
+      url: detail.url,
+      image: detail.image,
+      audio: detail.audio,
+      duration: detail.duration,
+      artist: detail.artist,
+      config,
+    },
+  };
+}

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,15 +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')
-      // 不同的 Meting API 返回格式可能不同
-      return data.url || data.data?.url!
+  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;
   }
 }