505 lines
16 KiB
TypeScript
505 lines
16 KiB
TypeScript
import {
|
|
HASHTAG_FILTER,
|
|
MASTODON_ACCESS_TOKEN,
|
|
MASTODON_INSTANCE,
|
|
ODESLI_API_KEY,
|
|
YOUTUBE_API_KEY
|
|
} from '$env/static/private';
|
|
import { Logger } from '$lib/log';
|
|
import type {
|
|
Account,
|
|
AccountAvatar,
|
|
Post,
|
|
SongThumbnailImage,
|
|
Tag,
|
|
TimelineEvent
|
|
} from '$lib/mastodon/response';
|
|
import { SongThumbnailImageKind } from '$lib/mastodon/response';
|
|
import type { OdesliResponse, Platform, SongInfo } from '$lib/odesliResponse';
|
|
import {
|
|
getAvatars,
|
|
getPosts,
|
|
getSongThumbnails,
|
|
removeAvatars,
|
|
saveAvatar,
|
|
savePost,
|
|
saveSongThumbnail
|
|
} from '$lib/server/db';
|
|
import { SpotifyPlaylistAdder } from '$lib/server/playlist/spotifyPlaylistAdder';
|
|
import { YoutubePlaylistAdder } from '$lib/server/playlist/ytPlaylistAdder';
|
|
import { createFeed, saveAtomFeed } from '$lib/server/rss';
|
|
import { sleep } from '$lib/sleep';
|
|
import crypto from 'crypto';
|
|
import fs from 'fs/promises';
|
|
import { console } from 'inspector/promises';
|
|
import sharp from 'sharp';
|
|
import { URL, URLSearchParams } from 'url';
|
|
import { WebSocket } from 'ws';
|
|
import type { PlaylistAdder } from './playlist/playlistAdder';
|
|
|
|
const URL_REGEX = new RegExp(/href="(?<postUrl>[^>]+?)" target="_blank"/gm);
|
|
const INVIDIOUS_REGEX = new RegExp(/invidious.*?watch.*?v=(?<videoId>[a-zA-Z_0-9-]+)/gm);
|
|
const YOUTUBE_REGEX = new RegExp(
|
|
/https?:\/\/(www\.)?youtu((be.com\/.*?v=)|(\.be\/))(?<videoId>[a-zA-Z_0-9-]+)/gm
|
|
);
|
|
|
|
export class TimelineReader {
|
|
private static _instance: TimelineReader;
|
|
private lastPosts: string[] = [];
|
|
private playlistAdders: PlaylistAdder[];
|
|
private logger: Logger;
|
|
|
|
private async isMusicVideo(videoId: string) {
|
|
if (!YOUTUBE_API_KEY || YOUTUBE_API_KEY === 'CHANGE_ME') {
|
|
// Assume that it *is* a music link when no YT API key is provided
|
|
this.logger.debug('YT API not configured');
|
|
return true;
|
|
}
|
|
const searchParams = new URLSearchParams([
|
|
['part', 'snippet'],
|
|
['id', videoId],
|
|
['key', YOUTUBE_API_KEY]
|
|
]);
|
|
const youtubeVideoUrl = new URL(`https://www.googleapis.com/youtube/v3/videos?${searchParams}`);
|
|
const resp = await fetch(youtubeVideoUrl);
|
|
const respObj = await resp.json();
|
|
if (!respObj.items.length) {
|
|
this.logger.warn('Could not find video with id', videoId);
|
|
return false;
|
|
}
|
|
|
|
const item = respObj.items[0];
|
|
if (!item.snippet) {
|
|
this.logger.warn('Could not load snippet for video', videoId, item);
|
|
return false;
|
|
}
|
|
if (item.snippet.tags?.includes('music')) {
|
|
return true;
|
|
}
|
|
|
|
const categorySearchParams = new URLSearchParams([
|
|
['part', 'snippet'],
|
|
['id', item.snippet.categoryId],
|
|
['key', YOUTUBE_API_KEY]
|
|
]);
|
|
const youtubeCategoryUrl = new URL(
|
|
`https://www.googleapis.com/youtube/v3/videoCategories?${categorySearchParams}`
|
|
);
|
|
const categoryTitle: string = await fetch(youtubeCategoryUrl)
|
|
.then((r) => r.json())
|
|
.then((r) => r.items[0]?.snippet?.title);
|
|
this.logger.debug('YT category', categoryTitle);
|
|
return categoryTitle === 'Music';
|
|
}
|
|
|
|
public async getSongInfoInPost(post: Post): Promise<SongInfo[]> {
|
|
const urlMatches = post.content.matchAll(URL_REGEX);
|
|
const songs: SongInfo[] = [];
|
|
for (const match of urlMatches) {
|
|
if (match === undefined || match.groups === undefined) {
|
|
this.logger.warn(
|
|
'Match listed in allMatches, but either it or its groups are undefined',
|
|
match
|
|
);
|
|
continue;
|
|
}
|
|
const urlMatch = match.groups.postUrl.toString();
|
|
let url: URL;
|
|
try {
|
|
url = new URL(urlMatch);
|
|
} catch (e) {
|
|
this.logger.error('URL found via Regex does not seem to be a valud url', urlMatch, e);
|
|
continue;
|
|
}
|
|
|
|
// Check *all* found url and let odesli determine if it is music or not
|
|
this.logger.debug(`Checking ${url} if it contains song data`);
|
|
const info = await this.getSongInfo(url);
|
|
//this.logger.debug(`Found song info for ${url}?`, info);
|
|
if (info) {
|
|
songs.push(info);
|
|
}
|
|
}
|
|
return songs;
|
|
}
|
|
|
|
private async getSongInfo(url: URL, remainingTries = 6): Promise<SongInfo | null> {
|
|
if (remainingTries === 0) {
|
|
this.logger.error('No tries remaining. Lookup failed!');
|
|
return null;
|
|
}
|
|
if (url.hostname === 'songwhip.com') {
|
|
// song.link doesn't support songwhip links and songwhip themselves will provide metadata if you pass in a
|
|
// Apple Music/Spotify/etc link, but won't when provided with their own link, so no way to extract song info
|
|
// except maybe scraping their HTML
|
|
return null;
|
|
}
|
|
|
|
const videoId = INVIDIOUS_REGEX.exec(url.href)?.groups?.videoId;
|
|
const urlString =
|
|
videoId !== undefined ? `https://youtube.com/watch?v=${videoId}` : url.toString();
|
|
|
|
const odesliParams = new URLSearchParams();
|
|
odesliParams.append('url', urlString);
|
|
odesliParams.append('userCountry', 'DE');
|
|
odesliParams.append('songIfSingle', 'true');
|
|
if (ODESLI_API_KEY && ODESLI_API_KEY !== 'CHANGE_ME') {
|
|
odesliParams.append('key', ODESLI_API_KEY);
|
|
}
|
|
const odesliApiUrl = `https://api.song.link/v1-alpha.1/links?${odesliParams}`;
|
|
try {
|
|
const response = await fetch(odesliApiUrl);
|
|
if (response.status === 429) {
|
|
throw new Error('Rate limit reached', { cause: 429 });
|
|
}
|
|
const odesliInfo: OdesliResponse = await response.json();
|
|
if (!odesliInfo || !odesliInfo.entitiesByUniqueId || !odesliInfo.entityUniqueId) {
|
|
return null;
|
|
}
|
|
const info = odesliInfo.entitiesByUniqueId[odesliInfo.entityUniqueId];
|
|
//this.logger.debug('odesli response', info);
|
|
const platform: Platform = 'youtube';
|
|
if (info.platforms.includes(platform)) {
|
|
const youtubeId =
|
|
videoId ??
|
|
YOUTUBE_REGEX.exec(url.href)?.groups?.videoId ??
|
|
new URL(odesliInfo.pageUrl).pathname.split('/y/').pop();
|
|
if (youtubeId === undefined) {
|
|
this.logger.warn(
|
|
'Looks like a youtube video, but could not extract a video id',
|
|
url,
|
|
odesliInfo
|
|
);
|
|
return null;
|
|
}
|
|
const isMusic = await this.isMusicVideo(youtubeId);
|
|
if (!isMusic) {
|
|
this.logger.debug('Probably not a music video', youtubeId, url);
|
|
return null;
|
|
}
|
|
}
|
|
const spotify: Platform = 'spotify';
|
|
const songInfo = {
|
|
...info,
|
|
pageUrl: odesliInfo.pageUrl,
|
|
youtubeUrl: odesliInfo.linksByPlatform[platform]?.url,
|
|
spotifyUrl: odesliInfo.linksByPlatform[spotify]?.url,
|
|
spotifyUri: odesliInfo.linksByPlatform[spotify]?.nativeAppUriDesktop,
|
|
postedUrl: url.toString()
|
|
} as SongInfo;
|
|
if (songInfo.youtubeUrl && !songInfo.spotifyUrl) {
|
|
this.logger.warn('SongInfo with YT, but no spotify URL', odesliInfo);
|
|
}
|
|
return songInfo;
|
|
} catch (e) {
|
|
if (e instanceof Error && e.cause === 429) {
|
|
this.logger.warn('song.link rate limit reached. Trying again in 10 seconds');
|
|
await sleep(10_000);
|
|
return await this.getSongInfo(url, remainingTries - 1);
|
|
}
|
|
this.logger.error(`Failed to load ${url} info from song.link`, e);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private async addToPlaylist(song: SongInfo) {
|
|
for (let adder of this.playlistAdders) {
|
|
await adder.addToPlaylist(song);
|
|
}
|
|
}
|
|
|
|
private async resizeAvatar(
|
|
baseName: string,
|
|
size: number,
|
|
suffix: string,
|
|
folder: string,
|
|
sharpAvatar: sharp.Sharp
|
|
): Promise<string | null> {
|
|
const fileName = `${folder}/${baseName}_${suffix}`;
|
|
const exists = await fs
|
|
.access(fileName, fs.constants.F_OK)
|
|
.then(() => true)
|
|
.catch(() => false);
|
|
if (exists) {
|
|
this.logger.debug('File already exists', fileName);
|
|
return null;
|
|
}
|
|
this.logger.debug('Saving avatar', fileName);
|
|
await sharpAvatar.resize(size).toFile(fileName);
|
|
return fileName;
|
|
}
|
|
|
|
private resizeAvatarPromiseMaker(
|
|
avatarFilenameBase: string,
|
|
baseSize: number,
|
|
maxPixelDensity: number,
|
|
accountUrl: string,
|
|
formats: string[],
|
|
avatar: ArrayBuffer
|
|
): Promise<void>[] {
|
|
const sharpAvatar = sharp(avatar);
|
|
const promises: Promise<void>[] = [];
|
|
for (let i = 1; i <= maxPixelDensity; i++) {
|
|
promises.push(
|
|
...formats.map((f) =>
|
|
this.resizeAvatar(avatarFilenameBase, baseSize * i, `${i}x.${f}`, 'avatars', sharpAvatar)
|
|
.then(
|
|
(fn) =>
|
|
({
|
|
accountUrl: accountUrl,
|
|
file: fn,
|
|
sizeDescriptor: `${i}x`
|
|
}) as AccountAvatar
|
|
)
|
|
.then(saveAvatar)
|
|
)
|
|
);
|
|
}
|
|
return promises;
|
|
}
|
|
|
|
private resizeThumbnailPromiseMaker(
|
|
filenameBase: string,
|
|
baseSize: number,
|
|
maxPixelDensity: number,
|
|
songThumbnailUrl: string,
|
|
formats: string[],
|
|
image: ArrayBuffer,
|
|
kind: SongThumbnailImageKind
|
|
): Promise<void>[] {
|
|
const sharpAvatar = sharp(image);
|
|
const promises: Promise<void>[] = [];
|
|
for (let i = 1; i <= maxPixelDensity; i++) {
|
|
promises.push(
|
|
...formats.map((f) =>
|
|
this.resizeAvatar(filenameBase, baseSize * i, `${i}x.${f}`, 'thumbnails', sharpAvatar)
|
|
.then(
|
|
(fn) =>
|
|
({
|
|
songThumbnailUrl: songThumbnailUrl,
|
|
file: fn,
|
|
sizeDescriptor: `${i}x`,
|
|
kind: kind
|
|
}) as SongThumbnailImage
|
|
)
|
|
.then(saveSongThumbnail)
|
|
)
|
|
);
|
|
}
|
|
return promises;
|
|
}
|
|
|
|
private async saveAvatar(account: Account) {
|
|
try {
|
|
const existingAvatars = await getAvatars(account.url, 1);
|
|
const existingAvatarBase = existingAvatars.shift()?.file.split('/').pop()?.split('_').shift();
|
|
const avatarFilenameBase =
|
|
new URL(account.avatar).pathname.split('/').pop()?.split('.').shift() ?? account.acct;
|
|
|
|
// User's avatar changed. Remove the old one!
|
|
if (existingAvatarBase && existingAvatarBase !== avatarFilenameBase) {
|
|
await removeAvatars(account.url);
|
|
const avatarsToDelete = (await fs.readdir('avatars'))
|
|
.filter((x) => x.startsWith(existingAvatarBase + '_'))
|
|
.map((x) => {
|
|
this.logger.debug('Removing existing avatar file', x);
|
|
return x;
|
|
})
|
|
.map((x) => fs.unlink('avatars/' + x));
|
|
await Promise.allSettled(avatarsToDelete);
|
|
}
|
|
const avatarResponse = await fetch(account.avatar);
|
|
const avatar = await avatarResponse.arrayBuffer();
|
|
await Promise.all(
|
|
this.resizeAvatarPromiseMaker(
|
|
avatarFilenameBase,
|
|
50,
|
|
3,
|
|
account.url,
|
|
['webp', 'avif', 'jpeg'],
|
|
avatar
|
|
)
|
|
);
|
|
} catch (e) {
|
|
console.error('Could not resize and save avatar for', account.acct, account.avatar, e);
|
|
}
|
|
}
|
|
|
|
private async saveSongThumbnails(songs: SongInfo[]) {
|
|
for (const song of songs) {
|
|
if (!song.thumbnailUrl) {
|
|
continue;
|
|
}
|
|
try {
|
|
const existingThumbs = await getSongThumbnails(song);
|
|
if (existingThumbs.length) {
|
|
continue;
|
|
}
|
|
const fileBaseName = crypto.createHash('sha256').update(song.thumbnailUrl).digest('hex');
|
|
const imageResponse = await fetch(song.thumbnailUrl);
|
|
const avatar = await imageResponse.arrayBuffer();
|
|
await Promise.all(
|
|
this.resizeThumbnailPromiseMaker(
|
|
fileBaseName + '_large',
|
|
200,
|
|
3,
|
|
song.thumbnailUrl,
|
|
['webp', 'avif', 'jpeg'],
|
|
avatar,
|
|
SongThumbnailImageKind.Big
|
|
)
|
|
);
|
|
await Promise.all(
|
|
this.resizeThumbnailPromiseMaker(
|
|
fileBaseName + '_small',
|
|
60,
|
|
3,
|
|
song.thumbnailUrl,
|
|
['webp', 'avif', 'jpeg'],
|
|
avatar,
|
|
SongThumbnailImageKind.Small
|
|
)
|
|
);
|
|
} catch (e) {
|
|
console.error(
|
|
'Could not resize and save song thumbnail for',
|
|
song.pageUrl,
|
|
song.thumbnailUrl,
|
|
e
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
private async checkAndSavePost(post: Post) {
|
|
const hashttags: string[] = HASHTAG_FILTER.split(',');
|
|
const found_tags: Tag[] = post.tags.filter((t: Tag) => hashttags.includes(t.name));
|
|
|
|
const songs = await this.getSongInfoInPost(post);
|
|
|
|
// If we don't have any tags or non-youtube urls, check youtube
|
|
// YT is handled separately, because it requires an API call and therefore is slower
|
|
if (songs.length === 0 && found_tags.length === 0) {
|
|
this.logger.log('Ignoring post', post.url);
|
|
return;
|
|
}
|
|
|
|
await savePost(post, songs);
|
|
|
|
await this.saveAvatar(post.account);
|
|
await this.saveSongThumbnails(songs);
|
|
|
|
this.logger.debug('Saved post', post.url, 'songs', songs);
|
|
|
|
const posts = await getPosts(null, null, 100);
|
|
await saveAtomFeed(createFeed(posts));
|
|
|
|
for (let song of songs) {
|
|
this.logger.debug('Adding to playlist', song);
|
|
await this.addToPlaylist(song);
|
|
}
|
|
}
|
|
|
|
private startWebsocket() {
|
|
const socketLogger = new Logger('Websocket');
|
|
const socket = new WebSocket(
|
|
`wss://${MASTODON_INSTANCE}/api/v1/streaming?type=subscribe&stream=public:local&access_token=${MASTODON_ACCESS_TOKEN}`
|
|
);
|
|
socket.onopen = () => {
|
|
socketLogger.log('Connected to WS');
|
|
};
|
|
socket.onmessage = async (event) => {
|
|
try {
|
|
const data: TimelineEvent = JSON.parse(event.data.toString());
|
|
socketLogger.debug('ES event', data.event);
|
|
if (data.event !== 'update') {
|
|
socketLogger.log('Ignoring ES event', data.event);
|
|
return;
|
|
}
|
|
const post: Post = JSON.parse(data.payload);
|
|
|
|
// Sometimes onmessage is called twice for the same post.
|
|
// This looks to be an issue with automatic reloading in the dev environment,
|
|
// but hard to tell
|
|
if (this.lastPosts.includes(post.id)) {
|
|
socketLogger.log('Skipping post, already handled', post.id);
|
|
return;
|
|
}
|
|
this.lastPosts.push(post.id);
|
|
while (this.lastPosts.length > 10) {
|
|
this.lastPosts.shift();
|
|
}
|
|
await this.checkAndSavePost(post);
|
|
} catch (e) {
|
|
socketLogger.error('error message', event, event.data, e);
|
|
}
|
|
};
|
|
socket.onclose = (event) => {
|
|
socketLogger.warn(
|
|
`Websocket connection to ${MASTODON_INSTANCE} closed. Code: ${event.code}, reason: '${event.reason}'`,
|
|
event
|
|
);
|
|
setTimeout(() => {
|
|
socketLogger.info(`Attempting to reconenct to WS`);
|
|
this.startWebsocket();
|
|
}, 10000);
|
|
};
|
|
socket.onerror = (event) => {
|
|
socketLogger.error(
|
|
`Websocket connection to ${MASTODON_INSTANCE} failed. ${event.type}: ${event.error}, message: '${event.message}'`
|
|
);
|
|
};
|
|
}
|
|
|
|
private async loadPostsSinceLastRun() {
|
|
const now = new Date().toISOString();
|
|
let latestPost = await getPosts(null, now, 1);
|
|
if (latestPost.length > 0) {
|
|
this.logger.log('Last post in DB since', now, latestPost[0].created_at);
|
|
} else {
|
|
this.logger.log('No posts in DB since');
|
|
}
|
|
let u = new URL(`https://${MASTODON_INSTANCE}/api/v1/timelines/public?local=true&limit=40`);
|
|
if (latestPost.length > 0) {
|
|
u.searchParams.append('since_id', latestPost[0].id);
|
|
}
|
|
for (let tag of HASHTAG_FILTER.split(',')) {
|
|
u.searchParams.append('q', '#' + tag);
|
|
}
|
|
const headers = {
|
|
Authorization: `Bearer ${MASTODON_ACCESS_TOKEN}`
|
|
};
|
|
const latestPosts: Post[] = await fetch(u, { headers }).then((r) => r.json());
|
|
this.logger.info('searched posts', latestPosts.length);
|
|
for (const post of latestPosts) {
|
|
await this.checkAndSavePost(post);
|
|
}
|
|
}
|
|
|
|
private constructor() {
|
|
this.logger = new Logger('Timeline');
|
|
this.logger.log('Constructing timeline object');
|
|
this.playlistAdders = [new YoutubePlaylistAdder(), new SpotifyPlaylistAdder()];
|
|
this.startWebsocket();
|
|
|
|
this.loadPostsSinceLastRun()
|
|
.then((_) => {
|
|
this.logger.info('loaded posts since last run');
|
|
})
|
|
.catch((e) => {
|
|
this.logger.error('cannot fetch latest posts', e);
|
|
});
|
|
}
|
|
|
|
public static init() {
|
|
if (this._instance === undefined) {
|
|
this._instance = new TimelineReader();
|
|
}
|
|
}
|
|
|
|
public static get instance(): TimelineReader {
|
|
TimelineReader.init();
|
|
return this._instance;
|
|
}
|
|
}
|