phlaym/moshing-mammut
1
0
Fork 0
Code Issues 3 Pull Requests Projects Releases 8 Activity

support adding to spotify playlist

Browse Source
This commit is contained in:
Max Nuding
2025-07-03 18:38:40 +02:00
parent a8b6a309f0
commit a0757ea3ff
11 changed files with 478 additions and 213 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@ -1,4 +1,5 @@
yt_auth_token yt_auth_token
spotify_auth_token
*.db *.db
feed.xml feed.xml
playbook.yml playbook.yml

51
src/lib/log.ts
View File

@ -33,3 +33,54 @@ export const log = {
return DEV; return DEV;
} }
}; };
export class Logger {
public constructor(private name: string) {}
public static isDebugEnabled(): boolean {
return DEV;
}
public verbose(...params: any[]) {
if (!enableVerboseLog) {
return;
}
console.debug(new Date().toISOString(), `- ${this.name} -`, ...params);
}
public debug(...params: any[]) {
if (!Logger.isDebugEnabled()) {
return;
}
console.debug(new Date().toISOString(), `- ${this.name} -`, ...params);
}
public log(...params: any[]) {
console.log(new Date().toISOString(), `- ${this.name} -`, ...params);
}
public info(...params: any[]) {
console.info(new Date().toISOString(), `- ${this.name} -`, ...params);
}
public warn(...params: any[]) {
console.warn(new Date().toISOString(), `- ${this.name} -`, ...params);
}
public error(...params: any[]) {
console.error(new Date().toISOString(), `- ${this.name} -`, ...params);
}
public static error(...params: any[]) {
console.error(new Date().toISOString(), ...params);
}
public static debug(...params: any[]) {
if (!Logger.isDebugEnabled()) {
return;
}
console.debug(new Date().toISOString(), ...params);
}
public static log(...params: any[]) {
console.log(new Date().toISOString(), ...params);
}
public static info(...params: any[]) {
console.info(new Date().toISOString(), ...params);
}
public static warn(...params: any[]) {
console.warn(new Date().toISOString(), ...params);
}
}

2
src/lib/odesliResponse.ts
View File

@ -3,6 +3,8 @@ import type { SongThumbnailImage } from '$lib/mastodon/response';
export type SongInfo = { export type SongInfo = {
pageUrl: string; pageUrl: string;
youtubeUrl?: string; youtubeUrl?: string;
spotifyUrl?: string;
spotifyUri?: string;
type: 'song' | 'album'; type: 'song' | 'album';
title?: string; title?: string;
artistName?: string; artistName?: string;

87
src/lib/server/db.ts
View File

@ -1,10 +1,12 @@
import { IGNORE_USERS, MASTODON_INSTANCE } from '$env/static/private'; import { IGNORE_USERS, MASTODON_INSTANCE } from '$env/static/private';
import { enableVerboseLog, log } from '$lib/log'; import { enableVerboseLog, Logger } from '$lib/log';
import type { Account, AccountAvatar, Post, SongThumbnailImage, Tag } from '$lib/mastodon/response'; import type { Account, AccountAvatar, Post, SongThumbnailImage, Tag } from '$lib/mastodon/response';
import type { SongInfo } from '$lib/odesliResponse'; import type { SongInfo } from '$lib/odesliResponse';
import { TimelineReader } from '$lib/server/timeline'; import { TimelineReader } from '$lib/server/timeline';
import sqlite3 from 'sqlite3'; import sqlite3 from 'sqlite3';
const logger = new Logger('Database');
type FilterParameter = { type FilterParameter = {
$limit?: number | undefined | null; $limit?: number | undefined | null;
$since?: string | undefined | null; $since?: string | undefined | null;
@ -37,6 +39,8 @@ type SongRow = {
overviewUrl?: string; overviewUrl?: string;
type: 'album' | 'song'; type: 'album' | 'song';
youtubeUrl?: string; youtubeUrl?: string;
spotifyUrl?: string;
spotifyUri?: string;
title?: string; title?: string;
artistName?: string; artistName?: string;
thumbnailUrl?: string; thumbnailUrl?: string;
@ -81,15 +85,15 @@ let databaseReady = false;
if (enableVerboseLog) { if (enableVerboseLog) {
sqlite3.verbose(); sqlite3.verbose();
db.on('change', (t, d, table, rowid) => { db.on('change', (t, d, table, rowid) => {
log.verbose('DB change event', t, d, table, rowid); logger.verbose('DB change event', t, d, table, rowid);
}); });
db.on('trace', (sql) => { db.on('trace', (sql) => {
log.verbose('Running', sql); logger.verbose('Running', sql);
}); });
db.on('profile', (sql) => { db.on('profile', (sql) => {
log.verbose('Finished', sql); logger.verbose('Finished', sql);
}); });
} }
@ -97,7 +101,7 @@ function applyDbMigration(migration: Migration): Promise<void> {
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
db.exec(migration.statement, (err) => { db.exec(migration.statement, (err) => {
if (err !== null) { if (err !== null) {
log.error(`Failed to apply migration ${migration.name}`, err); logger.error(`Failed to apply migration ${migration.name}`, err);
reject(err); reject(err);
return; return;
} }
@ -118,31 +122,31 @@ async function applyMigration(migration: Migration) {
if (post.songs && post.songs.length) { if (post.songs && post.songs.length) {
continue; continue;
} }
log.info( logger.info(
`Fetching songs for existing post ${current.toString().padStart(4, '0')} of ${total}`, `Fetching songs for existing post ${current.toString().padStart(4, '0')} of ${total}`,
post.url post.url
); );
const songs = await TimelineReader.getSongInfoInPost(post); const songs = await TimelineReader.getSongInfoInPost(post);
await saveSongInfoData(post.url, songs); await saveSongInfoData(post.url, songs);
log.debug(`Fetched ${songs.length} songs for existing post`, post.url); logger.debug(`Fetched ${songs.length} songs for existing post`, post.url);
} }
log.debug(`Finished fetching songs`); logger.debug(`Finished fetching songs`);
} else { } else {
await applyDbMigration(migration); await applyDbMigration(migration);
} }
} }
db.on('open', () => { db.on('open', () => {
log.info('Opened database'); logger.info('Opened database');
db.serialize(); db.serialize();
db.run('CREATE TABLE IF NOT EXISTS "migrations" ("id" integer,"name" TEXT, PRIMARY KEY (id))'); db.run('CREATE TABLE IF NOT EXISTS "migrations" ("id" integer,"name" TEXT, PRIMARY KEY (id))');
db.all('SELECT id FROM migrations', (err, rows: Migration[]) => { db.all('SELECT id FROM migrations', (err, rows: Migration[]) => {
if (err !== null) { if (err !== null) {
log.error('Could not fetch existing migrations', err); logger.error('Could not fetch existing migrations', err);
databaseReady = true; databaseReady = true;
return; return;
} }
log.debug('Already applied migrations', rows); logger.debug('Already applied migrations', rows);
const appliedMigrations: Set<number> = new Set(rows.map((row) => row['id'])); const appliedMigrations: Set<number> = new Set(rows.map((row) => row['id']));
const toApply = getMigrations().filter((m) => !appliedMigrations.has(m.id)); const toApply = getMigrations().filter((m) => !appliedMigrations.has(m.id));
let remaining = toApply.length; let remaining = toApply.length;
@ -159,7 +163,7 @@ db.on('open', () => {
databaseReady = true; databaseReady = true;
} }
if (err !== null) { if (err !== null) {
log.error(`Failed to apply migration ${migration.name}`, err); logger.error(`Failed to apply migration ${migration.name}`, err);
return; return;
} }
db.run( db.run(
@ -167,10 +171,10 @@ db.on('open', () => {
[migration.id, migration.name], [migration.id, migration.name],
(e: Error) => { (e: Error) => {
if (e !== null) { if (e !== null) {
log.error(`Failed to mark migration ${migration.name} as applied`, e); logger.error(`Failed to mark migration ${migration.name} as applied`, e);
return; return;
} }
log.info(`Applied migration ${migration.name}`); logger.info(`Applied migration ${migration.name}`);
} }
); );
}); });
@ -178,7 +182,7 @@ db.on('open', () => {
}); });
}); });
db.on('error', (err) => { db.on('error', (err) => {
log.error('Error opening database', err); logger.error('Error opening database', err);
}); });
function getMigrations(): Migration[] { function getMigrations(): Migration[] {
@ -313,6 +317,13 @@ function getMigrations(): Migration[] {
statement: ` statement: `
ALTER TABLE songs ADD COLUMN thumbnailWidth INTEGER NULL; ALTER TABLE songs ADD COLUMN thumbnailWidth INTEGER NULL;
ALTER TABLE songs ADD COLUMN thumbnailHeight INTEGER NULL;` ALTER TABLE songs ADD COLUMN thumbnailHeight INTEGER NULL;`
},
{
id: 8,
name: 'song spotify url/uri',
statement: `
ALTER TABLE songs ADD COLUMN spotifyUrl TEXT NULL;
ALTER TABLE songs ADD COLUMN spotifyUri TEXT NULL;`
} }
]; ];
} }
@ -321,9 +332,9 @@ async function waitReady(): Promise<void> {
// Simpler than a semaphore and is really only needed on startup // Simpler than a semaphore and is really only needed on startup
return new Promise((resolve) => { return new Promise((resolve) => {
const interval = setInterval(() => { const interval = setInterval(() => {
log.verbose('Waiting for database to be ready'); logger.verbose('Waiting for database to be ready');
if (databaseReady) { if (databaseReady) {
log.verbose('DB is ready'); logger.verbose('DB is ready');
clearInterval(interval); clearInterval(interval);
resolve(); resolve();
} }
@ -354,7 +365,7 @@ function saveAccountData(account: Account): Promise<void> {
], ],
(err) => { (err) => {
if (err !== null) { if (err !== null) {
log.error(`Could not insert/update account ${account.id}`, err); logger.error(`Could not insert/update account ${account.id}`, err);
reject(err); reject(err);
return; return;
} }
@ -377,7 +388,7 @@ function savePostData(post: Post): Promise<void> {
[post.id, post.content, post.created_at, post.url, post.account.url], [post.id, post.content, post.created_at, post.url, post.account.url],
(postErr) => { (postErr) => {
if (postErr !== null) { if (postErr !== null) {
log.error(`Could not insert post ${post.url}`, postErr); logger.error(`Could not insert post ${post.url}`, postErr);
reject(postErr); reject(postErr);
return; return;
} }
@ -405,7 +416,7 @@ function savePostTagData(post: Post): Promise<void> {
[tag.url, tag.name], [tag.url, tag.name],
(tagErr) => { (tagErr) => {
if (tagErr !== null) { if (tagErr !== null) {
log.error(`Could not insert/update tag ${tag.url}`, tagErr); logger.error(`Could not insert/update tag ${tag.url}`, tagErr);
reject(tagErr); reject(tagErr);
return; return;
} }
@ -414,7 +425,7 @@ function savePostTagData(post: Post): Promise<void> {
[post.url, tag.url], [post.url, tag.url],
(posttagserr) => { (posttagserr) => {
if (posttagserr !== null) { if (posttagserr !== null) {
log.error(`Could not insert poststags ${tag.url}, ${post.url}`, posttagserr); logger.error(`Could not insert poststags ${tag.url}, ${post.url}`, posttagserr);
reject(posttagserr); reject(posttagserr);
return; return;
} }
@ -444,14 +455,16 @@ function saveSongInfoData(postUrl: string, songs: SongInfo[]): Promise<void> {
for (const song of songs) { for (const song of songs) {
db.run( db.run(
` `
INSERT INTO songs (postedUrl, overviewUrl, type, youtubeUrl, title, artistName, thumbnailUrl, post_url, thumbnailWidth, thumbnailHeight) INSERT INTO songs (postedUrl, overviewUrl, type, youtubeUrl, spotifyUrl, spotifyUri, title, artistName, thumbnailUrl, post_url, thumbnailWidth, thumbnailHeight)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
`, `,
[ [
song.postedUrl, song.postedUrl,
song.pageUrl, song.pageUrl,
song.type, song.type,
song.youtubeUrl, song.youtubeUrl,
song.spotifyUrl,
song.spotifyUri,
song.title, song.title,
song.artistName, song.artistName,
song.thumbnailUrl, song.thumbnailUrl,
@ -461,7 +474,7 @@ function saveSongInfoData(postUrl: string, songs: SongInfo[]): Promise<void> {
], ],
(songErr) => { (songErr) => {
if (songErr !== null) { if (songErr !== null) {
log.error(`Could not insert song ${song.postedUrl}`, songErr); logger.error(`Could not insert song ${song.postedUrl}`, songErr);
reject(songErr); reject(songErr);
return; return;
} }
@ -479,20 +492,20 @@ function saveSongInfoData(postUrl: string, songs: SongInfo[]): Promise<void> {
} }
export async function savePost(post: Post, songs: SongInfo[]) { export async function savePost(post: Post, songs: SongInfo[]) {
log.debug(`Saving post ${post.url}`); logger.debug(`Saving post ${post.url}`);
if (!databaseReady) { if (!databaseReady) {
await waitReady(); await waitReady();
} }
const account = post.account; const account = post.account;
await saveAccountData(account); await saveAccountData(account);
log.debug(`Saved account data ${post.url}`); logger.debug(`Saved account data ${post.url}`);
await savePostData(post); await savePostData(post);
log.debug(`Saved post data ${post.url}`); logger.debug(`Saved post data ${post.url}`);
await savePostTagData(post); await savePostTagData(post);
log.debug(`Saved ${post.tags.length} tag data ${post.url}`); logger.debug(`Saved ${post.tags.length} tag data ${post.url}`);
await saveSongInfoData(post.url, songs); await saveSongInfoData(post.url, songs);
log.debug( logger.debug(
`Saved ${songs.length} song info data ${post.url}`, `Saved ${songs.length} song info data ${post.url}`,
songs.map((s) => s.thumbnailHeight) songs.map((s) => s.thumbnailHeight)
); );
@ -511,7 +524,7 @@ function getPostData(filterQuery: string, params: FilterParameter): Promise<Post
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
db.all(sql, params, (err, rows: PostRow[]) => { db.all(sql, params, (err, rows: PostRow[]) => {
if (err != null) { if (err != null) {
log.error('Error loading posts', err); logger.error('Error loading posts', err);
reject(err); reject(err);
return; return;
} }
@ -530,7 +543,7 @@ function getTagData(postIdsParams: string, postIds: string[]): Promise<Map<strin
postIds, postIds,
(tagErr, tagRows: PostTagRow[]) => { (tagErr, tagRows: PostTagRow[]) => {
if (tagErr != null) { if (tagErr != null) {
log.error('Error loading post tags', tagErr); logger.error('Error loading post tags', tagErr);
reject(tagErr); reject(tagErr);
return; return;
} }
@ -551,14 +564,14 @@ function getTagData(postIdsParams: string, postIds: string[]): Promise<Map<strin
function getSongData(postIdsParams: string, postIds: string[]): Promise<Map<string, SongInfo[]>> { function getSongData(postIdsParams: string, postIds: string[]): Promise<Map<string, SongInfo[]>> {
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
db.all( db.all(
`SELECT post_url, songs.postedUrl, songs.overviewUrl, songs.type, songs.youtubeUrl, `SELECT post_url, songs.postedUrl, songs.overviewUrl, songs.type, songs.youtubeUrl, songs.spotifyUri, songs.spotifyUri,
songs.title, songs.artistName, songs.thumbnailUrl, songs.post_url, songs.thumbnailWidth, songs.thumbnailHeight songs.title, songs.artistName, songs.thumbnailUrl, songs.post_url, songs.thumbnailWidth, songs.thumbnailHeight
FROM songs FROM songs
WHERE post_url IN (${postIdsParams});`, WHERE post_url IN (${postIdsParams});`,
postIds, postIds,
(tagErr, tagRows: SongRow[]) => { (tagErr, tagRows: SongRow[]) => {
if (tagErr != null) { if (tagErr != null) {
log.error('Error loading post songs', tagErr); logger.error('Error loading post songs', tagErr);
reject(tagErr); reject(tagErr);
return; return;
} }
@ -567,6 +580,8 @@ function getSongData(postIdsParams: string, postIds: string[]): Promise<Map<stri
const info = { const info = {
pageUrl: item.overviewUrl, pageUrl: item.overviewUrl,
youtubeUrl: item.youtubeUrl, youtubeUrl: item.youtubeUrl,
spotifyUrl: item.spotifyUrl,
spotifyUri: item.spotifyUri,
type: item.type, type: item.type,
title: item.title, title: item.title,
artistName: item.artistName, artistName: item.artistName,
@ -580,7 +595,7 @@ function getSongData(postIdsParams: string, postIds: string[]): Promise<Map<stri
}, },
new Map() new Map()
); );
log.verbose('songMap', songMap); logger.verbose('songMap', songMap);
resolve(songMap); resolve(songMap);
} }
); );
@ -599,7 +614,7 @@ function getAvatarData(
accountUrls, accountUrls,
(err, rows: AccountAvatarRow[]) => { (err, rows: AccountAvatarRow[]) => {
if (err != null) { if (err != null) {
log.error('Error loading avatars', err); logger.error('Error loading avatars', err);
reject(err); reject(err);
return; return;
} }
@ -633,7 +648,7 @@ function getSongThumbnailData(
thumbUrls, thumbUrls,
(err, rows: SongThumbnailAvatarRow[]) => { (err, rows: SongThumbnailAvatarRow[]) => {
if (err != null) { if (err != null) {
log.error('Error loading avatars', err); logger.error('Error loading avatars', err);
reject(err); reject(err);
return; return;
} }

159
src/lib/server/oauthPlaylistAdder.ts Normal file
View File

@ -0,0 +1,159 @@
import { Logger } from '$lib/log';
import type { OauthResponse } from '$lib/mastodon/response';
import fs from 'fs/promises';
export abstract class OauthPlaylistAdder {
/// How many minutes before expiry the token will be refreshed
protected refresh_time: number = 15;
protected logger: Logger = new Logger('OauthPlaylistAdder');
protected constructor(
protected apiBase: string,
protected token_file_name: string
) {}
public async authCodeExists(): Promise<boolean> {
try {
const fileHandle = await fs.open(this.token_file_name);
await fileHandle.close();
return true;
} catch {
this.logger.info('No auth token yet, authorizing...');
return false;
}
}
protected constructAuthUrlInternal(
endpointUrl: string,
clientId: string,
scope: string,
redirectUri: URL,
additionalParameters: Map<string, string> = new Map()
): URL {
const authUrl = new URL(endpointUrl);
authUrl.searchParams.append('client_id', clientId);
authUrl.searchParams.append('redirect_uri', redirectUri.toString());
authUrl.searchParams.append('response_type', 'code');
authUrl.searchParams.append('scope', scope);
for (let p of additionalParameters.entries()) {
authUrl.searchParams.append(p[0], p[1]);
}
return authUrl;
}
public async receivedAuthCodeInternal(
tokenUrl: URL,
clientId: string,
code: string,
url: URL,
client_secret?: string,
customHeader?: HeadersInit
) {
this.logger.debug('received code');
const params = new URLSearchParams();
params.append('client_id', clientId);
params.append('code', code);
params.append('grant_type', 'authorization_code');
params.append('redirect_uri', `${url.origin}${url.pathname}`);
if (client_secret) {
params.append('client_secret', client_secret);
}
this.logger.debug('sending token req', params);
const resp: OauthResponse = await fetch(tokenUrl, {
method: 'POST',
body: params,
headers: customHeader
}).then((r) => r.json());
this.logger.debug('received access token', resp);
let expiration = new Date();
expiration.setTime(expiration.getTime() + resp.expires_in * 1000);
expiration.setSeconds(expiration.getSeconds() + resp.expires_in);
resp.expires = expiration;
await fs.writeFile(this.token_file_name, JSON.stringify(resp));
}
protected async auth(): Promise<OauthResponse | null> {
try {
const token_file = await fs.readFile(this.token_file_name, { encoding: 'utf8' });
let token = JSON.parse(token_file);
if (token.expires) {
if (typeof token.expires === typeof '') {
token.expires = new Date(token.expires);
}
}
return token;
} catch (e) {
this.logger.error('Could not read access token', e);
return null;
}
}
protected async shouldRefreshToken(): Promise<{ token: OauthResponse; refresh: boolean } | null> {
const token = await this.auth();
if (token == null || !token?.expires) {
return null;
}
let refreshAt = new Date();
refreshAt.setTime(refreshAt.getTime() - this.refresh_time * 60 * 1000);
this.logger.info('token expiry', token.expires, 'vs refresh @', refreshAt);
if (token.expires.getTime() > refreshAt.getTime()) {
return {
token: token,
refresh: false
};
}
this.logger.info(
'Token expires',
token.expires,
token.expires.getTime(),
`which is after the refresh time`,
refreshAt,
refreshAt.getTime()
);
return {
token: token,
refresh: true
};
}
protected async requestRefreshToken(
tokenUrl: URL,
clientId: string,
refresh_token: string,
redirect_uri?: string,
client_secret?: string,
customHeader?: HeadersInit
) {
const params = new URLSearchParams();
params.append('client_id', clientId);
params.append('grant_type', 'refresh_token');
params.append('refresh_token', refresh_token);
if (client_secret) {
params.append('client_secret', client_secret);
}
if (redirect_uri) {
params.append('redirect_uri', redirect_uri);
}
this.logger.debug('sending token req', params);
const resp: OauthResponse = await fetch(tokenUrl, {
method: 'POST',
body: params,
headers: customHeader
}).then((r) => r.json());
this.logger.verbose('received access token', resp);
if (resp.error) {
this.logger.error('token resp error', resp);
return null;
}
if (!resp.refresh_token) {
resp.refresh_token = refresh_token;
}
let expiration = new Date();
expiration.setTime(expiration.getTime() + resp.expires_in * 1000);
expiration.setSeconds(expiration.getSeconds() + resp.expires_in);
resp.expires = expiration;
await fs.writeFile(this.token_file_name, JSON.stringify(resp));
return resp;
}
}

122
src/lib/server/spotifyPlaylistAdder.ts Normal file
View File

@ -0,0 +1,122 @@
import { SPOTIFY_CLIENT_ID, SPOTIFY_CLIENT_SECRET, SPOTIFY_PLAYLIST_ID } from '$env/static/private';
import { Logger } from '$lib/log';
import type { OauthResponse } from '$lib/mastodon/response';
import type { SongInfo } from '$lib/odesliResponse';
import { OauthPlaylistAdder } from './oauthPlaylistAdder';
export class SpotifyPlaylistAdder extends OauthPlaylistAdder {
public constructor() {
super('https://api.spotify.com/v1', 'spotify_auth_token');
this.logger = new Logger('SpotifyPlaylistAdder');
}
public constructAuthUrl(redirectUri: URL): URL {
const endpoint = 'https://accounts.spotify.com/authorize';
return this.constructAuthUrlInternal(
endpoint,
SPOTIFY_CLIENT_ID,
'playlist-modify-private playlist-modify-public',
redirectUri
);
}
public async receivedAuthCode(code: string, url: URL) {
this.logger.debug('received code');
const authHeader =
'Basic ' + Buffer.from(SPOTIFY_CLIENT_ID + ':' + SPOTIFY_CLIENT_SECRET).toString('base64');
const tokenUrl = new URL('https://accounts.spotify.com/api/token');
await this.receivedAuthCodeInternal(tokenUrl, SPOTIFY_CLIENT_ID, code, url, undefined, {
Authorization: authHeader
});
}
private async refreshToken(force: boolean = false): Promise<OauthResponse | null> {
const tokenInfo = await this.shouldRefreshToken();
if (tokenInfo == null) {
return null;
}
let token = tokenInfo.token;
if (!tokenInfo.refresh && !force) {
return token;
}
if (!token.refresh_token) {
this.logger.error('Need to refresh access token, but no refresh token provided');
return null;
}
const authHeader =
'Basic ' + Buffer.from(SPOTIFY_CLIENT_ID + ':' + SPOTIFY_CLIENT_SECRET).toString('base64');
const tokenUrl = new URL('https://accounts.spotify.com/api/token');
return await this.requestRefreshToken(
tokenUrl,
SPOTIFY_CLIENT_ID,
token.refresh_token,
undefined,
undefined,
{ Authorization: authHeader }
);
}
private async addToPlaylistRetry(song: SongInfo, remaning: number = 3) {
if (remaning < 0) {
this.logger.error('max retries reached, song will not be added to spotify playlist');
}
this.logger.debug('addToSpotifyPlaylist', remaning);
const token = await this.refreshToken();
if (token == null) {
return;
}
if (!SPOTIFY_PLAYLIST_ID || SPOTIFY_PLAYLIST_ID === 'CHANGE_ME') {
this.logger.debug('no spotify playlist ID configured');
return;
}
if (!song.spotifyUri) {
this.logger.info('Skip adding song to spotify playlist, no Uri', song);
return;
}
/*
const playlistItemsUrl = new URL(`${this.apiBase}/playlists/${SPOTIFY_PLAYLIST_ID}/tracks`);
playlistItemsUrl.searchParams.append('videoId', youtubeId);
playlistItemsUrl.searchParams.append('playlistId', SPOTIFY_PLAYLIST_ID);
playlistItemsUrl.searchParams.append('part', 'id');*/
/*const existingPlaylistItem = await fetch(this.apiBase + '/playlistItems', {
headers: { Authorization: `${token.token_type} ${token.access_token}` }
}).then((r) => r.json());
log.debug('existingPlaylistItem', existingPlaylistItem);
if (existingPlaylistItem.pageInfo && existingPlaylistItem.pageInfo.totalResults > 0) {
log.info('Item already in playlist');
return;
}*/
//const searchParams = new URLSearchParams([['part', 'snippet']]);
const options: RequestInit = {
method: 'POST',
headers: { Authorization: `${token.token_type} ${token.access_token}` },
body: JSON.stringify({
uris: [song.spotifyUri]
})
};
const apiUrl = new URL(`${this.apiBase}/playlists/${SPOTIFY_PLAYLIST_ID}/tracks`);
const resp = await fetch(apiUrl, options);
const respObj = await resp.json();
if (respObj.error) {
this.logger.debug('Add to playlist failed', respObj.error);
if (respObj.error.status === 401) {
const token = await this.refreshToken(true);
if (token == null) {
return;
}
this.addToPlaylistRetry(song, remaning--);
}
} else {
this.logger.info('Added to playlist', song.spotifyUri, song.title);
}
}
public async addToPlaylist(song: SongInfo) {
await this.addToPlaylistRetry(song);
}
}

86
src/lib/server/timeline.ts
View File

@ -5,7 +5,7 @@ import {
ODESLI_API_KEY, ODESLI_API_KEY,
YOUTUBE_API_KEY YOUTUBE_API_KEY
} from '$env/static/private'; } from '$env/static/private';
import { log } from '$lib/log'; import { log, Logger } from '$lib/log';
import type { import type {
Account, Account,
AccountAvatar, AccountAvatar,
@ -34,6 +34,7 @@ import { console } from 'inspector/promises';
import sharp from 'sharp'; import sharp from 'sharp';
import { URL, URLSearchParams } from 'url'; import { URL, URLSearchParams } from 'url';
import { WebSocket } from 'ws'; import { WebSocket } from 'ws';
import { SpotifyPlaylistAdder } from './spotifyPlaylistAdder';
const URL_REGEX = new RegExp(/href="(?<postUrl>[^>]+?)" target="_blank"/gm); 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 INVIDIOUS_REGEX = new RegExp(/invidious.*?watch.*?v=(?<videoId>[a-zA-Z_0-9-]+)/gm);
@ -45,6 +46,7 @@ export class TimelineReader {
private static _instance: TimelineReader; private static _instance: TimelineReader;
private lastPosts: string[] = []; private lastPosts: string[] = [];
private youtubePlaylistAdder: YoutubePlaylistAdder; private youtubePlaylistAdder: YoutubePlaylistAdder;
private spotifyPlaylistAdder: SpotifyPlaylistAdder;
private static async isMusicVideo(videoId: string) { private static async isMusicVideo(videoId: string) {
if (!YOUTUBE_API_KEY || YOUTUBE_API_KEY === 'CHANGE_ME') { if (!YOUTUBE_API_KEY || YOUTUBE_API_KEY === 'CHANGE_ME') {
@ -168,10 +170,13 @@ export class TimelineReader {
return null; return null;
} }
} }
const spotify: Platform = 'spotify';
return { return {
...info, ...info,
pageUrl: odesliInfo.pageUrl, pageUrl: odesliInfo.pageUrl,
youtubeUrl: odesliInfo.linksByPlatform[platform]?.url, youtubeUrl: odesliInfo.linksByPlatform[platform]?.url,
spotifyUrl: odesliInfo.linksByPlatform[spotify]?.url,
spotifyUri: odesliInfo.linksByPlatform[spotify]?.nativeAppUriDesktop,
postedUrl: url.toString() postedUrl: url.toString()
} as SongInfo; } as SongInfo;
} catch (e) { } catch (e) {
@ -263,8 +268,8 @@ export class TimelineReader {
} }
*/ */
private async addToPlaylist(song: SongInfo) { private async addToPlaylist(song: SongInfo) {
//await this.addToYoutubePlaylist(song);
await this.youtubePlaylistAdder.addToPlaylist(song); await this.youtubePlaylistAdder.addToPlaylist(song);
await this.spotifyPlaylistAdder.addToPlaylist(song);
} }
private static async resizeAvatar( private static async resizeAvatar(
@ -472,78 +477,28 @@ export class TimelineReader {
} }
private startWebsocket() { private startWebsocket() {
const socketLogger = new Logger('Websocket');
const socket = new WebSocket( const socket = new WebSocket(
`wss://${MASTODON_INSTANCE}/api/v1/streaming?type=subscribe&stream=public:local&access_token=${MASTODON_ACCESS_TOKEN}` `wss://${MASTODON_INSTANCE}/api/v1/streaming?type=subscribe&stream=public:local&access_token=${MASTODON_ACCESS_TOKEN}`
); );
socket.onopen = () => { socket.onopen = () => {
log.log('Connected to WS'); socketLogger.log('Connected to WS');
}; };
socket.onmessage = async (event) => { socket.onmessage = async (event) => {
try { try {
/*
let token: OauthResponse;
try {
const youtube_token_file = await fs.readFile('yt_auth_token', { encoding: 'utf8' });
token = JSON.parse(youtube_token_file);
if (token.expires) {
if (typeof token.expires === typeof '') {
token.expires = new Date(token.expires);
}
let now = new Date();
now.setTime(now.getTime() - 15 * 60 * 1000);
log.info('token expiry', token.expires, 'vs refresh @', now);
if (token.expires.getTime() <= now.getTime()) {
log.info(
'YT token expires',
token.expires,
token.expires.getTime(),
'which is less than 15 minutes from now',
now,
now.getTime()
);
const tokenUrl = new URL('https://oauth2.googleapis.com/token');
const params = new URLSearchParams();
params.append('client_id', YOUTUBE_CLIENT_ID);
params.append('client_secret', YOUTUBE_CLIENT_SECRET);
params.append('refresh_token', token.refresh_token || '');
params.append('grant_type', 'refresh_token');
params.append('redirect_uri', `${BASE_URL}/ytauth`);
if (token.refresh_token) {
log.debug('sending token req', params);
const resp = await fetch(tokenUrl, {
method: 'POST',
body: params
}).then((r) => r.json());
if (!resp.error) {
if (!resp.refresh_token) {
resp.refresh_token = token.refresh_token;
}
let expiration = new Date();
expiration.setSeconds(expiration.getSeconds() + resp.expires_in);
resp.expires = expiration;
await fs.writeFile('yt_auth_token', JSON.stringify(resp));
} else {
log.error('token resp error', resp);
}
} else {
log.error('no refresg token');
}
}
}
} catch (e) {
log.error('onmessage Could not read youtube access token', e);
}
*/
const data: TimelineEvent = JSON.parse(event.data.toString()); const data: TimelineEvent = JSON.parse(event.data.toString());
log.debug('ES event', data.event); socketLogger.debug('ES event', data.event);
if (data.event !== 'update') { if (data.event !== 'update') {
log.log('Ignoring ES event', data.event); socketLogger.log('Ignoring ES event', data.event);
return; return;
} }
const post: Post = JSON.parse(data.payload); 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)) { if (this.lastPosts.includes(post.id)) {
log.log('Skipping post, already handled', post.id); socketLogger.log('Skipping post, already handled', post.id);
return; return;
} }
this.lastPosts.push(post.id); this.lastPosts.push(post.id);
@ -552,21 +507,21 @@ export class TimelineReader {
} }
await this.checkAndSavePost(post); await this.checkAndSavePost(post);
} catch (e) { } catch (e) {
log.error('error message', event, event.data, e); socketLogger.error('error message', event, event.data, e);
} }
}; };
socket.onclose = (event) => { socket.onclose = (event) => {
log.warn( socketLogger.warn(
`Websocket connection to ${MASTODON_INSTANCE} closed. Code: ${event.code}, reason: '${event.reason}'`, `Websocket connection to ${MASTODON_INSTANCE} closed. Code: ${event.code}, reason: '${event.reason}'`,
event event
); );
setTimeout(() => { setTimeout(() => {
log.info(`Attempting to reconenct to WS`); socketLogger.info(`Attempting to reconenct to WS`);
this.startWebsocket(); this.startWebsocket();
}, 10000); }, 10000);
}; };
socket.onerror = (event) => { socket.onerror = (event) => {
log.error( socketLogger.error(
`Websocket connection to ${MASTODON_INSTANCE} failed. ${event.type}: ${event.error}, message: '${event.message}'` `Websocket connection to ${MASTODON_INSTANCE} failed. ${event.type}: ${event.error}, message: '${event.message}'`
); );
}; };
@ -600,6 +555,7 @@ export class TimelineReader {
private constructor() { private constructor() {
log.log('Constructing timeline object'); log.log('Constructing timeline object');
this.youtubePlaylistAdder = new YoutubePlaylistAdder(); this.youtubePlaylistAdder = new YoutubePlaylistAdder();
this.spotifyPlaylistAdder = new SpotifyPlaylistAdder();
this.startWebsocket(); this.startWebsocket();
this.loadPostsSinceLastRun() this.loadPostsSinceLastRun()

149
src/lib/server/ytPlaylistAdder.ts
View File

@ -7,126 +7,62 @@ import {
import { log } from '$lib/log'; import { log } from '$lib/log';
import type { OauthResponse } from '$lib/mastodon/response'; import type { OauthResponse } from '$lib/mastodon/response';
import type { SongInfo } from '$lib/odesliResponse'; import type { SongInfo } from '$lib/odesliResponse';
import fs from 'fs/promises'; import { OauthPlaylistAdder } from './oauthPlaylistAdder';
export class YoutubePlaylistAdder { export class YoutubePlaylistAdder extends OauthPlaylistAdder {
private apiBase: string = 'https://www.googleapis.com/youtube/v3'; public constructor() {
private token_file_name: string = 'yt_auth_token'; super('https://www.googleapis.com/youtube/v3', 'yt_auth_token');
/// How many minutes before expiry the token will be refreshed
private refresh_time: number = 15;
public async authCodeExists(): Promise<boolean> {
try {
const fileHandle = await fs.open(this.token_file_name);
await fileHandle.close();
return true;
} catch {
log.info('No auth token yet, authorizing...');
return false;
}
} }
public constructAuthUrl(redirectUri: URL): URL { public constructAuthUrl(redirectUri: URL): URL {
let additionalParameters = new Map([
['access_type', 'offline'],
['include_granted_scopes', 'false']
]);
const endpoint = 'https://accounts.google.com/o/oauth2/v2/auth'; const endpoint = 'https://accounts.google.com/o/oauth2/v2/auth';
const authUrl = new URL(endpoint); return this.constructAuthUrlInternal(
authUrl.searchParams.append('client_id', YOUTUBE_CLIENT_ID); endpoint,
authUrl.searchParams.append('redirect_uri', redirectUri.toString()); YOUTUBE_CLIENT_ID,
authUrl.searchParams.append('response_type', 'code'); 'https://www.googleapis.com/auth/youtube',
authUrl.searchParams.append('scope', 'https://www.googleapis.com/auth/youtube'); redirectUri,
authUrl.searchParams.append('access_type', 'offline'); additionalParameters
authUrl.searchParams.append('include_granted_scopes', 'false'); );
return authUrl;
} }
public async receivedAuthCode(code: string, url: URL) { public async receivedAuthCode(code: string, url: URL) {
log.debug('received code'); log.debug('received code');
const tokenUrl = new URL('https://oauth2.googleapis.com/token'); const tokenUrl = new URL('https://oauth2.googleapis.com/token');
const params = new URLSearchParams(); await this.receivedAuthCodeInternal(
params.append('client_id', YOUTUBE_CLIENT_ID); tokenUrl,
params.append('client_secret', YOUTUBE_CLIENT_SECRET); YOUTUBE_CLIENT_ID,
params.append('code', code); code,
params.append('grant_type', 'authorization_code'); url,
params.append('redirect_uri', `${url.origin}${url.pathname}`); YOUTUBE_CLIENT_SECRET
log.debug('sending token req', params); );
const resp: OauthResponse = await fetch(tokenUrl, {
method: 'POST',
body: params
}).then((r) => r.json());
log.debug('received access token', resp);
let expiration = new Date();
expiration.setTime(expiration.getTime() + resp.expires_in * 1000);
expiration.setSeconds(expiration.getSeconds() + resp.expires_in);
resp.expires = expiration;
await fs.writeFile(this.token_file_name, JSON.stringify(resp));
}
private async auth(): Promise<OauthResponse | null> {
try {
const youtube_token_file = await fs.readFile(this.token_file_name, { encoding: 'utf8' });
let token = JSON.parse(youtube_token_file);
log.debug('read youtube access token', token);
if (token.expires) {
if (typeof token.expires === typeof '') {
token.expires = new Date(token.expires);
}
}
return token;
} catch (e) {
log.error('Could not read youtube access token', e);
return null;
}
} }
private async refreshToken(): Promise<OauthResponse | null> { private async refreshToken(): Promise<OauthResponse | null> {
const token = await this.auth(); const tokenInfo = await this.shouldRefreshToken();
if (token == null || !token?.expires) { if (tokenInfo == null) {
return null; return null;
} }
let now = new Date(); let token = tokenInfo.token;
now.setTime(now.getTime() - this.refresh_time * 60 * 1000); if (!tokenInfo.refresh) {
log.info('token expiry', token.expires, 'vs refresh @', now);
if (token.expires.getTime() > now.getTime()) {
return token; return token;
} }
log.info(
'YT token expires',
token.expires,
token.expires.getTime(),
`which is less than ${this.refresh_time} minutes from now`,
now,
now.getTime()
);
const tokenUrl = new URL('https://oauth2.googleapis.com/token');
const params = new URLSearchParams();
params.append('client_id', YOUTUBE_CLIENT_ID);
params.append('client_secret', YOUTUBE_CLIENT_SECRET);
params.append('refresh_token', token.refresh_token || '');
params.append('grant_type', 'refresh_token');
params.append('redirect_uri', `${BASE_URL}/ytauth`);
if (!token.refresh_token) { if (!token.refresh_token) {
log.error('Need to refresh access token, but no refresh token provided'); log.error('Need to refresh access token, but no refresh token provided');
return null; return null;
} }
log.debug('sending token req', params);
let resp: OauthResponse = await fetch(tokenUrl, { const tokenUrl = new URL('https://oauth2.googleapis.com/token');
method: 'POST', return await this.requestRefreshToken(
body: params tokenUrl,
}).then((r) => r.json()); YOUTUBE_CLIENT_ID,
if (resp.error) { token.refresh_token,
log.error('token resp error', resp); `${BASE_URL}/ytauth`,
return null; YOUTUBE_CLIENT_SECRET
} );
if (!resp.refresh_token) {
resp.refresh_token = token.refresh_token;
}
let expiration = new Date();
expiration.setSeconds(expiration.getSeconds() + resp.expires_in);
resp.expires = expiration;
await fs.writeFile(this.token_file_name, JSON.stringify(resp));
return resp;
} }
public async addToPlaylist(song: SongInfo) { public async addToPlaylist(song: SongInfo) {
@ -160,16 +96,16 @@ export class YoutubePlaylistAdder {
playlistItemsUrl.searchParams.append('videoId', youtubeId); playlistItemsUrl.searchParams.append('videoId', youtubeId);
playlistItemsUrl.searchParams.append('playlistId', YOUTUBE_PLAYLIST_ID); playlistItemsUrl.searchParams.append('playlistId', YOUTUBE_PLAYLIST_ID);
playlistItemsUrl.searchParams.append('part', 'id'); playlistItemsUrl.searchParams.append('part', 'id');
const existingPlaylistItem = await fetch(this.apiBase + '/playlistItems', { const existingPlaylistItem = await fetch(playlistItemsUrl, {
headers: { Authorization: `${token.token_type} ${token.access_token}` } headers: { Authorization: `${token.token_type} ${token.access_token}` }
}).then((r) => r.json()); }).then((r) => r.json());
log.debug('existingPlaylistItem', existingPlaylistItem);
if (existingPlaylistItem.pageInfo && existingPlaylistItem.pageInfo.totalResults > 0) { if (existingPlaylistItem.pageInfo && existingPlaylistItem.pageInfo.totalResults > 0) {
log.info('Item already in playlist'); log.info('Item already in playlist', existingPlaylistItem);
return; return;
} }
const searchParams = new URLSearchParams([['part', 'snippet']]); const addItemUrl = new URL(this.apiBase + '/playlistItems');
addItemUrl.searchParams.append('part', 'snippet');
const options: RequestInit = { const options: RequestInit = {
method: 'POST', method: 'POST',
headers: { Authorization: `${token.token_type} ${token.access_token}` }, headers: { Authorization: `${token.token_type} ${token.access_token}` },
@ -183,14 +119,9 @@ export class YoutubePlaylistAdder {
} }
}) })
}; };
const youtubeApiUrl = new URL(`${this.apiBase}/playlistItems?${searchParams}`); const resp = await fetch(addItemUrl, options);
const resp = await fetch(youtubeApiUrl, options);
const respObj = await resp.json(); const respObj = await resp.json();
if (log.isDebugEnabled()) {
log.info('Added to playlist', options, respObj);
} else {
log.info('Added to playlist', youtubeId, song.title); log.info('Added to playlist', youtubeId, song.title);
}
if (respObj.error) { if (respObj.error) {
log.debug('Add to playlist failed', respObj.error.errors); log.debug('Add to playlist failed', respObj.error.errors);
} }

28
src/routes/spotifyAuth/+page.server.ts Normal file
View File

@ -0,0 +1,28 @@
import { log } from '$lib/log';
import { SpotifyPlaylistAdder } from '$lib/server/spotifyPlaylistAdder';
import { redirect } from '@sveltejs/kit';
import type { PageServerLoad } from './$types';
export const load: PageServerLoad = async ({ url }) => {
const adder = new SpotifyPlaylistAdder();
let redirectUri = url;
if (url.hostname === 'localhost') {
redirectUri.hostname = '127.0.0.1';
}
log.debug(url.searchParams, url.hostname);
if (url.searchParams.has('code')) {
await adder.receivedAuthCode(url.searchParams.get('code') || '', url);
redirect(307, '/');
} else if (url.searchParams.has('error')) {
log.error('received error', url.searchParams.get('error'));
return;
}
if (await adder.authCodeExists()) {
redirect(307, '/');
}
const authUrl = adder.constructAuthUrl(url);
log.debug('+page.server.ts', authUrl.toString());
redirect(307, authUrl);
};

1
src/routes/spotifyAuth/+page.svelte Normal file
View File

@ -0,0 +1 @@
<h1>Something went wrong</h1>

3
src/routes/ytauth/+page.svelte
View File

@ -1,2 +1 @@
<h1>Hello and welcome to my site!</h1> <h1>Something went wrong</h1>
<a href="/about">About my site</a>