@zhin.js/plugin-music 1.0.26 → 1.1.2

package/src/login/index.ts

@@ -0,0 +1,154 @@
+import type { QrLoginProvider, QrLoginSource, QrPollResult } from './types.js';
+import { QQLoginProvider } from './qq.js';
+import { NeteaseLoginProvider } from './netease.js';
+import type { CredentialStore } from '../credential-store.js';
+
+export type { QrLoginSource, QrPollResult, QrLoginProvider } from './types.js';
+
+export interface QrLoginSession {
+  source: QrLoginSource;
+  pollData: Record<string, string>;
+  timestamp: number;
+  aborted: boolean;
+}
+
+const LOGIN_TIMEOUT_MS = 2 * 60 * 1000;
+const POLL_INTERVAL_MS = 3_000;
+const MAX_POLLS = Math.ceil(LOGIN_TIMEOUT_MS / POLL_INTERVAL_MS);
+
+export function loginSessionKey(
+  endpointId: string,
+  conversationId: string,
+  senderId: string,
+): string {
+  return `login:${endpointId}:${conversationId}:${senderId}`;
+}
+
+/** Generation-owned QR login coordinator. */
+export class QrLoginRuntime {
+  readonly #active = new Map<string, QrLoginSession>();
+  readonly #providers: Readonly<Record<QrLoginSource, QrLoginProvider>>;
+  readonly #credentials: CredentialStore;
+  readonly #now: () => number;
+  readonly #sleep: (ms: number) => Promise<void>;
+
+  constructor(
+    credentials: CredentialStore,
+    providers?: Readonly<Record<QrLoginSource, QrLoginProvider>>,
+    now: () => number = Date.now,
+    sleep: (ms: number) => Promise<void> = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+  ) {
+    this.#credentials = credentials;
+    this.#now = now;
+    this.#sleep = sleep;
+    this.#providers = providers ?? {
+      qq: new QQLoginProvider(),
+      netease: new NeteaseLoginProvider(),
+    };
+  }
+
+  get(key: string): QrLoginSession | undefined {
+    const session = this.#active.get(key);
+    if (!session) return undefined;
+    if (this.#now() - session.timestamp > LOGIN_TIMEOUT_MS) {
+      session.aborted = true;
+      this.#active.delete(key);
+      return undefined;
+    }
+    return session;
+  }
+
+  cancel(key: string): boolean {
+    const session = this.#active.get(key);
+    if (!session) return false;
+    session.aborted = true;
+    this.#active.delete(key);
+    return true;
+  }
+
+  async start(
+    source: QrLoginSource,
+    key: string,
+  ): Promise<{ imageSegment: { type: 'image'; data: Record<string, unknown> } }> {
+    const existing = this.#active.get(key);
+    if (existing && !existing.aborted) existing.aborted = true;
+    const session: QrLoginSession = {
+      source,
+      pollData: {},
+      timestamp: this.#now(),
+      aborted: false,
+    };
+    this.#active.set(key, session);
+
+    try {
+      const result = await this.#providers[source].createQr();
+      if (session.aborted || this.#active.get(key) !== session) {
+        throw new Error('登录已取消');
+      }
+      session.pollData = result.pollData;
+      return { imageSegment: result.imageSegment };
+    } catch (error) {
+      if (this.#active.get(key) === session) this.#active.delete(key);
+      throw error;
+    }
+  }
+
+  async poll(
+    key: string,
+    onStatus: (result: QrPollResult) => Promise<void>,
+  ): Promise<QrPollResult> {
+    const session = this.#active.get(key);
+    if (!session) return { status: 'error', message: '没有进行中的登录会话' };
+
+    const provider = this.#providers[session.source];
+    let lastStatus = '';
+    try {
+      for (let i = 0; i < MAX_POLLS; i++) {
+        if (session.aborted) {
+          this.#active.delete(key);
+          return { status: 'error', message: '登录已取消' };
+        }
+
+        const result = await provider.pollQr(session.pollData);
+        if (result.status !== lastStatus) {
+          lastStatus = result.status;
+          await onStatus(result);
+        }
+        if (result.status === 'confirmed') {
+          this.#active.delete(key);
+          if (result.cookie) await this.#credentials.set(session.source, 'cookie', result.cookie);
+          return result;
+        }
+        if (result.status === 'expired' || result.status === 'error') {
+          this.#active.delete(key);
+          return result;
+        }
+        await this.#sleep(POLL_INTERVAL_MS);
+      }
+    } catch (error) {
+      this.#active.delete(key);
+      return {
+        status: 'error',
+        message: `轮询异常：${error instanceof Error ? error.message : String(error)}`,
+      };
+    }
+
+    this.#active.delete(key);
+    return { status: 'expired', message: '登录超时，请重试' };
+  }
+
+  pruneExpired(): void {
+    const now = this.#now();
+    for (const [key, session] of this.#active) {
+      if (now - session.timestamp > LOGIN_TIMEOUT_MS) {
+        session.aborted = true;
+        this.#active.delete(key);
+      }
+    }
+  }
+
+  dispose(): void {
+    for (const session of this.#active.values()) session.aborted = true;
+    this.#active.clear();
+  }
+}

package/src/login/netease.ts

@@ -0,0 +1,69 @@
+import type { QrLoginProvider, QrCreateResult, QrPollResult } from './types.js';
+import { extractSetCookies } from './types.js';
+
+const QR_IMAGE_API = 'https://api.qrserver.com/v1/create-qr-code/';
+
+export class NeteaseLoginProvider implements QrLoginProvider {
+  async createQr(): Promise<QrCreateResult> {
+    const timestampMs = Date.now();
+    const keyResp = await fetch(
+      `https://music.163.com/api/login/qrcode/unikey?type=1&timestamp=${timestampMs}`,
+      {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: `type=1&timestamp=${timestampMs}`,
+      },
+    );
+    const keyData = (await keyResp.json()) as { code: number; unikey?: string };
+    if (keyData.code !== 200 || !keyData.unikey) {
+      throw new Error('获取网易云登录二维码失败');
+    }
+
+    const loginUrl = `https://music.163.com/login?codekey=${keyData.unikey}`;
+    const imageUrl = `${QR_IMAGE_API}?size=300x300&data=${encodeURIComponent(loginUrl)}`;
+
+    return {
+      imageSegment: { type: 'image', data: { url: imageUrl } },
+      pollData: { unikey: keyData.unikey },
+    };
+  }
+
+  async pollQr(pollData: Record<string, string>): Promise<QrPollResult> {
+    const { unikey } = pollData;
+    try {
+      const response = await fetch(
+        'https://music.163.com/api/login/qrcode/client/login',
+        {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+          body: `key=${unikey}&type=1`,
+        },
+      );
+      const data = (await response.json()) as { code: number; message?: string };
+
+      switch (data.code) {
+        case 801:
+          return { status: 'waiting', message: '等待扫码...' };
+        case 802:
+          return { status: 'scanned', message: '已扫码，请在手机上确认登录' };
+        case 800:
+          return { status: 'expired', message: '二维码已过期，请重新发起登录' };
+        case 803: {
+          const cookie = extractSetCookies(response.headers);
+          return {
+            status: 'confirmed',
+            message: '登录成功',
+            cookie: cookie || undefined,
+          };
+        }
+        default:
+          return { status: 'error', message: data.message ?? '未知状态' };
+      }
+    } catch (err) {
+      return {
+        status: 'error',
+        message: `轮询失败：${err instanceof Error ? err.message : String(err)}`,
+      };
+    }
+  }
+}

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,71 @@
+import { sourceConfigMap, SOURCE_DISPLAY_NAME, formatDuration } from './config.js';
+import type { MusicInfo, MusicDetail, MusicSource } from './types.js';
+import type { MusicRuntime } from './runtime.js';
+
+export async function searchMusic(
+  runtime: MusicRuntime,
+  keyword: string,
+  source?: MusicSource,
+  limit = 5,
+): Promise<{
+  success: true;
+  keyword: string;
+  source: MusicSource;
+  results: MusicInfo[];
+  total: number;
+}> {
+  const s: MusicSource = source ?? 'qq';
+  const service = runtime.services[s];
+  const results = await service.search(keyword, limit);
+  return {
+    success: true,
+    keyword,
+    source: s,
+    results,
+    total: results.length,
+  };
+}
+
+export async function shareMusicDetail(runtime: MusicRuntime, id: string, source: MusicSource) {
+  const service = runtime.services[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/runtime.ts

@@ -0,0 +1,17 @@
+import { createToken } from 'zhin.js';
+import type { CredentialStore } from './credential-store.js';
+import type { MusicSearchService, MusicSource } from './types.js';
+import type { MusicSearchSessions } from './session.js';
+import type { QrLoginRuntime } from './login/index.js';
+
+export interface MusicRuntime {
+  readonly credentials: CredentialStore;
+  readonly services: Readonly<Record<MusicSource, MusicSearchService>>;
+  readonly sessions: MusicSearchSessions;
+  readonly logins: QrLoginRuntime;
+}
+
+export const musicRuntimeToken = createToken<MusicRuntime>(
+  'zhin.music.runtime',
+  'Owner-scoped Music runtime',
+);

package/src/session.ts

@@ -0,0 +1,77 @@
+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;
+
+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 };
+}
+
+/** Generation-owned pending music selections. */
+export class MusicSearchSessions {
+  readonly #pending = new Map<string, PendingSearch>();
+  readonly #timeoutMs: number;
+  readonly #now: () => number;
+
+  constructor(
+    timeoutMs = SEARCH_TIMEOUT_MS,
+    now: () => number = Date.now,
+  ) {
+    this.#timeoutMs = timeoutMs;
+    this.#now = now;
+  }
+
+  set(key: string, search: PendingSearch): void {
+    this.#pending.set(key, search);
+  }
+
+  get(key: string): PendingSearch | undefined {
+    const session = this.#pending.get(key);
+    if (!session) return undefined;
+    if (this.#now() - session.timestamp > this.#timeoutMs) {
+      this.#pending.delete(key);
+      return undefined;
+    }
+    return session;
+  }
+
+  delete(key: string): void {
+    this.#pending.delete(key);
+  }
+
+  pruneExpired(): void {
+    const now = this.#now();
+    for (const [key, session] of this.#pending) {
+      if (now - session.timestamp > this.#timeoutMs) {
+        this.#pending.delete(key);
+      }
+    }
+  }
+
+  dispose(): void {
+    this.#pending.clear();
+  }
+}

package/src/sources/index.ts

@@ -1,13 +1,20 @@
-// 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';
+import type { CredentialStore } from '../credential-store.js';
 
-/** 音乐源服务映射 */
-export const musicServices: Record<MusicSource, MusicSearchService> = {
-  qq: new QQMusicService(),
-  netease: new NeteaseMusicService(),
+export function createMusicServices(credentials: CredentialStore): Record<MusicSource, MusicSearchService> {
+  return {
+    qq: new QQMusicService(credentials),
+    netease: new NeteaseMusicService(credentials),
+    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';