@serifpersia/dango 3.3.9 → 3.4.1

package/server/dist/{controllers/music.controller.js → trpc/routers/music.js}

@@ -1,6 +1,8 @@
-import { Readable } from 'node:stream';
-import logger from '../logger.js';
-import { getInnertube, getAuthedInnertube, refreshAuthedInnertube, saveMusicCookie, getMusicAuthStatus, signOutMusic, isParserVariantError, } from '../lib/ytmusic.js';
+import { TRPCError } from '@trpc/server';
+import { protectedProcedure, router } from '../index.js';
+import { defineSchema, optStr, reqObj } from '../validation.js';
+import logger from '../../logger.js';
+import { getInnertube, getAuthedInnertube, refreshAuthedInnertube, saveMusicCookie, getMusicAuthStatus, signOutMusic, isParserVariantError, } from '../../lib/ytmusic.js';
 const NAME_SUFFIXES = [
     /\s*(- topic)$/i,
     /\s*vevo$/i,
@@ -13,7 +15,7 @@ const NAME_SUFFIXES = [
     /\s*[(|[](live)[)|\]]$/i,
     /\s*[(|[]4K\s*?(?:upgrade)?[)|\]]$/i,
 ];
-export function cleanupMusicName(name) {
+function cleanupMusicName(name) {
     if (!name)
         return name;
     let out = name;
@@ -93,9 +95,6 @@ function nodeType(node) {
         return n.type;
     return n?.constructor?.name ?? '';
 }
-/** Map a PlaylistPanel up-next entry (video or wrapper) to a MusicTrack.
- *  When trustLike is set (signed-in session), also read the current like
- *  state from YTM's own toggle (UNFAVORITE icon = currently liked). */
 function upnextToTrack(node, trustLike = false) {
     const kind = nodeType(node);
     if (kind === 'AutomixPreviewVideo')
@@ -170,10 +169,6 @@ function asMenuItems(menu) {
     const items = menu.items;
     return Array.isArray(items) ? items : [];
 }
-/** Find the YTM "liked songs" toggle for a track from its up-next menu.
- *  NOTE: default/toggled swap roles with the current state — when the song is
- *  already liked, default removes (status INDIFFERENT) and toggled re-adds
- *  (status LIKE). The payload `status` is the only reliable signal. */
 function findLikeToggle(item, videoId) {
     const result = { like: null, unlike: null };
     const kind = nodeType(item);
@@ -215,6 +210,8 @@ async function fetchPlaylistTracks(yt, id, cap = 500) {
             const track = toTrack(item);
             if (track)
                 tracks.push(track);
+            if (tracks.length >= cap)
+                break;
         }
         if (tracks.length >= cap)
             break;
@@ -288,126 +285,116 @@ async function readLibrary(yt) {
     logger.info(`[music] library parsed tracks=${tracks.length} playlists=${playlists.length} gridItems=${gridItems.length}`);
     return { tracks, playlists };
 }
-const UPSTREAM_UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36';
-const audioCache = new Map();
-const AUDIO_CACHE_MS = 5 * 60 * 1000;
-async function decipherWith(yt, videoId) {
-    const info = await yt.music.getInfo(videoId);
-    const streaming = info.streaming_data;
-    const formats = streaming?.adaptive_formats ?? [];
-    const sorted = [...formats]
-        .filter((f) => f.has_audio && !f.has_video)
-        .sort((a, b) => (b.bitrate ?? 0) - (a.bitrate ?? 0));
-    const player = yt.session.player;
-    for (const fmt of sorted) {
-        try {
-            const url = await fmt.decipher(player);
-            if (url && url.startsWith('http')) {
-                const entry = { url, mimeType: fmt.mime_type, fetchedAt: Date.now() };
-                audioCache.set(videoId, entry);
-                return entry;
-            }
-        }
-        catch {
-            // ignore
-        }
-    }
-    throw new Error('No stream available');
+function badRequest(message) {
+    return new TRPCError({ code: 'BAD_REQUEST', message });
 }
-async function decipherAudio(videoId) {
-    const cached = audioCache.get(videoId);
-    if (cached && Date.now() - cached.fetchedAt < AUDIO_CACHE_MS)
-        return cached;
-    const authed = await getAuthedInnertube().catch(() => null);
-    if (authed) {
-        try {
-            return await decipherWith(authed, videoId);
-        }
-        catch (err) {
-            logger.warn({ err }, '[music] authed stream lookup failed, retrying with a fresh saved-cookie session');
-            const fresh = await refreshAuthedInnertube();
-            if (fresh) {
-                try {
-                    return await decipherWith(fresh, videoId);
-                }
-                catch (retryErr) {
-                    logger.warn({ err: retryErr }, '[music] refreshed stream lookup failed, falling back to public session');
-                }
-            }
-        }
-    }
-    return decipherWith(await getInnertube(), videoId);
+function unauthorized(message) {
+    return new TRPCError({ code: 'UNAUTHORIZED', message });
 }
-const PASSTHROUGH_HEADERS = ['content-type', 'content-length', 'content-range', 'accept-ranges'];
-export class MusicController {
-    cache;
-    constructor(cache) {
-        this.cache = cache;
-    }
-    getAuthStatus = (_req, res) => {
-        res.json(getMusicAuthStatus());
-    };
-    startAuth = async (req, res) => {
+function failed(message) {
+    return new TRPCError({ code: 'INTERNAL_SERVER_ERROR', message });
+}
+const musicSearchInput = () => defineSchema((value) => {
+    const obj = reqObj(value);
+    const out = {};
+    const q = optStr(obj, 'q');
+    if (q !== undefined)
+        out.q = q;
+    return out;
+});
+const musicTrackInput = () => defineSchema((value) => {
+    const obj = reqObj(value);
+    const out = {};
+    const id = optStr(obj, 'id');
+    if (id !== undefined)
+        out.id = id;
+    return out;
+});
+const musicAuthStartInput = () => defineSchema((value) => {
+    const obj = reqObj(value);
+    const out = {};
+    const cookie = optStr(obj, 'cookie');
+    if (cookie !== undefined)
+        out.cookie = cookie;
+    return out;
+});
+const musicLikeInput = () => defineSchema((value) => {
+    const obj = reqObj(value);
+    const out = {};
+    const id = optStr(obj, 'id');
+    if (id !== undefined)
+        out.id = id;
+    if (typeof obj.like === 'boolean' || typeof obj.like === 'string')
+        out.like = obj.like;
+    return out;
+});
+function requireId(input) {
+    const id = String(input.id || '').trim();
+    if (!id)
+        throw badRequest('id is required');
+    return id;
+}
+export const musicRouter = router({
+    authStatus: protectedProcedure.query(() => {
+        return getMusicAuthStatus();
+    }),
+    authStart: protectedProcedure.input(musicAuthStartInput()).mutation(async ({ input }) => {
+        let cookie = String(input.cookie || '').trim();
+        if (!cookie)
+            throw badRequest('Cookie is required');
+        cookie = cookie
+            .replace(/^cookie\s*:\s*/i, '')
+            .replace(/^["']+|["']+$/g, '')
+            .trim();
+        if (cookie.includes('…') || cookie.includes('...')) {
+            throw badRequest(`Cookie looks truncated (${cookie.length} chars). In DevTools, right-click the Cookie header → Copy value (do not copy from the wrapped preview).`);
+        }
+        if (!cookie.includes('SID') && !cookie.includes('SAPISID')) {
+            throw badRequest('That does not look like a YouTube cookie at all. Copy the full Cookie request header from a "browse" call on music.youtube.com in DevTools → Network.');
+        }
         try {
-            let cookie = String(req.body?.cookie || '').trim();
-            if (!cookie)
-                return res.status(400).json({ error: 'Cookie is required' });
-            cookie = cookie
-                .replace(/^cookie\s*:\s*/i, '')
-                .replace(/^["']+|["']+$/g, '')
-                .trim();
-            if (cookie.includes('…') || cookie.includes('...')) {
-                return res.status(400).json({
-                    error: `Cookie looks truncated (${cookie.length} chars). In DevTools, right-click the Cookie header → Copy value (do not copy from the wrapped preview).`,
-                });
-            }
-            if (!cookie.includes('SID') && !cookie.includes('SAPISID')) {
-                return res.status(400).json({
-                    error: 'That does not look like a YouTube cookie at all. Copy the full Cookie request header from a "browse" call on music.youtube.com in DevTools → Network.',
-                });
-            }
             await saveMusicCookie(cookie);
             const yt = await getAuthedInnertube();
             if (yt) {
                 try {
                     const lib = await readLibrary(yt);
-                    return res.json({
+                    return {
                         success: true,
                         tracks: lib.tracks.length,
                         playlists: lib.playlists.length,
-                    });
+                    };
                 }
                 catch {
                     // ignore
                 }
             }
-            res.json({ success: true, tracks: 0, playlists: 0 });
+            return { success: true, tracks: 0, playlists: 0 };
         }
         catch (err) {
+            if (err instanceof TRPCError)
+                throw err;
             logger.error({ err }, '[music] cookie sign-in failed');
-            res.status(401).json({
-                error: 'Cookie rejected by YouTube Music. Copy a fresh Cookie header from music.youtube.com.',
-            });
+            throw unauthorized('Cookie rejected by YouTube Music. Copy a fresh Cookie header from music.youtube.com.');
         }
-    };
-    signOut = async (_req, res) => {
+    }),
+    signOut: protectedProcedure.mutation(async () => {
         try {
             await signOutMusic();
-            res.json({ success: true });
+            return { success: true };
         }
         catch (err) {
             logger.error({ err }, '[music] sign-out failed');
-            res.status(500).json({ error: 'Sign-out failed' });
+            throw failed('Sign-out failed');
         }
-    };
-    search = async (req, res) => {
-        const q = String(req.query.q || '').trim();
+    }),
+    search: protectedProcedure.input(musicSearchInput()).query(async ({ ctx, input }) => {
+        const q = String(input.q || '').trim();
         if (!q)
-            return res.json({ tracks: [] });
+            return { tracks: [] };
         const cacheKey = `music-search-${q.toLowerCase()}`;
-        const cached = this.cache.get(cacheKey);
+        const cached = ctx.apiCache.get(cacheKey);
         if (cached)
-            return res.json({ tracks: cached });
+            return { tracks: cached };
         try {
             const yt = await getInnertube();
             const result = await yt.music.search(q, { type: 'song' });
@@ -425,136 +412,26 @@ export class MusicController {
                 if (tracks.length >= 25)
                     break;
             }
-            this.cache.set(cacheKey, tracks, 300);
-            res.json({ tracks });
+            ctx.apiCache.set(cacheKey, tracks, 300);
+            return { tracks };
         }
         catch (err) {
             logger.error({ err }, '[music] search failed');
-            res.json({ tracks: [] });
+            return { tracks: [] };
         }
-    };
-    stream = async (req, res) => {
-        const videoId = String(req.query.videoId || req.query.id || '').trim();
-        if (!videoId)
-            return res.status(400).json({ error: 'videoId is required' });
-        try {
-            const entry = await decipherAudio(videoId);
-            res.json({ url: entry.url, mimeType: entry.mimeType });
-        }
-        catch (err) {
-            logger.error({ err }, '[music] stream failed');
-            res.status(502).json({ error: 'Stream lookup failed' });
-        }
-    };
-    audio = async (req, res) => {
-        const videoId = String(req.query.videoId || req.query.id || '').trim();
-        if (!videoId)
-            return res.status(400).json({ error: 'videoId is required' });
-        const aborter = new AbortController();
-        res.on('close', () => {
-            if (!res.writableEnded)
-                aborter.abort();
-        });
-        try {
-            let entry;
-            try {
-                entry = await decipherAudio(videoId);
-            }
-            catch {
-                return res.status(502).json({ error: 'No stream available' });
-            }
-            const timeout = AbortSignal.timeout(30000);
-            const signal = aborter.signal.aborted
-                ? aborter.signal
-                : AbortSignal.any([aborter.signal, timeout]);
-            let upstream;
-            try {
-                upstream = await fetch(entry.url, {
-                    headers: {
-                        'User-Agent': UPSTREAM_UA,
-                        Referer: 'https://music.youtube.com/',
-                        Origin: 'https://music.youtube.com/',
-                        Range: typeof req.headers.range === 'string' ? req.headers.range : 'bytes=0-',
-                    },
-                    signal,
-                });
-            }
-            catch (err) {
-                if (aborter.signal.aborted)
-                    return;
-                logger.error({ err }, '[music] audio upstream failed');
-                if (!res.headersSent)
-                    res.status(502).json({ error: 'Upstream error' });
-                return;
-            }
-            if (upstream.status !== 200 && upstream.status !== 206) {
-                try {
-                    await upstream.body?.cancel();
-                }
-                catch {
-                    // ignore
-                }
-                audioCache.delete(videoId);
-                if (!res.headersSent)
-                    res.status(502).json({ error: 'Upstream error' });
-                return;
-            }
-            res.status(upstream.status);
-            for (const name of PASSTHROUGH_HEADERS) {
-                const value = upstream.headers.get(name);
-                if (value)
-                    res.set(name === 'content-type' ? 'Content-Type' : name, value);
-            }
-            if (!res.get('Content-Type'))
-                res.set('Content-Type', entry.mimeType || 'audio/webm');
-            res.set('Accept-Ranges', 'bytes');
-            res.set('Access-Control-Allow-Origin', '*');
-            if (!upstream.body) {
-                if (!res.headersSent)
-                    res.status(502).json({ error: 'Upstream error' });
-                return;
-            }
-            try {
-                const nodeStream = Readable.fromWeb(upstream.body);
-                nodeStream.on('error', () => {
-                    try {
-                        if (!res.writableEnded)
-                            res.destroy();
-                    }
-                    catch {
-                        // ignore
-                    }
-                });
-                nodeStream.pipe(res);
-            }
-            catch (err) {
-                logger.error({ err }, '[music] audio pipe failed');
-                if (!res.headersSent)
-                    res.status(502).json({ error: 'Upstream error' });
-            }
-        }
-        catch (err) {
-            if (aborter.signal.aborted)
-                return;
-            logger.error({ err }, '[music] audio failed');
-            if (!res.headersSent)
-                res.status(502).json({ error: 'Stream lookup failed' });
-        }
-    };
-    track = async (req, res) => {
-        const id = String(req.query.id || '').trim();
-        if (!id)
-            return res.status(400).json({ error: 'id is required', track: null });
+    }),
+    track: protectedProcedure.input(musicTrackInput()).query(async ({ ctx, input }) => {
+        const id = requireId(input);
         const cacheKey = `music-track-${id.toLowerCase()}`;
-        const cached = this.cache.get(cacheKey);
+        const cached = ctx.apiCache.get(cacheKey);
         if (cached)
-            return res.json({ track: cached });
+            return { track: cached };
         try {
             const yt = await getInnertube();
             const info = await yt.music.getInfo(id);
             const basic = info.basic_info;
             if (!basic?.title)
-                return res.json({ track: null });
+                return { track: null };
             const durationSec = typeof basic.duration === 'number' && Number.isFinite(basic.duration)
                 ? Math.max(Math.round(basic.duration), 0)
                 : 0;
@@ -567,48 +444,46 @@ export class MusicController {
                     : undefined,
                 thumbnails: Array.isArray(basic.thumbnail) ? basic.thumbnail : [],
             };
-            this.cache.set(cacheKey, track, 300);
-            res.json({ track });
+            ctx.apiCache.set(cacheKey, track, 300);
+            return { track: track };
         }
         catch (err) {
             logger.error({ err }, '[music] track lookup failed');
-            res.json({ track: null });
+            return { track: null };
         }
-    };
-    playlist = async (req, res) => {
-        const id = String(req.query.id || '').trim();
-        if (!id)
-            return res.status(400).json({ error: 'id is required', tracks: [] });
+    }),
+    playlist: protectedProcedure.input(musicTrackInput()).query(async ({ input }) => {
+        const id = requireId(input);
         const yt = await getAuthedInnertube().catch(() => null);
         if (!yt) {
-            return res.status(401).json({ error: 'MUSIC_AUTH_REQUIRED', tracks: [] });
+            throw unauthorized('MUSIC_AUTH_REQUIRED');
         }
         try {
-            res.json({ tracks: await fetchPlaylistTracks(yt, id) });
+            return { tracks: await fetchPlaylistTracks(yt, id) };
         }
         catch (err) {
             logger.warn({ err }, '[music] playlist failed, retrying with a fresh saved-cookie session');
             const fresh = await refreshAuthedInnertube();
             if (!fresh)
-                return res.json({ tracks: [] });
+                return { tracks: [] };
             try {
-                res.json({ tracks: await fetchPlaylistTracks(fresh, id) });
+                return { tracks: await fetchPlaylistTracks(fresh, id) };
             }
             catch (retryErr) {
                 logger.warn({ err: retryErr }, '[music] playlist retry failed, returning empty');
-                res.json({ tracks: [] });
+                return { tracks: [] };
             }
         }
-    };
-    library = async (_req, res) => {
+    }),
+    library: protectedProcedure.query(async () => {
         const yt = await getAuthedInnertube().catch(() => null);
         if (!yt) {
-            return res.status(401).json({ error: 'MUSIC_AUTH_REQUIRED', tracks: [], playlists: [] });
+            throw unauthorized('MUSIC_AUTH_REQUIRED');
         }
         try {
             const first = await readLibrary(yt);
             if (first.tracks.length > 0 || first.playlists.length > 0)
-                return res.json(first);
+                return first;
             logger.warn('[music] library came back empty, retrying with a fresh saved-cookie session');
         }
         catch (err) {
@@ -616,51 +491,47 @@ export class MusicController {
         }
         const fresh = await refreshAuthedInnertube();
         if (!fresh)
-            return res.json({ tracks: [], playlists: [] });
+            return { tracks: [], playlists: [] };
         try {
-            res.json(await readLibrary(fresh));
+            return await readLibrary(fresh);
         }
         catch (err) {
             logger.warn({ err }, '[music] library retry failed, returning empty');
-            res.json({ tracks: [], playlists: [] });
+            return { tracks: [], playlists: [] };
         }
-    };
-    home = async (_req, res) => {
+    }),
+    home: protectedProcedure.query(async () => {
         try {
             const yt = await getInnertube();
             const feed = await yt.music.getHomeFeed();
-            res.json(feed);
+            return JSON.parse(JSON.stringify(feed));
         }
         catch (err) {
             logger.error({ err }, '[music] home feed failed');
-            res.json({ contents: [] });
+            return { contents: [] };
         }
-    };
-    upnext = async (req, res) => {
-        const id = String(req.query.id || '').trim();
-        if (!id)
-            return res.status(400).json({ error: 'id is required', tracks: [] });
-        // Signed-in sessions get fresh results with per-track like state; public
-        // results are cacheable and carry no like state.
+    }),
+    upnext: protectedProcedure.input(musicTrackInput()).query(async ({ ctx, input }) => {
+        const id = requireId(input);
         const authed = await getAuthedInnertube().catch(() => null);
         if (!authed) {
             const cacheKey = `music-upnext-${id.toLowerCase()}`;
-            const cached = this.cache.get(cacheKey);
+            const cached = ctx.apiCache.get(cacheKey);
             if (cached)
-                return res.json(cached);
+                return cached;
             try {
                 const yt = await getInnertube();
                 const payload = parseUpnext(await yt.music.getUpNext(id), false);
-                this.cache.set(cacheKey, payload, 300);
-                return res.json(payload);
+                ctx.apiCache.set(cacheKey, payload, 300);
+                return payload;
             }
             catch (err) {
                 logger.error({ err }, '[music] upnext failed');
-                return res.json({ tracks: [], playlistId: null });
+                return { tracks: [], playlistId: null };
             }
         }
         try {
-            return res.json(parseUpnext(await authed.music.getUpNext(id), true));
+            return parseUpnext(await authed.music.getUpNext(id), true);
         }
         catch (err) {
             logger.warn({ err }, '[music] authed upnext failed, retrying with a fresh saved-cookie session');
@@ -668,7 +539,7 @@ export class MusicController {
         const fresh = await refreshAuthedInnertube();
         if (fresh) {
             try {
-                return res.json(parseUpnext(await fresh.music.getUpNext(id), true));
+                return parseUpnext(await fresh.music.getUpNext(id), true);
             }
             catch (retryErr) {
                 logger.warn({ err: retryErr }, '[music] upnext retry failed, falling back to public');
@@ -676,65 +547,61 @@ export class MusicController {
         }
         try {
             const yt = await getInnertube();
-            return res.json(parseUpnext(await yt.music.getUpNext(id), false));
+            return parseUpnext(await yt.music.getUpNext(id), false);
         }
         catch (err) {
             logger.error({ err }, '[music] upnext failed');
-            return res.json({ tracks: [], playlistId: null });
+            return { tracks: [], playlistId: null };
         }
-    };
-    likedIds = async (_req, res) => {
+    }),
+    likes: protectedProcedure.query(async ({ ctx }) => {
         const yt = await getAuthedInnertube().catch(() => null);
         if (!yt) {
-            return res.status(401).json({ error: 'MUSIC_AUTH_REQUIRED', likedIds: [] });
+            throw unauthorized('MUSIC_AUTH_REQUIRED');
         }
         const cacheKey = 'music-liked-ids';
-        const cached = this.cache.get(cacheKey);
+        const cached = ctx.apiCache.get(cacheKey);
         if (cached)
-            return res.json({ likedIds: cached });
+            return { likedIds: cached };
         const fetchLikedIds = async (session) => {
             const tracks = await fetchPlaylistTracks(session, 'LM', 500);
             return tracks.map((t) => t.id);
         };
         try {
             const likedIds = await fetchLikedIds(yt);
-            this.cache.set(cacheKey, likedIds, 120);
-            res.json({ likedIds });
+            ctx.apiCache.set(cacheKey, likedIds, 120);
+            return { likedIds };
         }
         catch (err) {
             logger.warn({ err }, '[music] liked ids failed, retrying with a fresh saved-cookie session');
             const fresh = await refreshAuthedInnertube();
             if (!fresh)
-                return res.json({ likedIds: [] });
+                return { likedIds: [] };
             try {
                 const likedIds = await fetchLikedIds(fresh);
-                this.cache.set(cacheKey, likedIds, 120);
-                res.json({ likedIds });
+                ctx.apiCache.set(cacheKey, likedIds, 120);
+                return { likedIds };
             }
             catch (retryErr) {
                 logger.warn({ err: retryErr }, '[music] liked ids retry failed, returning empty');
-                res.json({ likedIds: [] });
+                return { likedIds: [] };
             }
         }
-    };
-    rate = async (req, res) => {
-        const id = String(req.body?.id ?? req.query.id ?? '').trim();
-        const like = req.body?.like === true || req.body?.like === 'true';
+    }),
+    like: protectedProcedure.input(musicLikeInput()).mutation(async ({ ctx, input }) => {
+        const id = String(input.id || '').trim();
+        const like = input.like === true || input.like === 'true';
         if (!id)
-            return res.status(400).json({ error: 'id is required' });
+            throw badRequest('id is required');
         const yt = await getAuthedInnertube().catch(() => null);
         if (!yt) {
-            return res.status(401).json({ error: 'MUSIC_AUTH_REQUIRED' });
+            throw unauthorized('MUSIC_AUTH_REQUIRED');
         }
         const attempt = async (session) => {
             const actions = session.actions ??
                 session.session?.actions;
             if (!actions)
                 throw new Error('Actions unavailable');
-            // Only ever call the toggle endpoints YouTube Music itself returns for
-            // this track (payload status LIKE/INDIFFERENT). No hand-built endpoints:
-            // raw video ids can differ from the canonical song id and a direct
-            // /like call would orphan entries in Liked Music.
             const panel = await session.music.getUpNext(id);
             const contents = panel.contents ?? [];
             let endpoint = null;
@@ -755,17 +622,17 @@ export class MusicController {
             logger.warn({ err }, '[music] rate failed, retrying with a fresh saved-cookie session');
             const fresh = await refreshAuthedInnertube();
             if (!fresh)
-                return res.status(502).json({ error: 'Like action failed' });
+                throw failed('Like action failed');
             try {
                 await attempt(fresh);
             }
             catch (retryErr) {
                 logger.error({ err: retryErr }, '[music] rate retry failed');
-                return res.status(502).json({ error: 'Like action failed' });
+                throw failed('Like action failed');
             }
         }
-        this.cache.delete('music-liked-ids');
+        ctx.apiCache.delete('music-liked-ids');
         logger.info(`[music] rate id=${id} liked=${like} via=toggle`);
-        res.json({ success: true, liked: like });
-    };
-}
+        return { success: true, liked: like };
+    }),
+});