@zhin.js/plugin-music 7.0.8 → 7.0.9

package/src/credential-store.ts

@@ -0,0 +1,169 @@
+import {
+  createGenerationStore,
+  type Dispose,
+  type GenerationStoreContext,
+} from '@zhin.js/plugin-runtime';
+import type { MusicSource } from './types.js';
+
+export const MUSIC_CREDENTIALS_TABLE = 'music_credentials';
+
+export interface CredentialRow {
+  source: MusicSource;
+  key: string;
+  value: string;
+  updated_at: string;
+}
+
+export interface CredentialModel {
+  select(...fields: string[]): {
+    where(query: Record<string, unknown>): PromiseLike<Record<string, unknown>[]>;
+    then<TResult1 = Record<string, unknown>[], TResult2 = never>(
+      onfulfilled?:
+        | ((value: Record<string, unknown>[]) => TResult1 | PromiseLike<TResult1>)
+        | null,
+      onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null,
+    ): Promise<TResult1 | TResult2>;
+  };
+  insert(row: Record<string, unknown>): Promise<unknown>;
+  delete(): { where(query: Record<string, unknown>): Promise<unknown> };
+  update(patch: Record<string, unknown>): {
+    where(query: Record<string, unknown>): Promise<unknown>;
+  };
+}
+
+export interface CredentialDb {
+  models: { get(name: string): CredentialModel | undefined };
+}
+
+function createMemoryModel(): CredentialModel {
+  const rows: Record<string, unknown>[] = [];
+
+  function matches(
+    row: Record<string, unknown>,
+    query: Record<string, unknown>,
+  ): boolean {
+    return Object.entries(query).every(([k, v]) => row[k] === v);
+  }
+
+  return {
+    select: () => {
+      const all = rows.map((r) => ({ ...r }));
+      return {
+        where: async (query) =>
+          rows.filter((r) => matches(r, query)).map((r) => ({ ...r })),
+        then: (onfulfilled, onrejected) =>
+          Promise.resolve(all).then(onfulfilled, onrejected),
+      };
+    },
+    insert: async (row) => {
+      rows.push({ ...row });
+    },
+    delete: () => ({
+      where: async (query) => {
+        for (let i = rows.length - 1; i >= 0; i--) {
+          if (matches(rows[i]!, query)) rows.splice(i, 1);
+        }
+      },
+    }),
+    update: (patch) => ({
+      where: async (query) => {
+        for (const row of rows) {
+          if (matches(row, query)) Object.assign(row, patch);
+        }
+      },
+    }),
+  };
+}
+
+const credentialDbStore = createGenerationStore<CredentialDb>('music/credential-db');
+let _memoryDb: CredentialDb | null = null;
+
+export function provideCredentialDb(
+  context: GenerationStoreContext,
+  db: CredentialDb,
+): Dispose {
+  return credentialDbStore.provide(context, db);
+}
+
+function getDb(): CredentialDb {
+  const provided = credentialDbStore.tryUse();
+  if (provided) return provided;
+  if (!_memoryDb) {
+    _memoryDb = {
+      models: {
+        get: (name) =>
+          name === MUSIC_CREDENTIALS_TABLE ? memoryModel : undefined,
+      },
+    };
+  }
+  return _memoryDb;
+}
+
+const memoryModel = createMemoryModel();
+
+function getModel(): CredentialModel | null {
+  return getDb().models.get(MUSIC_CREDENTIALS_TABLE) ?? null;
+}
+
+export async function getCredential(
+  source: MusicSource,
+  key: string,
+): Promise<string | null> {
+  const model = getModel();
+  if (!model) return null;
+  const rows = await model.select().where({ source, key });
+  if (rows.length === 0) return null;
+  return String(rows[0]!.value ?? '');
+}
+
+export async function setCredential(
+  source: MusicSource,
+  key: string,
+  value: string,
+): Promise<void> {
+  const model = getModel();
+  if (!model) return;
+  const existing = await model.select().where({ source, key });
+  if (existing.length > 0) {
+    await model
+      .update({ value, updated_at: new Date().toISOString() })
+      .where({ source, key });
+  } else {
+    await model.insert({
+      source,
+      key,
+      value,
+      updated_at: new Date().toISOString(),
+    });
+  }
+}
+
+export async function deleteCredential(
+  source: MusicSource,
+  key: string,
+): Promise<void> {
+  const model = getModel();
+  if (!model) return;
+  await model.delete().where({ source, key });
+}
+
+export async function listCredentials(
+  source?: MusicSource,
+): Promise<CredentialRow[]> {
+  const model = getModel();
+  if (!model) return [];
+  const rows = source
+    ? await model.select().where({ source })
+    : await model.select();
+  return rows.map((r) => ({
+    source: String(r.source) as MusicSource,
+    key: String(r.key),
+    value: String(r.value),
+    updated_at: String(r.updated_at ?? ''),
+  }));
+}
+
+export function resetCredentialDb(): void {
+  credentialDbStore.clear();
+  _memoryDb = null;
+}

package/src/index.ts

@@ -1,4 +1,45 @@
-export { formatDuration, formatMusicInfo, sourceConfigMap } from './config.js';
-export { searchMusic, shareMusicDetail } from './music-lib.js';
+export {
+  formatDuration,
+  formatMusicInfo,
+  sourceConfigMap,
+  SOURCE_ALIASES,
+  SOURCE_DISPLAY_NAME,
+  resolveSourceAlias,
+} from './config.js';
+export {
+  searchMusic,
+  shareMusicDetail,
+  formatSearchResults,
+  buildMusicShareSegment,
+} from './music-lib.js';
 export { musicServices } from './sources/index.js';
+export {
+  sessionKey,
+  resolveMessageIds,
+  setPending,
+  getPending,
+  clearPending,
+  cleanExpired,
+  type PendingSearch,
+} from './session.js';
+export {
+  getCredential,
+  setCredential,
+  deleteCredential,
+  listCredentials,
+  MUSIC_CREDENTIALS_TABLE,
+  provideCredentialDb,
+  resetCredentialDb,
+} from './credential-store.js';
+export {
+  startLogin,
+  pollLogin,
+  cancelLogin,
+  getActiveLogin,
+  loginSessionKey,
+  cleanExpiredLogins,
+  type QrLoginSource,
+  type QrLoginSession,
+  type QrPollResult,
+} from './login/index.js';
 export type { MusicDetail, MusicInfo, MusicSource, MusicSourceConfig } from './types.js';

package/src/login/index.ts

@@ -0,0 +1,135 @@
+import type { QrLoginProvider, QrLoginSource, QrPollResult } from './types.js';
+import { QQLoginProvider } from './qq.js';
+import { NeteaseLoginProvider } from './netease.js';
+import { setCredential } from '../credential-store.js';
+
+export type { QrLoginSource, QrPollResult, QrLoginProvider } from './types.js';
+
+const providers: Record<QrLoginSource, QrLoginProvider> = {
+  qq: new QQLoginProvider(),
+  netease: new NeteaseLoginProvider(),
+};
+
+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);
+
+const activeLogins = new Map<string, QrLoginSession>();
+
+export function loginSessionKey(
+  endpointId: string,
+  conversationId: string,
+  senderId: string,
+): string {
+  return `login:${endpointId}:${conversationId}:${senderId}`;
+}
+
+export function getActiveLogin(key: string): QrLoginSession | undefined {
+  const session = activeLogins.get(key);
+  if (!session) return undefined;
+  if (Date.now() - session.timestamp > LOGIN_TIMEOUT_MS) {
+    activeLogins.delete(key);
+    return undefined;
+  }
+  return session;
+}
+
+export function cancelLogin(key: string): boolean {
+  const session = activeLogins.get(key);
+  if (!session) return false;
+  session.aborted = true;
+  activeLogins.delete(key);
+  return true;
+}
+
+export async function startLogin(
+  source: QrLoginSource,
+  key: string,
+): Promise<{ imageSegment: { type: 'image'; data: Record<string, unknown> } }> {
+  const existing = activeLogins.get(key);
+  if (existing && !existing.aborted) {
+    existing.aborted = true;
+  }
+
+  const provider = providers[source];
+  const result = await provider.createQr();
+
+  activeLogins.set(key, {
+    source,
+    pollData: result.pollData,
+    timestamp: Date.now(),
+    aborted: false,
+  });
+
+  return { imageSegment: result.imageSegment };
+}
+
+export async function pollLogin(
+  key: string,
+  onStatus: (result: QrPollResult) => Promise<void>,
+): Promise<QrPollResult> {
+  const session = activeLogins.get(key);
+  if (!session) {
+    return { status: 'error', message: '没有进行中的登录会话' };
+  }
+
+  const provider = providers[session.source];
+  let lastStatus = '';
+
+  try {
+    for (let i = 0; i < MAX_POLLS; i++) {
+      if (session.aborted) {
+        activeLogins.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') {
+        activeLogins.delete(key);
+        if (result.cookie) {
+          await setCredential(session.source, 'cookie', result.cookie);
+        }
+        return result;
+      }
+      if (result.status === 'expired' || result.status === 'error') {
+        activeLogins.delete(key);
+        return result;
+      }
+
+      await new Promise<void>((r) => setTimeout(r, POLL_INTERVAL_MS));
+    }
+  } catch (err) {
+    console.error('[music-login] poll error:', err);
+    activeLogins.delete(key);
+    return {
+      status: 'error',
+      message: `轮询异常：${err instanceof Error ? err.message : String(err)}`,
+    };
+  }
+
+  activeLogins.delete(key);
+  return { status: 'expired', message: '登录超时，请重试' };
+}
+
+export function cleanExpiredLogins(): void {
+  const now = Date.now();
+  for (const [key, session] of activeLogins) {
+    if (now - session.timestamp > LOGIN_TIMEOUT_MS) {
+      session.aborted = true;
+      activeLogins.delete(key);
+    }
+  }
+}

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

@@ -1,5 +1,6 @@
 import { musicServices } from './sources/index.js';
-import type { MusicInfo, MusicSource } from './types.js';
+import { sourceConfigMap, SOURCE_DISPLAY_NAME, formatDuration } from './config.js';
+import type { MusicInfo, MusicDetail, MusicSource } from './types.js';
 
 export async function searchMusic(
   keyword: string,
@@ -8,24 +9,19 @@ export async function searchMusic(
 ): Promise<{
   success: true;
   keyword: string;
-  results: Array<{ id: string; title: string; source: string; url: string }>;
+  source: MusicSource;
+  results: MusicInfo[];
   total: number;
 }> {
-  const searchSources: MusicSource[] = source ? [source] : ['qq', 'netease'];
-  const searchResults = await Promise.all(
-    searchSources.map((s) => musicServices[s].search(keyword, limit)),
-  );
-  const allMusic = searchResults.flat().filter(Boolean) as MusicInfo[];
+  const s: MusicSource = source ?? 'qq';
+  const service = musicServices[s];
+  const results = await service.search(keyword, limit);
   return {
     success: true,
     keyword,
-    results: allMusic.map((m) => ({
-      id: m.id,
-      title: m.title,
-      source: m.source,
-      url: m.url,
-    })),
-    total: allMusic.length,
+    source: s,
+    results,
+    total: results.length,
   };
 }
 
@@ -36,18 +32,7 @@ export async function shareMusicDetail(id: string, source: MusicSource) {
   }
   try {
     const detail = await service.getDetail(id);
-    return {
-      success: true as const,
-      music: {
-        id: detail.id,
-        title: detail.title,
-        source: detail.source,
-        url: detail.url,
-        image: detail.image,
-        audio: detail.audio,
-        duration: detail.duration,
-      },
-    };
+    return { success: true as const, music: detail };
   } catch (error) {
     return {
       success: false as const,
@@ -55,3 +40,31 @@ export async function shareMusicDetail(id: string, source: MusicSource) {
     };
   }
 }
+
+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,
+    },
+  };
+}