feat(bot): last.fm duration fix, normalizers, and top tracks seeds

CHANGELOG.md

@@ -11,10 +11,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Dashboard sidebar redesigned as a guild command center: persistent guild block at top (avatar, name, Management Console subtitle, switch-server action), navigation reorganized into 6 operational groups (Overview / Moderation / Automation / Community / Media / Integrations), sharper active-item indicator, and collapsible mobile drawer with spring animation. (#379)
 - Autoplay recommendation engine now emits `session novelty` reason tag (+0.15 score boost) for candidates whose artist has not appeared anywhere in the current session, and `similar energy` reason tag (+0.10) for tracks within ±30% duration of the current track. (#380)
+- Last.fm top tracks are now used as additional autoplay seeds: when a user has a linked Last.fm account, their 3-month top 20 tracks are fetched, cached for 1 hour, and randomly sampled to discover taste-aware candidates with a `last.fm taste` reason tag. (#382)
+- Last.fm artist and title normalizers strip YouTube `- Topic` suffix, split multi-artist strings to keep only the primary, and remove `(Official Video)`, `(Official Audio)`, `(feat. X)`, and similar noise patterns before scrobbling. (#382)
 
 ### Fixed
 
 - Guild automation API endpoints (`/manifest`, `/status`, `/capture`, `/plan`, `/apply`, `/reconcile`, `/cutover`, `/presets/criativaria/apply`) now require `settings` module access via RBAC instead of bare session authentication, closing a privilege escalation path. (#381)
+- Last.fm scrobble and nowPlaying duration was always NaN because `track.duration` in discord-player 7 is a formatted string (`"3:45"`), not a number. Fixed to use `track.durationMS / 1000`. (#382)
 
 ## [2.6.40] - 2026-03-30
 

packages/bot/src/handlers/player/trackNowPlaying.ts

@@ -153,9 +153,7 @@ export async function updateLastFmNowPlaying(
     const sessionKey = await getSessionKeyForUser(requesterId)
     if (!sessionKey) return
     const durationSec =
-        typeof track.duration === 'number'
-            ? Math.round(track.duration / 1000)
-            : undefined
+        track.durationMS > 0 ? Math.round(track.durationMS / 1000) : undefined
     try {
         await lastFmUpdateNowPlaying(
             track.author,
@@ -182,8 +180,8 @@ export async function scrobbleCurrentTrackIfLastFm(
     lastFmTrackStartTime.delete(queue.guild.id)
     const timestamp = startedAt ?? Math.floor(Date.now() / 1000)
     const durationSec =
-        typeof trackToScrobble.duration === 'number'
-            ? Math.round(trackToScrobble.duration / 1000)
+        trackToScrobble.durationMS > 0
+            ? Math.round(trackToScrobble.durationMS / 1000)
             : undefined
     try {
         await lastFmScrobble(

packages/bot/src/lastfm/index.ts

@@ -1,6 +1,10 @@
 export {
     isLastFmConfigured,
     getSessionKeyForUser,
+    getTopTracks,
+    normalizeLastFmArtist,
+    normalizeLastFmTitle,
     updateNowPlaying,
     scrobble,
 } from './lastFmApi'
+export type { LastFmTopTrack, LastFmPeriod } from './lastFmApi'

packages/bot/src/lastfm/lastFmApi.spec.ts

@@ -1,5 +1,18 @@
-import { afterEach, beforeEach, describe, expect, it, jest } from '@jest/globals'
-import { getSessionKeyForUser, updateNowPlaying } from './lastFmApi'
+import {
+    afterEach,
+    beforeEach,
+    describe,
+    expect,
+    it,
+    jest,
+} from '@jest/globals'
+import {
+    getSessionKeyForUser,
+    updateNowPlaying,
+    normalizeLastFmArtist,
+    normalizeLastFmTitle,
+    getTopTracks,
+} from './lastFmApi'
 
 const getSessionKeyMock = jest.fn()
 const fetchMock = jest.fn()
@@ -50,11 +63,118 @@ describe('lastFmApi', () => {
     it('sends signed updateNowPlaying payload', async () => {
         await updateNowPlaying('Artist Name', 'Track Name', 187, 'session-123')
 
-        const [, request] = fetchMock.mock.calls.at(-1) as [string, { body: string }]
+        const [, request] = fetchMock.mock.calls.at(-1) as [
+            string,
+            { body: string },
+        ]
         expect(request.body).toContain('method=track.updateNowPlaying')
         expect(request.body).toContain('artist=Artist+Name')
         expect(request.body).toContain('track=Track+Name')
         expect(request.body).toContain('duration=187')
         expect(request.body).toContain('api_sig=')
     })
+
+    describe('normalizeLastFmArtist', () => {
+        it('strips " - Topic" suffix', () => {
+            expect(normalizeLastFmArtist('Doja Cat - Topic')).toBe('Doja Cat')
+        })
+
+        it('takes first artist when multiple are separated by comma', () => {
+            expect(normalizeLastFmArtist('Artist A, Artist B')).toBe('Artist A')
+        })
+
+        it('takes first artist when separated by slash', () => {
+            expect(normalizeLastFmArtist('Artist A / Artist B')).toBe(
+                'Artist A',
+            )
+        })
+
+        it('returns unchanged when no separators', () => {
+            expect(normalizeLastFmArtist('Kendrick Lamar')).toBe(
+                'Kendrick Lamar',
+            )
+        })
+    })
+
+    describe('normalizeLastFmTitle', () => {
+        it('removes (Official Video) suffix', () => {
+            expect(normalizeLastFmTitle('Track Name (Official Video)')).toBe(
+                'Track Name',
+            )
+        })
+
+        it('removes [Official Music Video] suffix', () => {
+            expect(
+                normalizeLastFmTitle('Track Name [Official Music Video]'),
+            ).toBe('Track Name')
+        })
+
+        it('removes feat. clause', () => {
+            expect(
+                normalizeLastFmTitle('Track Name (feat. Other Artist)'),
+            ).toBe('Track Name')
+        })
+
+        it('removes (ft. Other Artist) bracketed clause', () => {
+            expect(normalizeLastFmTitle('Track Name (ft. Other Artist)')).toBe(
+                'Track Name',
+            )
+        })
+
+        it('returns unchanged for clean titles', () => {
+            expect(normalizeLastFmTitle('HUMBLE.')).toBe('HUMBLE.')
+        })
+    })
+
+    describe('getTopTracks', () => {
+        it('returns mapped tracks on success', async () => {
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                json: async () => ({
+                    toptracks: {
+                        track: [
+                            {
+                                name: 'Song A',
+                                artist: { name: 'Artist X' },
+                                playcount: '42',
+                            },
+                        ],
+                    },
+                }),
+            })
+
+            const tracks = await getTopTracks('username', '3month', 5)
+
+            expect(tracks).toHaveLength(1)
+            expect(tracks[0]).toEqual({
+                artist: 'Artist X',
+                title: 'Song A',
+                playCount: 42,
+            })
+        })
+
+        it('returns empty array when fetch fails', async () => {
+            fetchMock.mockRejectedValueOnce(new Error('network'))
+
+            const tracks = await getTopTracks('username')
+
+            expect(tracks).toEqual([])
+        })
+
+        it('returns empty array when api_key is not configured', async () => {
+            delete process.env.LASTFM_API_KEY
+
+            const tracks = await getTopTracks('username')
+
+            expect(tracks).toEqual([])
+        })
+
+        it('returns empty array on non-ok response', async () => {
+            fetchMock.mockResolvedValueOnce({ ok: false })
+
+            const tracks = await getTopTracks('username')
+
+            expect(tracks).toEqual([])
+        })
+    })
 })

packages/bot/src/lastfm/lastFmApi.ts

@@ -81,6 +81,64 @@
     }
 }
 
+const TOPIC_SUFFIX = / - topic$/i
+const ARTIST_SEPARATORS = /\s*[,/]\s*/
+const TITLE_NOISE_PARENS =
+    /\s*[([](official\s*(music\s*)?video|official\s*audio|audio|lyric\s*video|lyrics?|live|hd|4k|ft\.?[^)\]]*|feat\.?[^)\]]*)[)\]]/gi
+const FEAT_CLAUSE = /\s*[\[(]?feat\.?\s+[^\])[]+[\])]?/gi
+
+export function normalizeLastFmArtist(raw: string): string {
+    return raw.replace(TOPIC_SUFFIX, '').split(ARTIST_SEPARATORS)[0].trim()
+}
+
+export function normalizeLastFmTitle(raw: string): string {
+    return raw.replace(TITLE_NOISE_PARENS, '').replace(FEAT_CLAUSE, '').trim()
+}
+
+export type LastFmTopTrack = {
+    artist: string
+    title: string
+    playCount: number
+}
+export type LastFmPeriod = '7day' | '1month' | '3month' | '6month' | '12month'
+
+export async function getTopTracks(
+    lastFmUsername: string,
+    period: LastFmPeriod = '3month',
+    limit = 20,
+): Promise<LastFmTopTrack[]> {
+    const config = getApiConfig()
+    if (!config) return []
+    const params = new URLSearchParams({
+        method: 'user.getTopTracks',
+        user: lastFmUsername,
+        period,
+        limit: String(limit),
+        api_key: config.apiKey,
+        format: 'json',
+    })
+    try {
+        const res = await fetch(`${API_BASE}?${params.toString()}`)
+        if (!res.ok) return []
+        const data = (await res.json()) as {
+            toptracks?: {
+                track?: Array<{
+                    name: string
+                    artist: { name: string }
+                    playcount: string
+                }>
+            }
+        }
+        return (data.toptracks?.track ?? []).map((t) => ({
+            artist: t.artist.name,
+            title: t.name,
+            playCount: parseInt(t.playcount, 10) || 0,
+        }))
+    } catch {
+        return []
+    }
+}
+
 export async function updateNowPlaying(
     artist: string,
     track: string,
@@ -89,8 +147,8 @@
 ): Promise<void> {
     if (!sessionKey || !getApiConfig()) return
     const params: Record<string, string> = {
-        artist: artist.trim(),
-        track: track.trim(),
+        artist: normalizeLastFmArtist(artist),
+        track: normalizeLastFmTitle(track),
     }
     if (durationSec != null && durationSec > 0) {
         params.duration = String(Math.round(durationSec))
@@ -107,8 +165,8 @@
 ): Promise<void> {
     if (!sessionKey || !getApiConfig()) return
     const params: Record<string, string> = {
-        artist: artist.trim(),
-        track: track.trim(),
+        artist: normalizeLastFmArtist(artist),
+        track: normalizeLastFmTitle(track),
         timestamp: String(Math.floor(timestamp)),
     }
     if (durationSec != null && durationSec > 0) {

packages/bot/src/utils/music/autoplay/lastFmSeeds.spec.ts

@@ -0,0 +1,92 @@
+import {
+    afterEach,
+    beforeEach,
+    describe,
+    expect,
+    it,
+    jest,
+} from '@jest/globals'
+import { getLastFmSeedTracks } from './lastFmSeeds'
+
+const getByDiscordIdMock = jest.fn()
+const getTopTracksMock = jest.fn()
+
+jest.mock('@lucky/shared/services', () => ({
+    lastFmLinkService: {
+        getByDiscordId: (...args: unknown[]) => getByDiscordIdMock(...args),
+    },
+}))
+
+jest.mock('@lucky/shared/utils', () => ({
+    debugLog: jest.fn(),
+    errorLog: jest.fn(),
+}))
+
+jest.mock('../../../lastfm', () => ({
+    getTopTracks: (...args: unknown[]) => getTopTracksMock(...args),
+}))
+
+describe('getLastFmSeedTracks', () => {
+    beforeEach(() => {
+        jest.clearAllMocks()
+    })
+
+    afterEach(() => {
+        jest.clearAllMocks()
+    })
+
+    it('returns mapped tracks when user has a Last.fm link', async () => {
+        getByDiscordIdMock.mockResolvedValue({ lastFmUsername: 'user123' })
+        getTopTracksMock.mockResolvedValue([
+            { artist: 'Artist A', title: 'Song A', playCount: 10 },
+            { artist: 'Artist B', title: 'Song B', playCount: 5 },
+        ])
+
+        const tracks = await getLastFmSeedTracks('discord-user-1')
+
+        expect(tracks).toEqual([
+            { artist: 'Artist A', title: 'Song A' },
+            { artist: 'Artist B', title: 'Song B' },
+        ])
+        expect(getTopTracksMock).toHaveBeenCalledWith('user123', '3month', 20)
+    })
+
+    it('returns empty array when user has no Last.fm link', async () => {
+        getByDiscordIdMock.mockResolvedValue(null)
+
+        const tracks = await getLastFmSeedTracks('discord-user-2')
+
+        expect(tracks).toEqual([])
+        expect(getTopTracksMock).not.toHaveBeenCalled()
+    })
+
+    it('returns empty array when link has no lastFmUsername', async () => {
+        getByDiscordIdMock.mockResolvedValue({ lastFmUsername: null })
+
+        const tracks = await getLastFmSeedTracks('discord-user-3')
+
+        expect(tracks).toEqual([])
+    })
+
+    it('returns cached result on second call within TTL', async () => {
+        getByDiscordIdMock.mockResolvedValue({ lastFmUsername: 'cached-user' })
+        getTopTracksMock.mockResolvedValue([
+            { artist: 'Artist C', title: 'Song C', playCount: 3 },
+        ])
+
+        const first = await getLastFmSeedTracks('discord-user-cache')
+        const second = await getLastFmSeedTracks('discord-user-cache')
+
+        expect(first).toEqual(second)
+        expect(getTopTracksMock).toHaveBeenCalledTimes(1)
+    })
+
+    it('returns empty array when getTopTracks throws', async () => {
+        getByDiscordIdMock.mockResolvedValue({ lastFmUsername: 'erruser' })
+        getTopTracksMock.mockRejectedValue(new Error('API error'))
+
+        const tracks = await getLastFmSeedTracks('discord-user-err')
+
+        expect(tracks).toEqual([])
+    })
+})