@zhin.js/plugin-music 1.1.0 → 1.1.3

package/src/credential-store.ts

@@ -1,8 +1,3 @@
-import {
-  createGenerationStore,
-  type Dispose,
-  type GenerationStoreContext,
-} from 'zhin.js';
 import type { MusicSource } from './types.js';
 
 export const MUSIC_CREDENTIALS_TABLE = 'music_credentials';
@@ -75,95 +70,56 @@ function createMemoryModel(): CredentialModel {
   };
 }
 
-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;
+export function createInMemoryCredentialDb(): CredentialDb {
+  const model = createMemoryModel();
+  return {
+    models: {
+      get: (name) => name === MUSIC_CREDENTIALS_TABLE ? model : undefined,
+    },
+  };
 }
 
-const memoryModel = createMemoryModel();
+export class CredentialStore {
+  readonly #db: CredentialDb;
 
-function getModel(): CredentialModel | null {
-  return getDb().models.get(MUSIC_CREDENTIALS_TABLE) ?? null;
-}
+  constructor(db: CredentialDb) {
+    this.#db = db;
+  }
 
-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 ?? '');
-}
+  private get model(): CredentialModel | null {
+    return this.#db.models.get(MUSIC_CREDENTIALS_TABLE) ?? null;
+  }
 
-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(),
-    });
+  async get(source: MusicSource, key: string): Promise<string | null> {
+    const rows = await this.model?.select().where({ source, key });
+    if (!rows?.length) return null;
+    return String(rows[0]!.value ?? '');
   }
-}
 
-export async function deleteCredential(
-  source: MusicSource,
-  key: string,
-): Promise<void> {
-  const model = getModel();
-  if (!model) return;
-  await model.delete().where({ source, key });
-}
+  async set(source: MusicSource, key: string, value: string): Promise<void> {
+    const model = this.model;
+    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 });
+      return;
+    }
+    await model.insert({ source, key, value, updated_at: new Date().toISOString() });
+  }
 
-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 ?? ''),
-  }));
-}
+  async delete(source: MusicSource, key: string): Promise<void> {
+    await this.model?.delete().where({ source, key });
+  }
 
-export function resetCredentialDb(): void {
-  credentialDbStore.clear();
-  _memoryDb = null;
+  async list(source?: MusicSource): Promise<CredentialRow[]> {
+    const model = this.model;
+    if (!model) return [];
+    const rows = source ? await model.select().where({ source }) : await model.select();
+    return rows.map((row) => ({
+      source: String(row.source) as MusicSource,
+      key: String(row.key),
+      value: String(row.value),
+      updated_at: String(row.updated_at ?? ''),
+    }));
+  }
 }

package/src/index.ts

@@ -12,32 +12,24 @@ export {
   formatSearchResults,
   buildMusicShareSegment,
 } from './music-lib.js';
-export { musicServices } from './sources/index.js';
+export { createMusicServices } from './sources/index.js';
 export {
   sessionKey,
   resolveMessageIds,
-  setPending,
-  getPending,
-  clearPending,
-  cleanExpired,
+  MusicSearchSessions,
   type PendingSearch,
 } from './session.js';
 export {
-  getCredential,
-  setCredential,
-  deleteCredential,
-  listCredentials,
+  CredentialStore,
+  createInMemoryCredentialDb,
   MUSIC_CREDENTIALS_TABLE,
-  provideCredentialDb,
-  resetCredentialDb,
+  type CredentialDb,
+  type CredentialRow,
 } from './credential-store.js';
+export { musicRuntimeToken, type MusicRuntime } from './runtime.js';
 export {
-  startLogin,
-  pollLogin,
-  cancelLogin,
-  getActiveLogin,
+  QrLoginRuntime,
   loginSessionKey,
-  cleanExpiredLogins,
   type QrLoginSource,
   type QrLoginSession,
   type QrPollResult,

package/src/login/index.ts

@@ -1,15 +1,10 @@
 import type { QrLoginProvider, QrLoginSource, QrPollResult } from './types.js';
 import { QQLoginProvider } from './qq.js';
 import { NeteaseLoginProvider } from './netease.js';
-import { setCredential } from '../credential-store.js';
+import type { CredentialStore } 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>;
@@ -21,8 +16,6 @@ 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,
@@ -31,105 +24,131 @@ export function loginSessionKey(
   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;
+/** 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(),
+    };
   }
-  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;
+  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;
   }
 
-  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: '没有进行中的登录会话' };
+  cancel(key: string): boolean {
+    const session = this.#active.get(key);
+    if (!session) return false;
+    session.aborted = true;
+    this.#active.delete(key);
+    return true;
   }
 
-  const provider = providers[session.source];
-  let lastStatus = '';
+  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 {
-    for (let i = 0; i < MAX_POLLS; i++) {
-      if (session.aborted) {
-        activeLogins.delete(key);
-        return { status: 'error', message: '登录已取消' };
+    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;
+    }
+  }
 
-      const result = await provider.pollQr(session.pollData);
-
-      if (result.status !== lastStatus) {
-        lastStatus = result.status;
-        await onStatus(result);
-      }
+  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: '登录已取消' };
+        }
 
-      if (result.status === 'confirmed') {
-        activeLogins.delete(key);
-        if (result.cookie) {
-          await setCredential(session.source, 'cookie', result.cookie);
+        const result = await provider.pollQr(session.pollData);
+        if (result.status !== lastStatus) {
+          lastStatus = result.status;
+          await onStatus(result);
         }
-        return result;
-      }
-      if (result.status === 'expired' || result.status === 'error') {
-        activeLogins.delete(key);
-        return 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);
       }
-
-      await new Promise<void>((r) => setTimeout(r, POLL_INTERVAL_MS));
+    } catch (error) {
+      this.#active.delete(key);
+      return {
+        status: 'error',
+        message: `轮询异常：${error instanceof Error ? error.message : String(error)}`,
+      };
     }
-  } 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: '登录超时，请重试' };
-}
+    this.#active.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);
+  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/music-lib.ts

@@ -1,8 +1,9 @@
-import { musicServices } from './sources/index.js';
 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,
@@ -14,7 +15,7 @@ export async function searchMusic(
   total: number;
 }> {
   const s: MusicSource = source ?? 'qq';
-  const service = musicServices[s];
+  const service = runtime.services[s];
   const results = await service.search(keyword, limit);
   return {
     success: true,
@@ -25,8 +26,8 @@ export async function searchMusic(
   };
 }
 
-export async function shareMusicDetail(id: string, source: MusicSource) {
-  const service = musicServices[source];
+export async function shareMusicDetail(runtime: MusicRuntime, id: string, source: MusicSource) {
+  const service = runtime.services[source];
   if (!service) {
     return { success: false as const, error: `不支持的音乐源: ${source}` };
   }

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

@@ -9,8 +9,6 @@ export interface PendingSearch {
 
 const SEARCH_TIMEOUT_MS = 3 * 60 * 1000;
 
-const pendingSessions = new Map<string, PendingSearch>();
-
 export function sessionKey(
   endpointId: string,
   conversationId: string,
@@ -32,29 +30,48 @@ export function resolveMessageIds(input: {
   return { endpointId, conversationId, senderId };
 }
 
-export function setPending(key: string, search: PendingSearch): void {
-  pendingSessions.set(key, search);
-}
+/** Generation-owned pending music selections. */
+export class MusicSearchSessions {
+  readonly #pending = new Map<string, PendingSearch>();
+  readonly #timeoutMs: number;
+  readonly #now: () => number;
 
-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;
+  constructor(
+    timeoutMs = SEARCH_TIMEOUT_MS,
+    now: () => number = Date.now,
+  ) {
+    this.#timeoutMs = timeoutMs;
+    this.#now = now;
   }
-  return session;
-}
 
-export function clearPending(key: string): void {
-  pendingSessions.delete(key);
-}
+  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);
+  }
 
-export function cleanExpired(): void {
-  const now = Date.now();
-  for (const [key, session] of pendingSessions) {
-    if (now - session.timestamp > SEARCH_TIMEOUT_MS) {
-      pendingSessions.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

@@ -3,13 +3,16 @@ 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(),
-  kuwo: new KuwoMusicService(),
-  kugou: new KugouMusicService(),
-};
+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';

package/src/sources/kugou.ts

@@ -9,6 +9,20 @@ interface KugouSearchItem {
   album_id?: string;
 }
 
+function stripHtmlTags(input: string): string {
+  let result = '';
+  let cursor = 0;
+  while (cursor < input.length) {
+    const start = input.indexOf('<', cursor);
+    if (start < 0) return result + input.slice(cursor);
+    result += input.slice(cursor, start);
+    const end = input.indexOf('>', start + 1);
+    if (end < 0) return result + input.slice(start);
+    cursor = end + 1;
+  }
+  return result;
+}
+
 export class KugouMusicService implements MusicSearchService {
   async search(keyword: string, limit = 10): Promise<MusicInfo[]> {
     try {
@@ -28,7 +42,7 @@ export class KugouMusicService implements MusicSearchService {
       return items.slice(0, limit).map((item) => ({
         id: item.hash,
         source: 'kugou' as const,
-        title: item.songname?.replace(/<[^>]+>/g, '') ?? '',
+        title: stripHtmlTags(item.songname ?? ''),
         artist: item.singername,
         album: item.album_name,
         duration: item.duration,

package/src/sources/netease.ts

@@ -1,9 +1,15 @@
 // plugins/utils/music/src/sources/netease.ts
 import type { MusicSearchService, MusicDetail, MusicInfo, Music163 } from '../types.js';
-import { getCredential } from '../credential-store.js';
+import type { CredentialStore } from '../credential-store.js';
 
 /** 网易云音乐搜索服务 */
 export class NeteaseMusicService implements MusicSearchService {
+  readonly #credentials: CredentialStore;
+
+  constructor(credentials: CredentialStore) {
+    this.#credentials = credentials;
+  }
+
   async search(keyword: string, limit = 10): Promise<MusicInfo[]> {
     try {
       const searchUrl = `http://music.163.com/api/search/get/web?csrf_token=hlpretag=&hlposttag=&s=${encodeURIComponent(keyword)}&type=1&offset=0&total=true&limit=${limit}`
@@ -72,7 +78,7 @@ export class NeteaseMusicService implements MusicSearchService {
    * @returns 音频直链 URL
    */
   async getAudioUrl(id: string): Promise<string> {
-    const cookie = await getCredential('netease', 'cookie');
+    const cookie = await this.#credentials.get('netease', 'cookie');
     if (cookie) {
       try {
         const response = await fetch(

package/src/sources/qq.ts

@@ -1,6 +1,6 @@
 import * as crypto from 'node:crypto';
 import type { MusicSearchService, MusicDetail, MusicInfo } from '../types.js';
-import { getCredential } from '../credential-store.js';
+import type { CredentialStore } from '../credential-store.js';
 
 const md5 = (text: string) => crypto.createHash('md5').update(text).digest('hex');
 
@@ -15,9 +15,15 @@ function getHeaders(cookie?: string | null) {
 }
 
 export class QQMusicService implements MusicSearchService {
+  readonly #credentials: CredentialStore;
+
+  constructor(credentials: CredentialStore) {
+    this.#credentials = credentials;
+  }
+
   async search(keyword: string, limit = 10): Promise<MusicInfo[]> {
     try {
-      const cookie = await getCredential('qq', 'cookie');
+      const cookie = await this.#credentials.get('qq', 'cookie');
       const response = await fetch(MUSICU_API, {
         method: 'POST',
         headers: getHeaders(cookie),
@@ -108,7 +114,7 @@ export class QQMusicService implements MusicSearchService {
   }
 
   async getAudioUrl(id: string, mid?: string, mediaMid?: string): Promise<string> {
-    const cookie = await getCredential('qq', 'cookie');
+    const cookie = await this.#credentials.get('qq', 'cookie');
     if (cookie) {
       try {
         const uin = /uin=o?(\d+)/.exec(cookie)?.[1] ?? '0';