@doitian/dsh-music 0.1.2 → 0.1.5

package/lib/index.js

@@ -22,6 +22,7 @@ import { Netease } from './netease.js';
 import { QrLogin, SessionStore, ANONYMOUS_COOKIE } from './session.js';
 import { Player } from './state.js';
 import { AiDj } from './dj.js';
+import { LikeState } from './likes.js';
 import { MusicRouter } from './router.js';
 
 export const name = 'music';
@@ -129,6 +130,9 @@ export function apply(ctx, config = {}) {
 
   const qr = new QrLogin({ api, store, logger });
 
+  // The account owns its likes; this is the cache the panel's hearts read.
+  const likes = new LikeState({ api, logger });
+
   /**
    * The LLM service is optional: the DJ falls back to its heuristic tier when
    * absent, so the plugin still works in a composition without a model route.
@@ -183,6 +187,14 @@ export function apply(ctx, config = {}) {
     },
   });
   player.onLowQueue = () => dj.topUp();
+  player.onSkip = (track) => {
+    // The panel's ✕ records the dislike and then presses next, so an early
+    // dislike would also count as a skip — but only inside the skip window,
+    // which would make the same judgement weigh differently by when it came.
+    if (store.taste(track.id) === 'disliked') return;
+    store.recordSkip(track.id);
+    logger.debug(`[music] skip recorded for ${track.id}`);
+  };
 
   /** Tool names that registered successfully; surfaced by `/music/health`. */
   const registeredTools = [];
@@ -190,10 +202,24 @@ export function apply(ctx, config = {}) {
   // ------------------------------------------------------------ session boot
   void api
     .fetchAccount()
-    .then((account) => {
+    .then(async (account) => {
       if (account) logger.info(`[music] signed in as ${account.nickname}`);
       else if (api.authenticated) logger.warn('[music] session cookie present but the account check failed');
       else logger.info('[music] anonymous session (search and non-VIP playback only)');
+
+      // The account holds the likes; the local list is a copy the DJ reads.
+      // Reconciling it here keeps that copy honest across a like made on the
+      // phone, and migrates a list an earlier build recorded locally because it
+      // had no endpoint to send it to.
+      try {
+        const likedIds = await api.likedPlaylistIds(account?.uid);
+        if (likedIds) {
+          store.setLikedIds(likedIds);
+          logger.debug(`[music] like mirror reconciled with the account (${likedIds.length} track(s))`);
+        }
+      } catch (error) {
+        logger.warn(`[music] could not read the account's likes: ${error.message}`);
+      }
     })
     .catch((error) => logger.warn(`[music] account check failed: ${error.message}`));
 
@@ -223,6 +249,7 @@ export function apply(ctx, config = {}) {
     store,
     qr,
     dj,
+    likes,
     panelHtml: PANEL_HTML,
     qrcodeJs: QRCODE_JS,
     config,
@@ -252,6 +279,8 @@ export function apply(ctx, config = {}) {
         lastPlanAt: player.dj.lastPlanAt,
         error: player.dj.error,
       },
+      /** How much of the account's like state is cached, and why it is not. */
+      likes: likes.status(),
       dataDir,
       session: { authenticated: api.authenticated, nickname: api.account?.nickname ?? null, vip: Boolean(api.account?.vip) },
       uptimeMs: Math.round(process.uptime() * 1000),
@@ -482,8 +511,8 @@ export function apply(ctx, config = {}) {
       title: 'AI DJ (NetEase Cloud Music)',
       description:
         'Run or configure the continuous AI DJ for the user\'s NetEase Cloud Music panel. ' +
-        'With `enabled: true` the DJ keeps the queue stocked: it gathers candidates from similar songs, the daily ' +
-        'recommendations, the charts and any mood brief, then either asks the model to choose or scores them by the ' +
+        'With `enabled: true` the DJ keeps the queue stocked: it gathers candidates from similar songs, personal FM, ' +
+        'liked songs not heard lately, the daily recommendations, the charts and any mood brief, then either asks the model to choose or scores them by the ' +
         'listener\'s liked artists, novelty and feedback. Pass `prompt` for a mood or vibe, and `replan` to refill now.',
       parameters: {
         type: 'object',
@@ -492,7 +521,10 @@ export function apply(ctx, config = {}) {
           enabled: { type: 'boolean', description: 'Turn continuous queue topping-up on or off.' },
           prompt: { type: 'string', description: 'Mood or request, e.g. "rainy afternoon jazz", "90s cantopop".' },
           replan: { type: 'boolean', description: 'Plan and queue a fresh batch immediately.' },
-          count: { type: 'integer', description: 'How many tracks to plan (1-25, default 8 for `replan`).' },
+          count: {
+            type: 'integer',
+            description: 'How many tracks to plan (1-25; default 8 for `start`, the player\'s batch size for `replan`).',
+          },
           start: { type: 'boolean', description: 'Replace the queue with a freshly planned batch (a full DJ session).' },
         },
       },
@@ -503,6 +535,7 @@ export function apply(ctx, config = {}) {
             `AI DJ is ${value.enabled ? 'on' : 'off'} (${value.source}${value.route ? ` via ${value.route}` : ''}). ` +
             (value.modelError ? `Model tier unavailable: ${value.modelError}. ` : '') +
             (value.vibe ? `Vibe: ${value.vibe}. ` : '') +
+            (value.searchedAs.length ? `Brief searched as: ${value.searchedAs.join('; ')}. ` : '') +
             (value.names.length
               ? `Queued ${value.added} track(s):\n${value.names.map((entry, index) => `${index + 1}. ${entry}`).join('\n')}`
               : value.note || 'No new tracks were queued.') +
@@ -519,7 +552,7 @@ export function apply(ctx, config = {}) {
         if (args.start) {
           plan = await dj.start({ prompt, count });
         } else if (args.replan || (enabled === true && player.queue.length === 0)) {
-          plan = await dj.topUp({ force: true });
+          plan = await dj.topUp({ force: true, count: args.count === undefined ? undefined : count });
         }
 
         const summary = player.summary();
@@ -529,6 +562,7 @@ export function apply(ctx, config = {}) {
           route: plan?.route ?? summary.dj.lastPlan?.route ?? null,
           modelError: player.dj.modelError ?? null,
           vibe: plan?.vibe ?? summary.dj.lastPlan?.vibe ?? '',
+          searchedAs: plan?.searchedAs ?? summary.dj.lastPlan?.searchedAs ?? [],
           note: plan?.note ?? (plan && plan.tracks.length === 0 ? 'no candidates were available' : ''),
           added: plan?.tracks.length ?? 0,
           names: (plan?.tracks ?? []).map((track) => `${track.name} — ${(track.artists ?? []).join('/')}`),

package/lib/likes.js

@@ -0,0 +1,169 @@
+/**
+ * NetEase's like state for the tracks the panel is showing.
+ *
+ * A like lives in the account, not in this plugin: `/api/song/like/check` is
+ * where the truth is, and this class is the cache in front of it. Four
+ * properties are deliberate:
+ *
+ *   - **Unknown is not "not liked".** A track nobody has asked about has no
+ *     answer; `isLiked` reads false for it, and `known` says which of the two
+ *     it is. The panel renders a hollow heart either way, so the difference
+ *     only matters to a caller that is about to write.
+ *   - **A refusal is not an answer.** An anonymous session answers `code: 301`
+ *     for every id. Caching that as "not liked" would leave every heart empty
+ *     for the rest of the session, so a refused check caches nothing and is
+ *     retried after a cool-off instead.
+ *   - **A write is authoritative.** `set()` writes through to NetEase and then
+ *     updates the cache, so the panel's next poll does not need a round trip to
+ *     see the change it just made. It never claims a like the account does not
+ *     have: a refused write leaves the cache untouched.
+ *   - **Nothing here is persisted.** The account is the storage; a restart
+ *     re-reads it, and a different account must not inherit the last one's
+ *     answers, which is what `clear()` is for.
+ *
+ * @module dsh-music/likes
+ */
+
+/** How long one answer is trusted before it is asked again. */
+const DEFAULT_TTL_MS = 5 * 60 * 1000;
+
+/** Ids per `/api/song/like/check` request; it takes a list, but not a URL. */
+const CHECK_BATCH = 100;
+
+/** How long a refused or failed check waits before trying again. */
+const RETRY_AFTER_MS = 30_000;
+
+export class LikeState {
+  /**
+   * @param {object} options
+   * @param {import('./netease.js').Netease} options.api
+   * @param {{warn: Function, info: Function, debug: Function}} [options.logger]
+   * @param {number} [options.ttlMs] how long one answer stays fresh.
+   * @param {number} [options.batchSize] ids per check request.
+   */
+  constructor({ api, logger, ttlMs = DEFAULT_TTL_MS, batchSize = CHECK_BATCH } = {}) {
+    this.api = api;
+    this.logger = logger;
+    this.ttlMs = ttlMs;
+    this.batchSize = batchSize;
+    /** @type {Map<number, {liked: boolean, at: number}>} */
+    this.answers = new Map();
+    /** @type {Map<number, Promise<void>>} in-flight checks, so polls share one. */
+    this.pending = new Map();
+    /** Earliest time a refused check may be attempted again. */
+    this.retryAt = 0;
+    /** Why the last check did not produce answers, for `/music/health`. */
+    this.error = null;
+  }
+
+  /** The cached answer; false when there is none. See {@link known}. */
+  isLiked(id) {
+    return this.answers.get(Number(id))?.liked === true;
+  }
+
+  /** Whether a fresh answer for this track is cached — either way. */
+  known(id) {
+    const entry = this.answers.get(Number(id));
+    return Boolean(entry) && Date.now() - entry.at < this.ttlMs;
+  }
+
+  /** Forget every answer. A session change invalidates all of them. */
+  clear() {
+    this.answers.clear();
+    this.pending.clear();
+    this.retryAt = 0;
+    this.error = null;
+    return this;
+  }
+
+  /**
+   * Resolve the like state of `ids`, asking NetEase only about the tracks with
+   * no fresh answer. Never throws: a like check must not fail a poll, and an
+   * unresolved id simply stays unknown.
+   */
+  async ensure(ids) {
+    // Nothing can be liked on an anonymous session, so there is nothing to ask.
+    if (!this.api?.authenticated) return;
+    const list = [...new Set([...ids].map(Number).filter(Number.isFinite))];
+    const stale = list.filter((id) => !this.known(id) && !this.pending.has(id));
+    if (stale.length === 0) return;
+    if (Date.now() < this.retryAt) return;
+
+    const work = this.#load(stale).finally(() => {
+      for (const id of stale) this.pending.delete(id);
+    });
+    for (const id of stale) this.pending.set(id, work);
+    await work;
+  }
+
+  /** Ask for `ids` in batches and cache every answer in them. */
+  async #load(ids) {
+    for (let offset = 0; offset < ids.length; offset += this.batchSize) {
+      const chunk = ids.slice(offset, offset + this.batchSize);
+      let result;
+      try {
+        result = await this.api.likedIds(chunk);
+      } catch (error) {
+        this.#coolOff(`like check failed: ${error.message}`);
+        return;
+      }
+      if (!result.ok) {
+        // Not an answer: cache nothing, so signing in or a retry can still
+        // resolve these tracks rather than freezing them as unliked.
+        this.#coolOff(`like check refused (code ${result.code}): ${result.reason}`);
+        return;
+      }
+      const liked = new Set(result.ids);
+      const at = Date.now();
+      for (const id of chunk) this.answers.set(id, { liked: liked.has(id), at });
+      this.error = null;
+    }
+  }
+
+  #coolOff(reason) {
+    this.retryAt = Date.now() + RETRY_AFTER_MS;
+    this.error = reason;
+    this.logger?.debug?.(`[music] ${reason}`);
+  }
+
+  /**
+   * Like or un-like one track on NetEase.
+   *
+   * The account is written first and the cache only follows a confirmed change,
+   * so the panel can never show a heart the account would contradict.
+   *
+   * @param {number|string} trackId
+   * @param {boolean} liked
+   * @returns {Promise<{ok: boolean, id: number, liked?: boolean, code?: number|string, reason?: string}>}
+   */
+  async set(trackId, liked) {
+    const id = Number(trackId);
+    if (!Number.isFinite(id)) {
+      return { ok: false, id: trackId, code: 'BAD_ID', reason: `invalid track id "${trackId}"` };
+    }
+    if (!this.api?.authenticated) {
+      return { ok: false, id, code: 'ANONYMOUS', reason: 'the NetEase session is anonymous' };
+    }
+    let result;
+    try {
+      result = await this.api.likeSong(id, liked);
+    } catch (error) {
+      return { ok: false, id, code: 'NETWORK', reason: error.message };
+    }
+    if (!result.ok) return result;
+    this.answers.set(id, { liked: Boolean(liked), at: Date.now() });
+    this.error = null;
+    return result;
+  }
+
+  /** What the cache holds, for `/music/health`. */
+  status() {
+    return {
+      cached: this.answers.size,
+      pending: this.pending.size,
+      error: this.error,
+    };
+  }
+}
+
+export { CHECK_BATCH, DEFAULT_TTL_MS, RETRY_AFTER_MS };

package/lib/netease.js

@@ -14,6 +14,8 @@
  *   - `api/toplist`                   anonymous OK
  *   - `api/discovery/simiSong`        anonymous OK
  *   - `api/personalized/newsong`      anonymous OK
+ *   - `api/song/like`                 POST: like / un-like, needs a session
+ *   - `api/song/like/check`           which of these ids the account liked
  *   - `api/login/qrcode/*`            QR login handshake
  *
  * @module dsh-music/netease
@@ -370,6 +372,21 @@ export class Netease {
     return data?.result ?? {};
   }
 
+  /**
+   * Playlists matching a keyword. Listeners name and tag playlists by mood
+   * (雨天, 爵士, 深夜…), so this is how a mood finds music, where a song search
+   * only matches titles and lyrics.
+   */
+  async searchPlaylists(keyword, { limit = 10 } = {}) {
+    const result = await this.search(keyword, { type: 1000, limit });
+    return (result.playlists ?? []).map((item) => ({
+      id: item.id,
+      name: item.name,
+      trackCount: item.trackCount ?? 0,
+      playCount: item.playCount ?? 0,
+    }));
+  }
+
   /** Track metadata, including cover art and the VIP fee code. */
   async songDetail(ids) {
     const list = [...ids].map(Number).filter(Number.isFinite);
@@ -474,6 +491,12 @@ export class Netease {
       playCount: playlist.playCount ?? 0,
       creator: playlist.creator?.nickname ?? '',
       tracks: normalizeTracks(playlist.tracks),
+      /**
+       * Every track id, in order. For a playlist the account does not own,
+       * `tracks` stops at the first 20 while this list is complete, so it is
+       * the only way to reach the rest.
+       */
+      trackIds: (playlist.trackIds ?? []).map((entry) => entry.id).filter(Number.isFinite),
     };
   }
 
@@ -522,6 +545,18 @@ export class Netease {
     return normalizeTracks(result?.dailySongs ?? result?.recommend);
   }
 
+  /**
+   * 私人FM (personal FM): a few tracks NetEase picks for this account, a
+   * different few on every call. Requires a session.
+   *
+   * This is the personalised feed the plain API still serves; heartbeat mode
+   * ({@link intelligenceList}) answers `code 500` there for every seed.
+   */
+  async personalFm() {
+    const data = await this.call('/api/v1/radio/get');
+    return normalizeTracks(data?.data);
+  }
+
   /**
    * 心动模式 (heartbeat mode): a personalised continuation of a seed track
    * inside a playlist context. Requires a session.
@@ -544,6 +579,78 @@ export class Netease {
     return normalizeTracks(data?.data);
   }
 
+  // ------------------------------------------------------------------ likes
+
+  /**
+   * Like or un-like one track on the account.
+   *
+   * `/api/song/like` is one of the few *write* endpoints the plain web API
+   * still serves unencrypted — it answers `{playlistId, code: 200}` and puts the
+   * track in (or takes it out of) the account's 我喜欢的音乐 playlist. It takes
+   * the direction rather than toggling, so the caller must know which one it
+   * means; ask {@link likedIds} when it does not.
+   *
+   * A refusal is reported, not thrown: an anonymous session answers `code: 301`
+   * and a delisted track answers `code: 400` with NetEase's own reason
+   * ("歌曲已经下架了"), and both are ordinary outcomes of a click. Only a
+   * transport failure throws.
+   *
+   * @param {number|string} id track id.
+   * @param {boolean} like `true` to like, `false` to remove the like.
+   */
+  async likeSong(id, like = true) {
+    const trackId = Number(id);
+    if (!Number.isFinite(trackId)) {
+      return { ok: false, id, code: 'BAD_ID', reason: `invalid track id "${id}"` };
+    }
+    const data = await this.call('/api/song/like', {
+      method: 'POST',
+      query: { trackId, like: Boolean(like) },
+    });
+    if (Number(data?.code) !== 200) {
+      return {
+        ok: false,
+        id: trackId,
+        code: data?.code ?? 'UNKNOWN',
+        reason:
+          data?.message ||
+          data?.msg ||
+          (this.authenticated ? 'NetEase refused the change' : 'sign in to NetEase first'),
+      };
+    }
+    return { ok: true, id: trackId, liked: Boolean(like), playlistId: data?.playlistId ?? null };
+  }
+
+  /**
+   * Which of these tracks the account has liked.
+   *
+   * `/api/song/like/check` answers `{ids: [...the liked subset...]}`, so one
+   * request covers a whole queue. An anonymous session answers `code: 301` for
+   * every id — a refusal, not "nothing is liked" — and comes back as
+   * `ok: false` so a caller never caches it as an answer.
+   *
+   * @param {Iterable<number|string>} ids
+   * @returns {Promise<{ok: boolean, ids: number[], code?: number|string, reason?: string}>}
+   */
+  async likedIds(ids) {
+    const list = [...new Set([...ids].map(Number).filter(Number.isFinite))];
+    // NetEase answers an empty batch with `code: 400`, and an empty question has
+    // no answer to fetch anyway.
+    if (list.length === 0) return { ok: true, ids: [] };
+    const data = await this.call('/api/song/like/check', {
+      query: { trackIds: JSON.stringify(list) },
+    });
+    if (Number(data?.code) !== 200 || !Array.isArray(data?.ids)) {
+      return {
+        ok: false,
+        ids: [],
+        code: data?.code ?? 'UNKNOWN',
+        reason: data?.message || data?.msg || 'NetEase refused the like check',
+      };
+    }
+    return { ok: true, ids: data.ids.map(Number) };
+  }
+
   // -------------------------------------------------------------- account
 
   /** Account summary; `null` when the session is anonymous or expired. */
@@ -577,9 +684,32 @@ export class Netease {
       cover: resizeImage(item.coverImgUrl, 300),
       trackCount: item.trackCount ?? 0,
       subscribed: Boolean(item.subscribed),
+      /** `5` marks 我喜欢的音乐 — the account's likes, as a playlist. */
+      specialType: item.specialType ?? 0,
     }));
   }
 
+  /**
+   * Every track id in the account's 我喜欢的音乐 playlist, or `null` when there
+   * is no account or no such playlist.
+   *
+   * This is the whole like state in one read, which is what makes it useful for
+   * reconciling a local mirror; use {@link likedIds} to ask about specific
+   * tracks. The playlist's length is not capped by `n` — NetEase returns the
+   * complete `trackIds` list — so one request covers a library of any size.
+   *
+   * @param {number|string} [uid] owner; defaults to the fetched account.
+   */
+  async likedPlaylistIds(uid) {
+    const owner = Number(uid ?? this.account?.uid);
+    if (!Number.isFinite(owner)) return null;
+    const playlists = await this.userPlaylists(owner, { limit: 1000 });
+    const liked = playlists.find((playlist) => playlist.specialType === 5);
+    if (!liked) return null;
+    const detail = await this.call('/api/v6/playlist/detail', { query: { id: liked.id, n: 1 } });
+    return (detail?.playlist?.trackIds ?? []).map((entry) => entry.id).filter(Number.isFinite);
+  }
+
   // ------------------------------------------------------------ QR login
 
   /**