From 81065df132c6ee09579e3d8543a88ac432c5c780 Mon Sep 17 00:00:00 2001 From: Kris Date: Sun, 22 Feb 2026 12:33:20 +0200 Subject: [PATCH] a --- .dockerignore | 2 + .gitignore | 34 ++++++++ Dockerfile | 13 +++ README.md | 15 ++++ bun.lock | 30 +++++++ docker-compose.yml | 8 ++ package.json | 18 ++++ src/index.ts | 213 +++++++++++++++++++++++++++++++++++++++++++++ tsconfig.json | 29 ++++++ 9 files changed, 362 insertions(+) create mode 100644 .dockerignore create mode 100644 .gitignore create mode 100644 Dockerfile create mode 100644 README.md create mode 100644 bun.lock create mode 100644 docker-compose.yml create mode 100644 package.json create mode 100644 src/index.ts create mode 100644 tsconfig.json diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000..76add87 --- /dev/null +++ b/.dockerignore @@ -0,0 +1,2 @@ +node_modules +dist \ No newline at end of file diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..a14702c --- /dev/null +++ b/.gitignore @@ -0,0 +1,34 @@ +# dependencies (bun install) +node_modules + +# output +out +dist +*.tgz + +# code coverage +coverage +*.lcov + +# logs +logs +_.log +report.[0-9]_.[0-9]_.[0-9]_.[0-9]_.json + +# dotenv environment variable files +.env +.env.development.local +.env.test.local +.env.production.local +.env.local + +# caches +.eslintcache +.cache +*.tsbuildinfo + +# IntelliJ based IDEs +.idea + +# Finder (MacOS) folder config +.DS_Store diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..aa3ec9d --- /dev/null +++ b/Dockerfile @@ -0,0 +1,13 @@ +FROM oven/bun:1 + +WORKDIR /app + +COPY package.json bun.lock ./ +RUN bun install --frozen-lockfile + +COPY . . + +ENV NODE_ENV=production +EXPOSE 3000 + +CMD ["bun", "run", "start"] \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..9bcbbb4 --- /dev/null +++ b/README.md @@ -0,0 +1,15 @@ +# kris-scrobbler + +To install dependencies: + +```bash +bun install +``` + +To run: + +```bash +bun run src/index.ts +``` + +This project was created using `bun init` in bun v1.3.0. [Bun](https://bun.com) is a fast all-in-one JavaScript runtime. diff --git a/bun.lock b/bun.lock new file mode 100644 index 0000000..ce43d8d --- /dev/null +++ b/bun.lock @@ -0,0 +1,30 @@ +{ + "lockfileVersion": 1, + "workspaces": { + "": { + "name": "kris-scrobbler", + "dependencies": { + "lastfm-ts-api": "^2.6.0", + }, + "devDependencies": { + "@types/bun": "latest", + }, + "peerDependencies": { + "typescript": "^5", + }, + }, + }, + "packages": { + "@types/bun": ["@types/bun@1.3.9", "", { "dependencies": { "bun-types": "1.3.9" } }, "sha512-KQ571yULOdWJiMH+RIWIOZ7B2RXQGpL1YQrBtLIV3FqDcCu6FsbFUBwhdKUlCKUpS3PJDsHlJ1QKlpxoVR+xtw=="], + + "@types/node": ["@types/node@25.3.0", "", { "dependencies": { "undici-types": "~7.18.0" } }, "sha512-4K3bqJpXpqfg2XKGK9bpDTc6xO/xoUP/RBWS7AtRMug6zZFaRekiLzjVtAoZMquxoAbzBvy5nxQ7veS5eYzf8A=="], + + "bun-types": ["bun-types@1.3.9", "", { "dependencies": { "@types/node": "*" } }, "sha512-+UBWWOakIP4Tswh0Bt0QD0alpTY8cb5hvgiYeWCMet9YukHbzuruIEeXC2D7nMJPB12kbh8C7XJykSexEqGKJg=="], + + "lastfm-ts-api": ["lastfm-ts-api@2.6.0", "", {}, "sha512-Kr4B4/LlEHumvmnzLawXGRQAzn2ApsQ/n+locPyDpGIQgJg/oK9OSAVTS1d47D00NLnZCNoa/+9YB/bkeXL46Q=="], + + "typescript": ["typescript@5.9.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw=="], + + "undici-types": ["undici-types@7.18.2", "", {}, "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w=="], + } +} diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..24b1392 --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,8 @@ +services: + kris-scrobbler: + build: + context: . + dockerfile: Dockerfile + environment: + - NODE_ENV=production + restart: unless-stopped \ No newline at end of file diff --git a/package.json b/package.json new file mode 100644 index 0000000..4397746 --- /dev/null +++ b/package.json @@ -0,0 +1,18 @@ +{ + "name": "kris-scrobbler", + "module": "src/index.ts", + "devDependencies": { + "@types/bun": "latest" + }, + "peerDependencies": { + "typescript": "^5" + }, + "private": true, + "scripts": { + "dev": "bun run --watch src/index.ts" + }, + "type": "module", + "dependencies": { + "lastfm-ts-api": "^2.6.0" + } +} \ No newline at end of file diff --git a/src/index.ts b/src/index.ts new file mode 100644 index 0000000..012d721 --- /dev/null +++ b/src/index.ts @@ -0,0 +1,213 @@ +import { LastFMTrack, LastFMUser } from 'lastfm-ts-api'; + +export const ROCKSKY_ENDPOINT = 'https://audioscrobbler.rocksky.app/2.0'; + +const LASTFM_USER = process.env.LASTFM_USER ?? 'user'; +const POLL_INTERVAL_MS = 5_000; +const MAX_SCROBBLES_PER_POLL = 1; +const MAX_SCROBBLE_RETRIES = 3; +const SCROBBLE_RETRY_DELAY_MS = 10_000; +const LOOKBACK_SECONDS = Number(process.env.LOOKBACK_SECONDS ?? 24 * 60 * 60); + +function requireEnv(name: string): string { + const value = process.env[name]; + if (!value) { + throw new Error(`Missing required env var: ${name}`); + } + + return value; +} + +function sleep(ms: number): Promise { + return new Promise(resolve => { + setTimeout(resolve, ms); + }); +} + +function formatError(error: unknown): string { + if (error instanceof Error && error.message) { + return error.message; + } + + if (typeof error === 'string') { + return error; + } + + try { + return JSON.stringify(error); + } catch { + return 'Unknown error'; + } +} + +const lastfm = new LastFMUser(requireEnv('LASTFM_KEY')); + +const rocksky = new LastFMTrack( + requireEnv('ROCKSKY_KEY'), + requireEnv('ROCKSKY_SECRET'), + requireEnv('ROCKSKY_SESSION_KEY'), + { + hostname: 'audioscrobbler.rocksky.app', + path: '/2.0' + } +); + +let lastTimestamp = Math.floor(Date.now() / 1000) - LOOKBACK_SECONDS; +let isSyncing = false; +let lastNowPlayingKey: string | null = null; + +async function scrobble(): Promise { + if (isSyncing) { + return; + } + + isSyncing = true; + + try { + const response = await lastfm.getRecentTracks({ + user: LASTFM_USER, + from: String(lastTimestamp), + limit: 200 + }); + + const recentTracks = Array.isArray(response.recenttracks.track) + ? response.recenttracks.track + : response.recenttracks.track + ? [response.recenttracks.track] + : []; + + const tracks = recentTracks + .map(track => { + const nowPlaying = Boolean(track['@attr']?.nowplaying); + const timestamp = nowPlaying + ? Math.max(1, Math.floor(Date.now() / 1000) - 30) + : Number(track.date?.uts); + const artist = track.artist?.['#text']?.trim(); + const title = track.name?.trim(); + const album = track.album?.['#text']?.trim(); + const mbid = track.mbid?.trim(); + const nowPlayingKey = nowPlaying ? mbid || `${artist}::${title}` : null; + + if (!Number.isFinite(timestamp) || !artist || !title) { + return null; + } + + if (nowPlaying && nowPlayingKey === lastNowPlayingKey) { + return null; + } + + return { + artist, + track: title, + timestamp, + nowPlaying, + nowPlayingKey, + ...(album ? { album } : {}), + ...(mbid ? { mbid } : {}) + }; + }) + .filter((track): track is NonNullable => track !== null) + .sort((a, b) => a.timestamp - b.timestamp); + + if (tracks.length === 0) { + return; + } + + const seen = new Set(); + const uniqueTracks = tracks.filter(track => { + const dedupeId = track.mbid || `${track.artist}::${track.track}`; + const key = `${track.timestamp}::${dedupeId}`; + if (seen.has(key)) { + return false; + } + + seen.add(key); + return true; + }); + + const completedTracks = uniqueTracks.filter(track => !track.nowPlaying); + const nowPlayingTracks = uniqueTracks.filter(track => track.nowPlaying); + const tracksToScrobble = + completedTracks.length > 0 + ? completedTracks.slice(-MAX_SCROBBLES_PER_POLL) + : nowPlayingTracks.slice(-MAX_SCROBBLES_PER_POLL); + const latestTrack = tracksToScrobble[tracksToScrobble.length - 1]; + if (!latestTrack) { + return; + } + + const scrobblePayload = tracksToScrobble.map(({ nowPlaying, nowPlayingKey, ...track }) => track); + + let scrobbleSucceeded = false; + + for (let attempt = 1; attempt <= MAX_SCROBBLE_RETRIES; attempt += 1) { + try { + const result = await rocksky.scrobbleMany(scrobblePayload); + const accepted = result.scrobbles['@attr'].accepted; + const ignored = result.scrobbles['@attr'].ignored; + console.log(`Scrobbled ${accepted} track(s), ignored ${ignored}.`); + + const scrobbles = Array.isArray(result.scrobbles.scrobble) + ? result.scrobbles.scrobble + : [result.scrobbles.scrobble]; + + for (const [index, scrobbleResult] of scrobbles.entries()) { + const fallbackTrack = tracksToScrobble[index]; + const artist = scrobbleResult.artist?.['#text']?.trim() || fallbackTrack?.artist || 'Unknown artist'; + const track = scrobbleResult.track?.['#text']?.trim() || fallbackTrack?.track || 'Unknown track'; + const ignoredCode = Number(scrobbleResult.ignoredMessage?.code ?? 0); + const ignoredMessage = scrobbleResult.ignoredMessage?.['#text']?.trim(); + const status = + ignoredCode === 0 + ? 'accepted' + : `ignored (${ignoredCode}${ignoredMessage ? `: ${ignoredMessage}` : ''})`; + + const nowPlayingSuffix = fallbackTrack?.nowPlaying ? ' (now playing)' : ''; + console.log(`Scrobble result: ${artist} - ${track}${nowPlayingSuffix}: ${status}`); + } + + scrobbleSucceeded = true; + break; + } catch (error) { + console.error( + `Scrobble attempt ${attempt}/${MAX_SCROBBLE_RETRIES} failed: ${formatError(error)}` + ); + + if (attempt < MAX_SCROBBLE_RETRIES) { + await sleep(SCROBBLE_RETRY_DELAY_MS); + } + } + } + + if (!latestTrack.nowPlaying) { + lastTimestamp = latestTrack.timestamp + 1; + } + + if (latestTrack.nowPlaying && latestTrack.nowPlayingKey) { + lastNowPlayingKey = latestTrack.nowPlayingKey; + } + + if (!scrobbleSucceeded) { + console.error( + `Skipping failed scrobble after ${MAX_SCROBBLE_RETRIES} attempts: ${latestTrack.artist} - ${latestTrack.track}` + ); + } + + console.log(`Synced ${tracksToScrobble.length} track(s) up to ${lastTimestamp}.`); + } catch (error) { + console.error(`Scrobble sync failed: ${formatError(error)}`); + } finally { + isSyncing = false; + } +} + +async function run(): Promise { + console.log(`Syncing Last.fm user ${LASTFM_USER} to ${ROCKSKY_ENDPOINT}`); + await scrobble(); + + setInterval(() => { + void scrobble(); + }, POLL_INTERVAL_MS); +} + +void run(); diff --git a/tsconfig.json b/tsconfig.json new file mode 100644 index 0000000..bfa0fea --- /dev/null +++ b/tsconfig.json @@ -0,0 +1,29 @@ +{ + "compilerOptions": { + // Environment setup & latest features + "lib": ["ESNext"], + "target": "ESNext", + "module": "Preserve", + "moduleDetection": "force", + "jsx": "react-jsx", + "allowJs": true, + + // Bundler mode + "moduleResolution": "bundler", + "allowImportingTsExtensions": true, + "verbatimModuleSyntax": true, + "noEmit": true, + + // Best practices + "strict": true, + "skipLibCheck": true, + "noFallthroughCasesInSwitch": true, + "noUncheckedIndexedAccess": true, + "noImplicitOverride": true, + + // Some stricter flags (disabled by default) + "noUnusedLocals": false, + "noUnusedParameters": false, + "noPropertyAccessFromIndexSignature": false + } +}