youtube-music/src/plugins/last-fm/main.ts

import crypto from 'node:crypto';

import { net, shell } from 'electron';

import type { LastFmPluginConfig } from './index';
import type { SongInfo } from '@/providers/song-info';

interface LastFmData {
  method: string,
  timestamp?: number,
}

interface LastFmSongData {
  track?: string,
  duration?: number,
  artist?: string,
  album?: string,
  api_key: string,
  sk?: string,
  format: string,
  method: string,
  timestamp?: number,
  api_sig?: string,
}

const createFormData = (parameters: LastFmSongData) => {
  // Creates the body for in the post request
  const formData = new URLSearchParams();
  for (const key in parameters) {
    formData.append(key, String(parameters[key as keyof LastFmSongData]));
  }

  return formData;
};

const createQueryString = (parameters: Record<string, unknown>, apiSignature: string) => {
  // Creates a querystring
  const queryData = [];
  parameters.api_sig = apiSignature;
  for (const key in parameters) {
    queryData.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(parameters[key]))}`);
  }

  return '?' + queryData.join('&');
};

const createApiSig = (parameters: LastFmSongData, secret: string) => {
  // This function creates the api signature, see: https://www.last.fm/api/authspec
  const keys = Object.keys(parameters);

  keys.sort();
  let sig = '';
  for (const key of keys) {
    if (key === 'format') {
      continue;
    }

    sig += `${key}${parameters[key as keyof LastFmSongData]}`;
  }

  sig += secret;
  sig = crypto.createHash('md5').update(sig, 'utf-8').digest('hex');
  return sig;
};

const createToken = async ({ api_key: apiKey, api_root: apiRoot, secret }: LastFmPluginConfig) => {
  // Creates and stores the auth token
  const data = {
    method: 'auth.gettoken',
    api_key: apiKey,
    format: 'json',
  };
  const apiSigature = createApiSig(data, secret);
  const response = await net.fetch(`${apiRoot}${createQueryString(data, apiSigature)}`);
  const json = await response.json() as Record<string, string>;
  return json?.token;
};

const authenticate = async (config: LastFmPluginConfig) => {
  // Asks the user for authentication
  await shell.openExternal(`https://www.last.fm/api/auth/?api_key=${config.api_key}&token=${config.token}`);
};

type SetConfType = (conf: Partial<Omit<LastFmPluginConfig, 'enabled'>>) => (void | Promise<void>);

export const getAndSetSessionKey = async (config: LastFmPluginConfig, setConfig: SetConfType) => {
  // Get and store the session key
  const data = {
    api_key: config.api_key,
    format: 'json',
    method: 'auth.getsession',
    token: config.token,
  };
  const apiSignature = createApiSig(data, config.secret);
  const response = await net.fetch(`${config.api_root}${createQueryString(data, apiSignature)}`);
  const json = await response.json() as {
    error?: string,
    session?: {
      key: string,
    }
  };
  if (json.error) {
    config.token = await createToken(config);
    await authenticate(config);
    setConfig(config);
  }
  if (json.session) {
    config.session_key = json.session.key;
  }
  setConfig(config);
  return config;
};

const postSongDataToAPI = async (songInfo: SongInfo, config: LastFmPluginConfig, data: LastFmData, setConfig: SetConfType) => {
  // This sends a post request to the api, and adds the common data
  if (!config.session_key) {
    await getAndSetSessionKey(config, setConfig);
  }

  const postData: LastFmSongData = {
    track: songInfo.title,
    duration: songInfo.songDuration,
    artist: songInfo.artist,
    ...(songInfo.album ? { album: songInfo.album } : undefined), // Will be undefined if current song is a video
    api_key: config.api_key,
    sk: config.session_key,
    format: 'json',
    ...data,
  };

  postData.api_sig = createApiSig(postData, config.secret);
  const formData = createFormData(postData);
  net.fetch('https://ws.audioscrobbler.com/2.0/', { method: 'POST', body: formData })
    .catch(async (error: {
      response?: {
        data?: {
          error: number,
        }
      }
    }) => {
      if (error?.response?.data?.error === 9) {
        // Session key is invalid, so remove it from the config and reauthenticate
        config.session_key = undefined;
        config.token = await createToken(config);
        await authenticate(config);
        setConfig(config);
      }
    });
};

export const addScrobble = (songInfo: SongInfo, config: LastFmPluginConfig, setConfig: SetConfType) => {
  // This adds one scrobbled song to last.fm
  const data = {
    method: 'track.scrobble',
    timestamp: Math.trunc((Date.now() - (songInfo.elapsedSeconds ?? 0)) / 1000),
  };
  postSongDataToAPI(songInfo, config, data, setConfig);
};

export const setNowPlaying = (songInfo: SongInfo, config: LastFmPluginConfig, setConfig: SetConfType) => {
  // This sets the now playing status in last.fm
  const data = {
    method: 'track.updateNowPlaying',
  };
  postSongDataToAPI(songInfo, config, data, setConfig);
};