phlaym/moshing-mammut
1
0
Fork 0
Code Issues 4 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
spotify_auth_token
*.db
feed.xml
playbook.yml

51
src/lib/log.ts
View File

@ -33,3 +33,54 @@ export const log = {
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 = {
pageUrl: string;
youtubeUrl?: string;
spotifyUrl?: string;
spotifyUri?: string;
type: 'song' | 'album';
title?: 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 { enableVerboseLog, log } from '$lib/log';
import { enableVerboseLog, Logger } from '$lib/log';
import type { Account, AccountAvatar, Post, SongThumbnailImage, Tag } from '$lib/mastodon/response';
import type { SongInfo } from '$lib/odesliResponse';
import { TimelineReader } from '$lib/server/timeline';
import sqlite3 from 'sqlite3';
const logger = new Logger('Database');
type FilterParameter = {
$limit?: number | undefined | null;
$since?: string | undefined | null;
@ -37,6 +39,8 @@ type SongRow = {
overviewUrl?: string;
type: 'album' | 'song';
youtubeUrl?: string;
spotifyUrl?: string;
spotifyUri?: string;
title?: string;
artistName?: string;
thumbnailUrl?: string;
@ -81,15 +85,15 @@ let databaseReady = false;
if (enableVerboseLog) {
sqlite3.verbose();
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) => {
log.verbose('Running', sql);
logger.verbose('Running', 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) => {
db.exec(migration.statement, (err) => {
if (err !== null) {
log.error(`Failed to apply migration ${migration.name}`, err);
logger.error(`Failed to apply migration ${migration.name}`, err);
reject(err);
return;
}
@ -118,31 +122,31 @@ async function applyMigration(migration: Migration) {
if (post.songs && post.songs.length) {
continue;
}
log.info(
logger.info(
`Fetching songs for existing post ${current.toString().padStart(4, '0')} of ${total}`,
post.url
);
const songs = await TimelineReader.getSongInfoInPost(post);
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 {
await applyDbMigration(migration);
}
}
db.on('open', () => {
log.info('Opened database');
logger.info('Opened database');
db.serialize();
db.run('CREATE TABLE IF NOT EXISTS "migrations" ("id" integer,"name" TEXT, PRIMARY KEY (id))');
db.all('SELECT id FROM migrations', (err, rows: Migration[]) => {
if (err !== null) {
log.error('Could not fetch existing migrations', err);
logger.error('Could not fetch existing migrations', err);
databaseReady = true;
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 toApply = getMigrations().filter((m) => !appliedMigrations.has(m.id));
let remaining = toApply.length;
@ -159,7 +163,7 @@ db.on('open', () => {
databaseReady = true;
}
if (err !== null) {
log.error(`Failed to apply migration ${migration.name}`, err);
logger.error(`Failed to apply migration ${migration.name}`, err);
return;
}
db.run(
@ -167,10 +171,10 @@ db.on('open', () => {
[migration.id, migration.name],
(e: Error) => {
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;
}
log.info(`Applied migration ${migration.name}`);
logger.info(`Applied migration ${migration.name}`);
}
);
});
@ -178,7 +182,7 @@ db.on('open', () => {
});
});
db.on('error', (err) => {
log.error('Error opening database', err);
logger.error('Error opening database', err);
});
function getMigrations(): Migration[] {
@ -313,6 +317,13 @@ function getMigrations(): Migration[] {
statement: `
ALTER TABLE songs ADD COLUMN thumbnailWidth 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
return new Promise((resolve) => {
const interval = setInterval(() => {
log.verbose('Waiting for database to be ready');
logger.verbose('Waiting for database to be ready');
if (databaseReady) {
log.verbose('DB is ready');
logger.verbose('DB is ready');
clearInterval(interval);
resolve();
}
@ -354,7 +365,7 @@ function saveAccountData(account: Account): Promise<void> {
],
(err) => {
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);
return;
}
@ -377,7 +388,7 @@ function savePostData(post: Post): Promise<void> {
[post.id, post.content, post.created_at, post.url, post.account.url],
(postErr) => {
if (postErr !== null) {
log.error(`Could not insert post ${post.url}`, postErr);
logger.error(`Could not insert post ${post.url}`, postErr);
reject(postErr);
return;
}
@ -405,7 +416,7 @@ function savePostTagData(post: Post): Promise<void> {
[tag.url, tag.name],
(tagErr) => {
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);
return;
}
@ -414,7 +425,7 @@ function savePostTagData(post: Post): Promise<void> {
[post.url, tag.url],
(posttagserr) => {
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);
return;
}
@ -444,14 +455,16 @@ function saveSongInfoData(postUrl: string, songs: SongInfo[]): Promise<void> {
for (const song of songs) {
db.run(
`
INSERT INTO songs (postedUrl, overviewUrl, type, youtubeUrl, title, artistName, thumbnailUrl, post_url, thumbnailWidth, thumbnailHeight)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
INSERT INTO songs (postedUrl, overviewUrl, type, youtubeUrl, spotifyUrl, spotifyUri, title, artistName, thumbnailUrl, post_url, thumbnailWidth, thumbnailHeight)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
`,
[
song.postedUrl,
song.pageUrl,
song.type,
song.youtubeUrl,
song.spotifyUrl,
song.spotifyUri,
song.title,
song.artistName,
song.thumbnailUrl,
@ -461,7 +474,7 @@ function saveSongInfoData(postUrl: string, songs: SongInfo[]): Promise<void> {
],
(songErr) => {
if (songErr !== null) {
log.error(`Could not insert song ${song.postedUrl}`, songErr);
logger.error(`Could not insert song ${song.postedUrl}`, songErr);
reject(songErr);
return;
}
@ -479,20 +492,20 @@ function saveSongInfoData(postUrl: string, songs: SongInfo[]): Promise<void> {
}
export async function savePost(post: Post, songs: SongInfo[]) {
log.debug(`Saving post ${post.url}`);
logger.debug(`Saving post ${post.url}`);
if (!databaseReady) {
await waitReady();
}
const account = post.account;
await saveAccountData(account);
log.debug(`Saved account data ${post.url}`);
logger.debug(`Saved account data ${post.url}`);
await savePostData(post);
log.debug(`Saved post data ${post.url}`);
logger.debug(`Saved post data ${post.url}`);
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);
log.debug(
logger.debug(
`Saved ${songs.length} song info data ${post.url}`,
songs.map((s) => s.thumbnailHeight)
);
@ -511,7 +524,7 @@ function getPostData(filterQuery: string, params: FilterParameter): Promise<Post
return new Promise((resolve, reject) => {
db.all(sql, params, (err, rows: PostRow[]) => {
if (err != null) {
log.error('Error loading posts', err);
logger.error('Error loading posts', err);
reject(err);
return;
}
@ -530,7 +543,7 @@ function getTagData(postIdsParams: string, postIds: string[]): Promise<Map<strin
postIds,
(tagErr, tagRows: PostTagRow[]) => {
if (tagErr != null) {
log.error('Error loading post tags', tagErr);
logger.error('Error loading post tags', tagErr);
reject(tagErr);
return;
}
@ -551,14 +564,14 @@ function getTagData(postIdsParams: string, postIds: string[]): Promise<Map<strin
function getSongData(postIdsParams: string, postIds: string[]): Promise<Map<string, SongInfo[]>> {
return new Promise((resolve, reject) => {
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
FROM songs
WHERE post_url IN (${postIdsParams});`,
postIds,
(tagErr, tagRows: SongRow[]) => {
if (tagErr != null) {
log.error('Error loading post songs', tagErr);
logger.error('Error loading post songs', tagErr);
reject(tagErr);
return;
}
@ -567,6 +580,8 @@ function getSongData(postIdsParams: string, postIds: string[]): Promise<Map<stri
const info = {
pageUrl: item.overviewUrl,
youtubeUrl: item.youtubeUrl,
spotifyUrl: item.spotifyUrl,
spotifyUri: item.spotifyUri,
type: item.type,
title: item.title,
artistName: item.artistName,
@ -580,7 +595,7 @@ function getSongData(postIdsParams: string, postIds: string[]): Promise<Map<stri
},
new Map()
);
log.verbose('songMap', songMap);
logger.verbose('songMap', songMap);
resolve(songMap);
}
);
@ -599,7 +614,7 @@ function getAvatarData(
accountUrls,
(err, rows: AccountAvatarRow[]) => {
if (err != null) {
log.error('Error loading avatars', err);
logger.error('Error loading avatars', err);
reject(err);
return;
}
@ -633,7 +648,7 @@ function getSongThumbnailData(
thumbUrls,
(err, rows: SongThumbnailAvatarRow[]) => {
if (err != null) {
log.error('Error loading avatars', err);
logger.error('Error loading avatars', err);
reject(err);
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,
YOUTUBE_API_KEY
} from '$env/static/private';
import { log } from '$lib/log';
import { log, Logger } from '$lib/log';
import type {
Account,
AccountAvatar,
@ -34,6 +34,7 @@ import { console } from 'inspector/promises';
import sharp from 'sharp';
import { URL, URLSearchParams } from 'url';
import { WebSocket } from 'ws';
import { SpotifyPlaylistAdder } from './spotifyPlaylistAdder';
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);
@ -45,6 +46,7 @@ export class TimelineReader {
private static _instance: TimelineReader;
private lastPosts: string[] = [];
private youtubePlaylistAdder: YoutubePlaylistAdder;
private spotifyPlaylistAdder: SpotifyPlaylistAdder;
private static async isMusicVideo(videoId: string) {
if (!YOUTUBE_API_KEY || YOUTUBE_API_KEY === 'CHANGE_ME') {
@ -168,10 +170,13 @@ export class TimelineReader {
return null;
}
}
const spotify: Platform = 'spotify';
return {
...info,
pageUrl: odesliInfo.pageUrl,
youtubeUrl: odesliInfo.linksByPlatform[platform]?.url,
spotifyUrl: odesliInfo.linksByPlatform[spotify]?.url,
spotifyUri: odesliInfo.linksByPlatform[spotify]?.nativeAppUriDesktop,
postedUrl: url.toString()
} as SongInfo;
} catch (e) {
@ -263,8 +268,8 @@ export class TimelineReader {
}
*/
private async addToPlaylist(song: SongInfo) {
//await this.addToYoutubePlaylist(song);
await this.youtubePlaylistAdder.addToPlaylist(song);
await this.spotifyPlaylistAdder.addToPlaylist(song);
}
private static async resizeAvatar(
@ -472,78 +477,28 @@ export class TimelineReader {
}
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 = () => {
log.log('Connected to WS');
socketLogger.log('Connected to WS');
};
socket.onmessage = async (event) => {
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());
log.debug('ES event', data.event);
socketLogger.debug('ES event', data.event);
if (data.event !== 'update') {
log.log('Ignoring ES event', data.event);
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)) {
log.log('Skipping post, already handled', post.id);
socketLogger.log('Skipping post, already handled', post.id);
return;
}
this.lastPosts.push(post.id);
@ -552,21 +507,21 @@ export class TimelineReader {
}
await this.checkAndSavePost(post);
} catch (e) {
log.error('error message', event, event.data, e);
socketLogger.error('error message', event, event.data, e);
}
};
socket.onclose = (event) => {
log.warn(
socketLogger.warn(
`Websocket connection to ${MASTODON_INSTANCE} closed. Code: ${event.code}, reason: '${event.reason}'`,
event
);
setTimeout(() => {
log.info(`Attempting to reconenct to WS`);
socketLogger.info(`Attempting to reconenct to WS`);
this.startWebsocket();
}, 10000);
};
socket.onerror = (event) => {
log.error(
socketLogger.error(
`Websocket connection to ${MASTODON_INSTANCE} failed. ${event.type}: ${event.error}, message: '${event.message}'`
);
};
@ -600,6 +555,7 @@ export class TimelineReader {
private constructor() {
log.log('Constructing timeline object');
this.youtubePlaylistAdder = new YoutubePlaylistAdder();
this.spotifyPlaylistAdder = new SpotifyPlaylistAdder();
this.startWebsocket();
this.loadPostsSinceLastRun()

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

@ -7,126 +7,62 @@ import {
import { log } from '$lib/log';
import type { OauthResponse } from '$lib/mastodon/response';
import type { SongInfo } from '$lib/odesliResponse';
import fs from 'fs/promises';
import { OauthPlaylistAdder } from './oauthPlaylistAdder';
export class YoutubePlaylistAdder {
private apiBase: string = 'https://www.googleapis.com/youtube/v3';
private token_file_name: string = '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;
}
export class YoutubePlaylistAdder extends OauthPlaylistAdder {
public constructor() {
super('https://www.googleapis.com/youtube/v3', 'yt_auth_token');
}
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 authUrl = new URL(endpoint);
authUrl.searchParams.append('client_id', YOUTUBE_CLIENT_ID);
authUrl.searchParams.append('redirect_uri', redirectUri.toString());
authUrl.searchParams.append('response_type', 'code');
authUrl.searchParams.append('scope', 'https://www.googleapis.com/auth/youtube');
authUrl.searchParams.append('access_type', 'offline');
authUrl.searchParams.append('include_granted_scopes', 'false');
return authUrl;
return this.constructAuthUrlInternal(
endpoint,
YOUTUBE_CLIENT_ID,
'https://www.googleapis.com/auth/youtube',
redirectUri,
additionalParameters
);
}
public async receivedAuthCode(code: string, url: URL) {
log.debug('received code');
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('code', code);
params.append('grant_type', 'authorization_code');
params.append('redirect_uri', `${url.origin}${url.pathname}`);
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;
}
await this.receivedAuthCodeInternal(
tokenUrl,
YOUTUBE_CLIENT_ID,
code,
url,
YOUTUBE_CLIENT_SECRET
);
}
private async refreshToken(): Promise<OauthResponse | null> {
const token = await this.auth();
if (token == null || !token?.expires) {
const tokenInfo = await this.shouldRefreshToken();
if (tokenInfo == null) {
return null;
}
let now = new Date();
now.setTime(now.getTime() - this.refresh_time * 60 * 1000);
log.info('token expiry', token.expires, 'vs refresh @', now);
if (token.expires.getTime() > now.getTime()) {
let token = tokenInfo.token;
if (!tokenInfo.refresh) {
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) {
log.error('Need to refresh access token, but no refresh token provided');
return null;
}
log.debug('sending token req', params);
let resp: OauthResponse = await fetch(tokenUrl, {
method: 'POST',
body: params
}).then((r) => r.json());
if (resp.error) {
log.error('token resp error', resp);
return null;
}
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;
const tokenUrl = new URL('https://oauth2.googleapis.com/token');
return await this.requestRefreshToken(
tokenUrl,
YOUTUBE_CLIENT_ID,
token.refresh_token,
`${BASE_URL}/ytauth`,
YOUTUBE_CLIENT_SECRET
);
}
public async addToPlaylist(song: SongInfo) {
@ -160,16 +96,16 @@ export class YoutubePlaylistAdder {
playlistItemsUrl.searchParams.append('videoId', youtubeId);
playlistItemsUrl.searchParams.append('playlistId', YOUTUBE_PLAYLIST_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}` }
}).then((r) => r.json());
log.debug('existingPlaylistItem', existingPlaylistItem);
if (existingPlaylistItem.pageInfo && existingPlaylistItem.pageInfo.totalResults > 0) {
log.info('Item already in playlist');
log.info('Item already in playlist', existingPlaylistItem);
return;
}
const searchParams = new URLSearchParams([['part', 'snippet']]);
const addItemUrl = new URL(this.apiBase + '/playlistItems');
addItemUrl.searchParams.append('part', 'snippet');
const options: RequestInit = {
method: 'POST',
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(youtubeApiUrl, options);
const resp = await fetch(addItemUrl, options);
const respObj = await resp.json();
if (log.isDebugEnabled()) {
log.info('Added to playlist', options, respObj);
} else {
log.info('Added to playlist', youtubeId, song.title);
}
if (respObj.error) {
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>
<a href="/about">About my site</a>
<h1>Something went wrong</h1>