plx-converter 0.1.0 → 0.1.2

package/dist/ytmusic-provider.js

@@ -0,0 +1,156 @@
+import { matchCandidates, matchVideoCandidates, searchQuery } from './matcher.js';
+import { innertube, isMix, parsePlaylistRef } from './ytmusic.js';
+import { continuationToken, parseItems, playlistTitle, toCandidate } from './ytmusic-parse.js';
+// Search filter params, as the web client sends them: catalog songs, and music videos.
+const SONGS = 'EgWKAQIIAWoKEAkQBRAKEAMQBA%3D%3D';
+const VIDEOS = 'EgWKAQIQAWoKEAkQBRAKEAMQBA%3D%3D';
+const secToMs = (s) => (s == null ? null : s * 1000);
+export class YtMusicProvider {
+    cookie;
+    name = 'YouTube Music';
+    constructor(cookie) {
+        this.cookie = cookie;
+    }
+    call(path, body) { return innertube(path, this.cookie, body); }
+    // Every page of a playlist, following continuations.
+    async browseAll(playlistId) {
+        const pages = [];
+        const items = [];
+        let token = null;
+        for (;;) {
+            const page = token
+                ? await this.call('browse', { continuation: token })
+                : await this.call('browse', { browseId: `VL${parsePlaylistRef(playlistId)}` });
+            pages.push(page);
+            items.push(...parseItems(page));
+            token = continuationToken(page);
+            if (!token)
+                return { pages, items };
+        }
+    }
+    // Music videos are read but not converted: their stated artist is the uploading channel, so
+    // matching on it produces confident wrong answers. They come back as `skipped` so the report can
+    // show them as their own kind of row rather than silently dropping them.
+    async readPlaylist(playlistId) {
+        if (isMix(playlistId)) {
+            throw new Error('That is a mix, not a playlist. A mix is generated fresh every time it is opened, so it has no fixed contents to convert — open the playlist you want and use its link.');
+        }
+        const { items } = await this.browseAll(playlistId);
+        return {
+            tracks: items.filter((i) => i.isSong).map((i) => ({ name: i.title, artist: i.artist, durationMs: secToMs(i.durationSec) })),
+            truncated: false,
+            skipped: items.filter((i) => !i.isSong).map((i) => ({ name: i.title, artist: i.artist })),
+        };
+    }
+    async playlistName(playlistId) {
+        if (isMix(playlistId))
+            return parsePlaylistRef(playlistId);
+        const page = await this.call('browse', { browseId: `VL${parsePlaylistRef(playlistId)}` });
+        return playlistTitle(page) || parsePlaylistRef(playlistId);
+    }
+    async searchItems(track, params) {
+        const response = await this.call('search', { query: searchQuery(track.name, track.artist), params });
+        return parseItems(response);
+    }
+    // Catalog songs first. Only when nothing in the catalog matches does a music video get a look, and
+    // then under stricter rules — see matchVideoCandidates (ADR 0003: the provider owns the search
+    // strategy, the matcher owns the rules).
+    async search(track) {
+        const songs = await this.searchItems(track, SONGS);
+        const song = matchCandidates(track.name, track.artist, track.durationMs, songs.filter((i) => i.isSong).map(toCandidate));
+        if (song)
+            return song;
+        const videos = await this.searchItems(track, VIDEOS);
+        return matchVideoCandidates(track.name, track.artist, track.durationMs, videos.map(toCandidate));
+    }
+    async createPlaylist(title) {
+        const response = await this.call('playlist/create', { title, description: '', privacyStatus: 'PRIVATE' });
+        if (!response.playlistId)
+            throw new Error('YouTube Music did not return a playlist id');
+        return response.playlistId;
+    }
+    // Not part of the Provider interface — plx never deletes a user's playlist during a conversion.
+    // It exists so a live write can be undone, which is the only way to exercise the write path
+    // against the real service without leaving litter behind.
+    async deletePlaylist(playlistId) {
+        await this.call('playlist/delete', { playlistId: parsePlaylistRef(playlistId) });
+    }
+    async addTracks(playlistId, videoIds) {
+        const response = await this.call('browse/edit_playlist', {
+            playlistId: parsePlaylistRef(playlistId),
+            actions: videoIds.map((videoId) => ({ action: 'ACTION_ADD_VIDEO', addedVideoId: videoId })),
+        });
+        if (response.status && response.status !== 'STATUS_SUCCEEDED')
+            throw new Error(`YouTube Music refused the add (${response.status})`);
+        return videoIds.length;
+    }
+    async getPlaylistTrackIds(playlistId) {
+        const { items } = await this.browseAll(playlistId);
+        return new Set(items.map((i) => i.videoId));
+    }
+    async listPlaylists() {
+        const response = await this.call('browse', { browseId: 'FEmusic_liked_playlists' });
+        const found = [];
+        (function walk(node) {
+            if (!node || typeof node !== 'object')
+                return;
+            const record = node;
+            const row = record.musicTwoRowItemRenderer;
+            const browseId = row?.navigationEndpoint?.browseEndpoint?.browseId;
+            const title = row?.title?.runs?.[0]?.text;
+            // Anything not a playlist (an artist row, say) has no VL-prefixed browse id.
+            if (browseId?.startsWith('VL') && title)
+                found.push({ id: browseId.slice(2), title });
+            for (const child of Object.values(record))
+                walk(child);
+        })(response);
+        return found;
+    }
+    // Verification: re-resolve a match by its own id and hand back what the service says it is.
+    // `player` reports flat `videoDetails` rather than the deep renderer nesting everything else uses,
+    // which makes it both cheaper and far less likely to break.
+    async resolveTrack(videoId) {
+        const response = await this.call('player', { videoId });
+        const details = response.videoDetails;
+        if (!details?.title)
+            throw new Error('YouTube Music returned nothing for that track');
+        const seconds = Number(details.lengthSeconds);
+        return {
+            name: details.title,
+            // A catalog track's uploader is the artist's auto-generated "<Artist> - Topic" channel.
+            artist: (details.author ?? '').replace(/\s*-\s*Topic$/, ''),
+            durationMs: Number.isFinite(seconds) ? seconds * 1000 : null,
+        };
+    }
+    // Reorder capability (ADR 0002), keyed on track id. YouTube Music moves by `setVideoId`, an opaque
+    // per-item handle that is *not* the track id — the same song added twice has two of them. That
+    // lookup happens here, inside the provider; the handle never reaches the conversion interface.
+    async reorder(playlistId, trackIds) {
+        const desired = [...new Set(trackIds)].filter(Boolean);
+        if (desired.length < 2)
+            return false;
+        const { items } = await this.browseAll(playlistId);
+        const handles = new Map();
+        for (const item of items)
+            if (item.setVideoId && !handles.has(item.videoId))
+                handles.set(item.videoId, item.setVideoId);
+        const movable = desired.filter((id) => handles.has(id));
+        const current = items.map((i) => i.videoId).filter((id) => movable.includes(id));
+        if (current.length === movable.length && movable.every((id, i) => current[i] === id))
+            return false;
+        // Walk backwards placing each track before the one that should follow it, so a single pass
+        // leaves the run in source order without needing to know where anything moved to.
+        for (let i = movable.length - 2; i >= 0; i -= 1) {
+            await this.call('browse/edit_playlist', {
+                playlistId: parsePlaylistRef(playlistId),
+                actions: [{
+                        action: 'ACTION_MOVE_VIDEO_BEFORE',
+                        setVideoId: handles.get(movable[i]),
+                        movedSetVideoIdSuccessor: handles.get(movable[i + 1]),
+                    }],
+            });
+            await new Promise((resolve) => setTimeout(resolve, 100));
+        }
+        return true;
+    }
+}

package/dist/ytmusic.js

@@ -0,0 +1,130 @@
+import { createHash } from 'node:crypto';
+import { browserHeaders, fetchJson } from './http.js';
+const ORIGIN = 'https://music.youtube.com';
+const INNERTUBE = `${ORIGIN}/youtubei/v1`;
+// The cookies the YouTube Music web client sends. Google needs a bundle rather than the single
+// cookie the other two providers use, which is why plx stores a whole cookie header for it and why
+// the manual path is one paste instead of a prompt per cookie.
+//
+// SAPISID (or its __Secure- twin) is the one that must be present: request signing is derived from
+// it. The rest carry the session and are sent as-is.
+export const YTMUSIC_COOKIES = [
+    'SAPISID', '__Secure-1PAPISID', '__Secure-3PAPISID',
+    'SID', '__Secure-1PSID', '__Secure-3PSID',
+    // The *SIDTS pair is not optional on a current Google session: without it the *PSID cookies are
+    // treated as unbound and the request authenticates as logged out, with a 200 and no hint why.
+    '__Secure-1PSIDTS', '__Secure-3PSIDTS',
+    'HSID', 'SSID', 'APISID',
+    'LOGIN_INFO', 'SIDCC', '__Secure-1PSIDCC', '__Secure-3PSIDCC',
+    'PREF', 'VISITOR_INFO1_LIVE', 'YSC',
+];
+// The single joiner both browser backends route through: whatever cookies were found, in one header
+// string. Only the names above are kept, in that order, so the header is stable regardless of the
+// order a cookie store happened to yield them. Returns '' when the essential cookie is missing —
+// a bundle without it cannot be signed, so it is not a credential.
+export function cookieHeader(found) {
+    const pairs = YTMUSIC_COOKIES.filter((name) => found[name]).map((name) => `${name}=${found[name]}`);
+    return sapisidFrom(pairs.join('; ')) ? pairs.join('; ') : '';
+}
+// The value request signing is derived from. Accepts the __Secure- variants, which is what a
+// browser that has migrated to partitioned cookies will have instead of a bare SAPISID.
+export function sapisidFrom(header) {
+    for (const name of ['SAPISID', '__Secure-3PAPISID', '__Secure-1PAPISID']) {
+        const match = header.match(new RegExp(`(?:^|;\\s*)${name}=([^;]+)`));
+        if (match)
+            return match[1];
+    }
+    return '';
+}
+// SAPISIDHASH: sha1 over "<unix seconds> <SAPISID> <origin>", the way the web client signs its own
+// requests. Timestamp is a parameter so the hash is testable against a known vector.
+export function sapisidHash(sapisid, origin = ORIGIN, nowSec = Math.floor(Date.now() / 1000)) {
+    const digest = createHash('sha1').update(`${nowSec} ${sapisid} ${origin}`).digest('hex');
+    return `SAPISIDHASH ${nowSec}_${digest}`;
+}
+export function ytmusicHeaders(cookie) {
+    return {
+        ...browserHeaders,
+        Accept: '*/*',
+        'Content-Type': 'application/json',
+        Authorization: sapisidHash(sapisidFrom(cookie)),
+        'X-Goog-AuthUser': '0',
+        'x-origin': ORIGIN,
+        Cookie: cookie,
+    };
+}
+// InnerTube wants a client version; it is lenient about the exact value but not about the shape.
+// Derived from today's date the way the web client's own version is, so it ages with the calendar
+// instead of going stale as a pinned constant.
+export function clientVersion(now = new Date()) {
+    const date = now.toISOString().slice(0, 10).replaceAll('-', '');
+    return `1.${date}.01.00`;
+}
+export const innertubeContext = () => ({ context: { client: { clientName: 'WEB_REMIX', clientVersion: clientVersion(), hl: 'en', gl: 'US' } } });
+export async function innertube(path, cookie, body = {}) {
+    return fetchJson(`${INNERTUBE}/${path}?prettyPrint=false`, {
+        method: 'POST',
+        headers: ytmusicHeaders(cookie),
+        body: JSON.stringify({ ...innertubeContext(), ...body }),
+    });
+}
+// First `accountName: { runs: [{ text }] }` anywhere in the response. The account-menu renderer is
+// nested about six levels deep and the nesting is not a contract, so this walks rather than indexes.
+export function accountNameFrom(value) {
+    if (!value || typeof value !== 'object')
+        return '';
+    const node = value;
+    const runs = node.accountName?.runs;
+    if (runs?.[0]?.text)
+        return runs[0].text;
+    for (const child of Object.values(node)) {
+        const found = accountNameFrom(child);
+        if (found)
+            return found;
+    }
+    return '';
+}
+const EXPIRED = 'Your YouTube Music session has expired. Log in at music.youtube.com again, then re-run auto-fetch or paste a fresh cookie header.';
+// Prove the credential against the live service, resolving to the signed-in account name.
+//
+// Google answers a rejected session with **200 and a signed-out menu**, not an error status, so the
+// only reliable proof is that the response actually names an account. Trusting the status code here
+// reports a dead session as working.
+export async function validateSession(cookie) {
+    if (!sapisidFrom(cookie))
+        throw new Error('That cookie header has no SAPISID — copy the whole Cookie line from a music.youtube.com request.');
+    let raw;
+    try {
+        raw = await innertube('account/account_menu', cookie);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (/\b(401|403)\b/.test(message))
+            throw new Error(EXPIRED);
+        throw new Error(`Could not reach YouTube Music (${message}).`);
+    }
+    const account = accountNameFrom(raw);
+    if (!account)
+        throw new Error(EXPIRED);
+    return account;
+}
+// --- Playlist ids ----------------------------------------------------------
+// A YouTube Music playlist id *is* a YouTube playlist id, so both hosts name the same thing.
+export function parsePlaylistRef(ref) {
+    const input = ref.trim();
+    if (/^https?:\/\//i.test(input)) {
+        try {
+            const list = new URL(input).searchParams.get('list');
+            if (list)
+                return list;
+            const last = new URL(input).pathname.replace(/\/+$/, '').split('/').pop() ?? '';
+            return last.replace(/^VL/, '');
+        }
+        catch { /* fall through to the raw value */ }
+    }
+    return input.replace(/^VL/, '');
+}
+// A mix (radio) regenerates on every visit: its contents are not reproducible, so it is not a
+// playlist and plx refuses it as a source. Every mix id starts with RD — RDCLAK, RDAMVM, RDEM…
+// Checked on the id so the reason is explicit, rather than surfacing as an empty read.
+export const isMix = (playlistId) => /^RD/i.test(parsePlaylistRef(playlistId));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "plx-converter",
-  "version": "0.1.0",
-  "description": "Spotify ⇄ Deezer playlist converter CLI",
+  "version": "0.1.2",
+  "description": "Convert playlists between Spotify, Deezer, and YouTube Music using your own browser session",
   "license": "MIT",
   "type": "module",
   "bin": {
@@ -26,6 +26,7 @@
   "dependencies": {
     "@clack/prompts": "^0.10.1",
     "dotenv": "^16.4.7",
+    "plx-converter": "^0.1.1",
     "zod": "^3.24.2"
   },
   "devDependencies": {

package/dist/converter.js

@@ -1,115 +0,0 @@
-import { EMBED_TRACK_LIMIT, readPlaylist } from './spotify.js';
-import { writeCsv } from './csv.js';
-export class Converter {
-    deezer;
-    spotifyToken;
-    rows = [];
-    output;
-    constructor(deezer, spotifyToken, output) {
-        this.deezer = deezer;
-        this.spotifyToken = spotifyToken;
-        this.output = output;
-    }
-    record(row) { this.rows.push(row); }
-    async matchPlaylist(playlist, dryRun = false) {
-        let result;
-        try {
-            result = await readPlaylist(playlist.uri, this.spotifyToken);
-        }
-        catch (error) {
-            this.record({ playlist: playlist.name, title: '', artist: '', isrc: null, matched: false, note: `gagal baca playlist: ${error instanceof Error ? error.name : 'Error'}` });
-            return { matchedIds: [], total: 0, truncated: false };
-        }
-        if (result.truncated) {
-            this.record({ playlist: playlist.name, title: '', artist: '', isrc: null, matched: false, note: `PERINGATAN: terpotong di ${EMBED_TRACK_LIMIT} lagu; sisanya tidak dikonversi` });
-            console.log(`[${playlist.name}] ⚠️ Terpotong di ${EMBED_TRACK_LIMIT} lagu (fallback embed).`);
-        }
-        const matchedIds = [];
-        for (let i = 0; i < result.tracks.length; i += 1) {
-            const track = result.tracks[i];
-            let match = null;
-            for (let attempt = 0; attempt < 3; attempt += 1) {
-                try {
-                    match = await this.deezer.search(track);
-                    break;
-                }
-                catch (error) {
-                    if (attempt === 2)
-                        console.log(`  ⚠️ search gagal: ${error instanceof Error ? error.name : 'Error'}`);
-                    else
-                        await new Promise((resolve) => setTimeout(resolve, 2 ** attempt * 1000));
-                }
-            }
-            if (match) {
-                matchedIds.push(match.id);
-                this.record({ playlist: playlist.name, title: track.name, artist: track.artist, isrc: null, matched: true, deezer_id: match.id, method: match.method, note: dryRun ? 'dry-run' : null });
-                console.log(`  [${i + 1}/${result.tracks.length}] ✓ ${match.method} — ${track.name} — ${track.artist}`);
-            }
-            else {
-                this.record({ playlist: playlist.name, title: track.name, artist: track.artist, isrc: null, matched: false, note: dryRun ? 'dry-run: tidak ketemu' : 'tidak ketemu' });
-                console.log(`  [${i + 1}/${result.tracks.length}] ✗ tidak ditemukan — ${track.name} — ${track.artist}`);
-            }
-            await new Promise((resolve) => setTimeout(resolve, 300));
-        }
-        console.log(`[${playlist.name}] ${matchedIds.length}/${result.tracks.length} lagu cocok.`);
-        return { matchedIds, total: result.tracks.length, truncated: result.truncated };
-    }
-    async writePlaylist(name, ids, title = `[plx] ${name}`) {
-        if (!ids.length) {
-            console.log(`[${name}] Tidak ada lagu yang cocok — playlist tidak dibuat.`);
-            return;
-        }
-        const id = await this.deezer.createPlaylist(title);
-        const unique = [...new Set(ids)];
-        for (let start = 0; start < unique.length; start += 100) {
-            await this.deezer.addTracks(id, unique.slice(start, start + 100));
-            await new Promise((resolve) => setTimeout(resolve, 200));
-        }
-        console.log(`[${name}] playlist Deezer dibuat: ${title} (${unique.length} lagu)`);
-    }
-    // Append to an existing playlist, skipping tracks already present (dedupe), then reorder 1:1.
-    async writeToExisting(name, playlistId, ids) {
-        if (!ids.length) {
-            console.log(`[${name}] Tidak ada lagu yang cocok.`);
-            return;
-        }
-        const existing = await this.deezer.getPlaylistTrackIds(playlistId);
-        // Dedupe within the batch too — Deezer rejects any chunk containing a repeated id.
-        const unique = [...new Set(ids)];
-        const batchDupes = ids.length - unique.length;
-        const alreadyThere = unique.filter((id) => existing.has(id)).length;
-        const toAdd = unique.filter((id) => !existing.has(id));
-        let added = 0;
-        if (toAdd.length) {
-            for (let start = 0; start < toAdd.length; start += 100) {
-                added += await this.deezer.addTracks(playlistId, toAdd.slice(start, start + 100));
-                await new Promise((resolve) => setTimeout(resolve, 200));
-            }
-        }
-        const parts = [];
-        if (alreadyThere)
-            parts.push(`${alreadyThere} sudah ada`);
-        if (batchDupes)
-            parts.push(`${batchDupes} duplikat dihilangkan`);
-        console.log(`[${name}] ${added} lagu baru ditambahkan${parts.length ? ` (${parts.join(', ')})` : ''}.`);
-        await this.reorderToMatch(name, playlistId, ids);
-    }
-    // Reorder the target to mirror the source order (1:1 sync). Moves each matched track into place
-    // from the front, so matched tracks land in source order and anything extra is pushed to the end.
-    async reorderToMatch(name, playlistId, ids) {
-        const desired = [...new Set(ids)].filter((id) => id);
-        if (desired.length < 2)
-            return;
-        const current = await this.deezer.getPlaylistTrackOrder(playlistId);
-        const movable = new Set(desired);
-        const kept = current.filter((id) => movable.has(id));
-        if (kept.length === desired.length && desired.every((id, i) => kept[i] === id))
-            return;
-        for (let i = 0; i < desired.length; i += 1) {
-            await this.deezer.moveTrack(playlistId, desired[i], i === 0 ? null : desired[i - 1]);
-            await new Promise((resolve) => setTimeout(resolve, 100));
-        }
-        console.log(`[${name}] urutan playlist disamakan dengan sumber.`);
-    }
-    async writeReport() { await writeCsv(this.output, this.rows); }
-}

package/dist/reverse.js

@@ -1,87 +0,0 @@
-import { addTracks, createPlaylist, fetchTrackUris, resolveTrackMeta, searchTrack } from './spotify.js';
-import { matchCandidates, searchQuery } from './matcher.js';
-import { writeCsv } from './csv.js';
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-// Match a Deezer playlist's tracks to Spotify track URIs, then resolve each matched
-// URI back to its real Spotify metadata and compare to the source. `verified` counts
-// matches whose resolved title+artist still match the source (precision); a matched
-// URI whose metadata diverges is flagged `note: '⚠️ cek ulang (mungkin salah track)'`.
-export async function reverseMatch(deezer, token, sourceId, sourceName) {
-    const tracks = await deezer.getPlaylistTracks(sourceId);
-    const rows = [];
-    const matchedUris = [];
-    let verified = 0;
-    for (let i = 0; i < tracks.length; i += 1) {
-        const track = tracks[i];
-        let match = null;
-        for (let attempt = 0; attempt < 3; attempt += 1) {
-            try {
-                const candidates = await searchTrack(searchQuery(track.name, track.artist), token);
-                match = matchCandidates(track.name, track.artist, track.durationMs, candidates);
-                break;
-            }
-            catch (error) {
-                if (attempt === 2)
-                    console.log(`  ⚠️ search gagal: ${error instanceof Error ? error.name : 'Error'}`);
-                else
-                    await sleep(2 ** attempt * 1000);
-            }
-        }
-        if (match) {
-            let note = null;
-            try {
-                const meta = await resolveTrackMeta(match.id);
-                if (matchCandidates(track.name, track.artist, track.durationMs, [{ id: match.id, title: meta.name, artist: meta.artist, duration: meta.durationMs != null ? Math.round(meta.durationMs / 1000) : null }]))
-                    verified += 1;
-                else
-                    note = '⚠️ cek ulang (mungkin salah track)';
-            }
-            catch {
-                note = '⚠️ verifikasi gagal';
-            }
-            matchedUris.push(match.id);
-            rows.push({ playlist: sourceName, title: track.name, artist: track.artist, isrc: null, matched: true, deezer_id: match.id, method: match.method, note });
-            console.log(`  [${i + 1}/${tracks.length}] ✓ ${match.method} — ${track.name} — ${track.artist}${note ? ` — ${note}` : ''}`);
-        }
-        else {
-            rows.push({ playlist: sourceName, title: track.name, artist: track.artist, isrc: null, matched: false, note: 'tidak ketemu' });
-            console.log(`  [${i + 1}/${tracks.length}] ✗ tidak ditemukan — ${track.name} — ${track.artist}`);
-        }
-        await sleep(300);
-    }
-    const missed = tracks.length - matchedUris.length;
-    console.log(`[${sourceName}] ${matchedUris.length}/${tracks.length} cocok (${verified} terverifikasi${missed ? `, ${missed} gagal match` : ''}).`);
-    return { rows, matchedUris, total: tracks.length };
-}
-// Deezer playlist (source) → new Spotify playlist (target).
-export async function reverseConvert(deezer, token, sourceId, sourceName, output) {
-    const { rows, matchedUris } = await reverseMatch(deezer, token, sourceId, sourceName);
-    if (matchedUris.length) {
-        const uri = await createPlaylist(`[plx] ${sourceName}`, token);
-        for (let start = 0; start < matchedUris.length; start += 100) {
-            await addTracks(uri, matchedUris.slice(start, start + 100), token);
-            await sleep(200);
-        }
-        console.log(`[${sourceName}] playlist Spotify dibuat: ${uri} (${matchedUris.length} lagu)`);
-    }
-    await writeCsv(output, rows);
-}
-// Deezer playlist (source) → an existing Spotify playlist (target). Dedupe + append (no reorder — Spotify has no move primitive in scope).
-export async function reverseWriteToExisting(deezer, token, sourceId, sourceName, targetUri, output) {
-    const { rows, matchedUris } = await reverseMatch(deezer, token, sourceId, sourceName);
-    if (!matchedUris.length) {
-        await writeCsv(output, rows);
-        return;
-    }
-    const targetId = targetUri.split(':').pop() ?? targetUri;
-    const existing = new Set(await fetchTrackUris(targetId, token));
-    const toAdd = [...new Set(matchedUris)].filter((u) => !existing.has(u));
-    if (toAdd.length) {
-        for (let start = 0; start < toAdd.length; start += 100) {
-            await addTracks(targetUri, toAdd.slice(start, start + 100), token);
-            await sleep(200);
-        }
-    }
-    console.log(`[${sourceName}] ${toAdd.length} lagu baru ditambahkan (${matchedUris.length - toAdd.length} sudah ada, dilewati).`);
-    await writeCsv(output, rows);
-}