harmonyy 1.0.0

package/dist/spotify/index.js

@@ -0,0 +1,212 @@
+import crypto from 'node:crypto';
+export * from './types.js';
+const postJSON = async (url, body, headers = {}) => {
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            ...headers
+        },
+        body: JSON.stringify(body)
+    });
+    return res.json();
+};
+const throwPatched = (code) => {
+    console.error('spotify patched harmony yet again. here\'s how to fix:');
+    console.error('1. ensure you have the latest version of harmony installed');
+    console.error('2. open an issue @ https://github.com/VillainsRule/harmony/issues/new');
+    console.error(`3. make sure to specify "error code ${code}" in the issue`);
+    throw new Error(`[harmony] spotify was patched. open an issue on Github (error code ${code}).`);
+};
+export default class Spotify {
+    $latestSecret = { version: 1, secret: [] };
+    $deviceId = '';
+    $cookie = '';
+    $accessToken = { clientId: '', accessToken: '', accessTokenExpirationTimestampMs: 0 };
+    $clientToken = { token: '', refreshAt: 0 };
+    $variables;
+    $secretsReady;
+    constructor() {
+        this.$secretsReady = this.$fetchSecrets();
+        this.$secretsReady.catch(() => { });
+        setInterval(() => this.$fetchSecrets().catch(() => { }), 1000 * 60 * 60 * 1).unref();
+    }
+    async $fetchSecrets() {
+        const req = await fetch('https://raw.githubusercontent.com/VillainsRule/harmony/master/secrets/secretBytes.json');
+        const bytes = await req.json();
+        this.$latestSecret = bytes[bytes.length - 1];
+        if (!this.$latestSecret)
+            throwPatched(3);
+    }
+    async $getVariables() {
+        const mainReq = await fetch('https://open.spotify.com', {
+            headers: {
+                accept: 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
+                'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36'
+            }
+        });
+        const mainPage = await mainReq.text();
+        const deviceId = mainReq.headers.getSetCookie().find(h => h.startsWith('sp_t='))?.split(';')[0].split('=')[1];
+        if (!deviceId)
+            return throwPatched(4);
+        this.$deviceId = deviceId;
+        const mainScript = mainPage.match(/<\/script><script src="(.*?)"/)?.[1];
+        if (!mainScript)
+            return throwPatched(5);
+        const scriptContent = await (await fetch(mainScript)).text();
+        this.$variables = {
+            buildVer: 'unknown',
+            buildDate: 'unknown',
+            clientVersion: scriptContent.match(/clientVersion:"(.*?)"/)?.[1] || '',
+            serverTime: mainReq.headers.get('x-timer')?.match(/S([0-9]+)\./)?.[1] || ''
+        };
+        return this.$variables;
+    }
+    $toSecret(input) {
+        const inputBytes = [...Buffer.from(input)];
+        const transformed = inputBytes.map((e, t) => e ^ ((t % 33) + 9));
+        const joined = transformed.map(num => num.toString()).join('');
+        const hex_str = Buffer.from(joined).toString('hex');
+        return Buffer.from(hex_str, 'hex');
+    }
+    $generateTOTP(timestamp = Date.now()) {
+        const totpSecret = this.$latestSecret ? this.$toSecret(this.$latestSecret.secret) : null;
+        if (!totpSecret)
+            return throwPatched(2);
+        const secretBuffer = Buffer.from(totpSecret);
+        const digits = 6;
+        const timeStep = 30;
+        const time = Math.floor(timestamp / 1000 / timeStep);
+        const counter = Buffer.alloc(8);
+        counter.writeBigUInt64BE(BigInt(time));
+        const hmac = crypto.createHmac('sha1', secretBuffer).update(counter).digest();
+        const offset = hmac[hmac.length - 1] & 0xf;
+        const code = (((hmac[offset] & 0x7f) << 24) |
+            ((hmac[offset + 1] & 0xff) << 16) |
+            ((hmac[offset + 2] & 0xff) << 8) |
+            (hmac[offset + 3] & 0xff)) % 10 ** digits;
+        return code.toString().padStart(digits, '0');
+    }
+    async $pullAccessToken() {
+        await this.$secretsReady;
+        if (!this.$variables)
+            await this.$getVariables();
+        const urlBase = new URL('https://open.spotify.com/api/token');
+        const params = new URLSearchParams();
+        const totp = this.$generateTOTP();
+        params.append('reason', 'init');
+        params.append('productType', 'web-player');
+        params.append('totp', totp);
+        params.append('totpServer', totp);
+        params.append('totpVer', this.$latestSecret.version.toString());
+        urlBase.search = params.toString();
+        const req = await fetch(urlBase, {
+            headers: {
+                'Accept': '*/*',
+                'Accept-Language': 'en-US,en;q=0.9',
+                'Accept-Encoding': 'gzip, deflate, br',
+                'Connection': 'keep-alive'
+            }
+        });
+        const res = await req.json();
+        if (res.error)
+            return throwPatched(1);
+        this.$accessToken = res;
+    }
+    async $getHeaders() {
+        if (!this.$accessToken.accessToken)
+            await this.$pullAccessToken();
+        if (this.$accessToken.accessTokenExpirationTimestampMs - Date.now() <= 1)
+            await this.$pullAccessToken();
+        return {
+            'Accept': 'application/json',
+            'Accept-Encoding': 'gzip, deflate, br, zstd',
+            'Accept-Language': 'en',
+            'App-Platform': 'WebPlayer',
+            'Authorization': `Bearer ${this.$accessToken.accessToken}`,
+            'Cache-Control': 'no-cache',
+            'Content-Type': 'application/json;charset=UTF-8',
+            'Origin': 'https://open.spotify.com',
+            'Referer': 'https://open.spotify.com/',
+            'Spotify-App-Version': this.$variables.clientVersion,
+            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/134.0.0.0 Safari/537.36'
+        };
+    }
+    async search(query, opts = {}) {
+        const data = await postJSON('https://api-partner.spotify.com/pathfinder/v2/query', {
+            operationName: 'searchDesktop',
+            variables: {
+                ...opts,
+                searchTerm: query,
+                offset: opts.offset ?? 0,
+                limit: opts.limit ?? 10,
+                numberOfTopResults: opts.numberOfTopResults ?? 5,
+                includeAudiobooks: opts.includeAudiobooks ?? false,
+                includeArtistHasConcertsField: opts.includeArtistHasConcertsField ?? true,
+                includePreReleases: opts.includePreReleases ?? true,
+                includeLocalConcertsField: opts.includeLocalConcertsField ?? false,
+                includeAuthors: opts.includeAuthors ?? true
+            },
+            extensions: {
+                persistedQuery: {
+                    version: 1,
+                    sha256Hash: 'd9f785900f0710b31c07818d617f4f7600c1e21217e80f5b043d1e78d74e6026'
+                }
+            }
+        }, await this.$getHeaders());
+        return data.data.searchV2;
+    }
+    async getPopular(timezone = Intl.DateTimeFormat().resolvedOptions().timeZone) {
+        const data = await postJSON('https://api-partner.spotify.com/pathfinder/v2/query', {
+            operationName: 'home',
+            variables: {
+                timeZone: timezone,
+                sp_t: this.$deviceId,
+                facet: '',
+                sectionItemsLimit: 10
+            },
+            extensions: {
+                persistedQuery: {
+                    version: 1,
+                    sha256Hash: '72325e84c876c72564fb9ab012f602be8ef6a1fdd3039be2f8b4f2be4c229a30'
+                }
+            }
+        }, await this.$getHeaders());
+        return data.data.home.sectionContainer.sections.items;
+    }
+    async getAlbum(uri) {
+        const data = await postJSON('https://api-partner.spotify.com/pathfinder/v2/query', {
+            operationName: 'getAlbum',
+            variables: {
+                uri,
+                locale: '',
+                offset: 0,
+                limit: 50
+            },
+            extensions: {
+                persistedQuery: {
+                    version: 1,
+                    sha256Hash: '97dd13a1f28c80d66115a13697a7ffd94fe3bebdb94da42159456e1d82bfee76'
+                }
+            }
+        }, await this.$getHeaders());
+        return data.data.albumUnion;
+    }
+    async getArtist(uri) {
+        const data = await postJSON('https://api-partner.spotify.com/pathfinder/v2/query', {
+            operationName: 'queryArtistOverview',
+            variables: {
+                uri,
+                locale: ''
+            },
+            extensions: {
+                persistedQuery: {
+                    version: 1,
+                    sha256Hash: '1ac33ddab5d39a3a9c27802774e6d78b9405cc188c6f75aed007df2a32737c72'
+                }
+            }
+        }, await this.$getHeaders());
+        return data.data.artistUnion;
+    }
+}

package/dist/spotify/types.d.ts

@@ -0,0 +1,406 @@
+export type OperationName = 'searchArtists' | 'searchAlbums' | 'searchTracks' | 'queryArtistOverview' | 'queryArtistDiscographyAll' | 'getAlbum' | 'fetchPlaylist' | 'fetchPlaylistContents';
+export type CoverArtSource = {
+    height: number | null;
+    url: string;
+    width: number | null;
+};
+export type ExtractedColorItem = {
+    hex: string;
+    isFallback: boolean;
+};
+export type ExtractedColors = {
+    colorDark: ExtractedColorItem;
+};
+export type AlbumCoverArt = {
+    extractedColors: ExtractedColors;
+    sources: CoverArtSource[];
+};
+export type AvatarImage = {
+    extractedColors: ExtractedColors;
+    sources: CoverArtSource[];
+};
+export type GalleryImageItem = {
+    sources: CoverArtSource[];
+};
+export type Gallery = {
+    items: GalleryImageItem[];
+};
+export type ArtistVisuals = {
+    avatarImage: AvatarImage | null;
+    gallery?: Gallery;
+};
+export type Duration = {
+    totalMilliseconds: number;
+};
+export type ContentRating = {
+    label: 'NONE' | 'EXPLICIT';
+};
+export type Playability = {
+    playable: boolean;
+    reason: 'PLAYABLE';
+};
+export type SharingInfo = {
+    shareId: string;
+    shareUrl: string;
+};
+export type CopyrightItem = {
+    text: string;
+    type: 'C' | 'P';
+};
+export type Copyright = {
+    items: CopyrightItem[];
+};
+export type FullDate = {
+    day: number;
+    month: number;
+    precision: 'DAY' | 'MONTH' | 'YEAR';
+    year: number;
+    isoString?: string;
+};
+export type AlbumDate = {
+    year: number;
+};
+export type TracksSummary = {
+    totalCount: number;
+};
+export type ReleaseType = 'ALBUM' | 'SINGLE' | 'EP' | 'COMPILATION';
+export type PaginatedResponse<Item> = {
+    items: Item[];
+    totalCount: number;
+};
+export type ArtistSimplified = {
+    profile: {
+        name: string;
+    };
+    uri: string;
+    visuals?: ArtistVisuals;
+};
+export type AlbumOfTrack = {
+    coverArt: AlbumCoverArt;
+    id: string;
+    name: string;
+    uri: string;
+};
+export type ArtistStats = {
+    followers: number;
+    monthlyListeners: number;
+    worldRank: number;
+};
+export type Album = {
+    __typename: 'Album';
+    artists: {
+        items: ArtistSimplified[];
+    };
+    coverArt: AlbumCoverArt;
+    date: AlbumDate;
+    name: string;
+    playability: Playability;
+    type: ReleaseType;
+    uri: string;
+};
+export type Track = {
+    __typename: 'Track';
+    albumOfTrack: AlbumOfTrack;
+    artists: {
+        items: ArtistSimplified[];
+    };
+    contentRating: ContentRating;
+    duration: Duration;
+    discNumber: number;
+    id: string;
+    name: string;
+    playability: Playability;
+    playcount: string;
+    trackNumber: number;
+    uri: string;
+};
+export type NotFound = {
+    __typename: 'NotFound';
+};
+export type ArtistTopTrack = {
+    track: {
+        albumOfTrack: AlbumOfTrack;
+        artists: {
+            items: ArtistSimplified[];
+        };
+        contentRating: ContentRating;
+        discNumber: number;
+        duration: Duration;
+        id: string;
+        name: string;
+        playability: Playability;
+        playcount: string;
+        uri: string;
+    };
+};
+export type TopTracksSection = {
+    items: ArtistTopTrack[];
+};
+export type ReleaseItem = {
+    copyright: Copyright;
+    coverArt: AlbumCoverArt;
+    date: FullDate;
+    id: string;
+    label: string;
+    name: string;
+    playability: Playability;
+    sharingInfo: SharingInfo;
+    tracks: TracksSummary;
+    type: ReleaseType;
+    uri: string;
+};
+export type ReleaseSection = PaginatedResponse<ReleaseItem>;
+export type Discography = {
+    all?: PaginatedResponse<{
+        releases: PaginatedResponse<ReleaseItem>;
+    }>;
+    albums: ReleaseSection;
+    compilations: ReleaseSection;
+    latest: ReleaseItem;
+    popularReleasesAlbums: ReleaseSection;
+    singles: ReleaseSection;
+    topTracks: TopTracksSection;
+};
+export type RelatedArtistsSection = PaginatedResponse<Artist>;
+export type RelatedContent = {
+    relatedArtists: RelatedArtistsSection;
+};
+export type Artist = {
+    __typename: 'Artist';
+    id: string;
+    uri: string;
+    profile: {
+        name: string;
+        verified?: boolean;
+        biography?: {
+            type: string;
+            text: string;
+        };
+    };
+    headerImage: {
+        data: {
+            sources: CoverArtSource[];
+        };
+    } | null;
+    visuals?: ArtistVisuals;
+    discography: Discography;
+    relatedContent: RelatedContent;
+    sharingInfo: SharingInfo;
+    stats: ArtistStats;
+};
+export type AlbumResponseWrapper = {
+    __typename: 'AlbumResponseWrapper';
+    data: Album;
+};
+export type ArtistResponseWrapper = {
+    __typename: 'ArtistResponseWrapper';
+    data: Artist;
+};
+export type TrackResponseWrapper = {
+    __typename: 'TrackResponseWrapper';
+    data: Track | NotFound;
+};
+export type SearchResultItemWrapper<Result> = {
+    item: Result;
+};
+export type AlbumOrPrereleasePage = {
+    __typename: 'AlbumOrPrereleasePage';
+    items: AlbumResponseWrapper[];
+    totalCount: number;
+};
+export type SearchV2 = {
+    albumsV2: AlbumOrPrereleasePage;
+    artists: PaginatedResponse<ArtistResponseWrapper>;
+    tracksV2: PaginatedResponse<SearchResultItemWrapper<TrackResponseWrapper>>;
+};
+export type AlbumUnion = {
+    __typename: 'AlbumUnion';
+    copyright: Copyright;
+    date: FullDate;
+    label: string;
+    name: string;
+    playability: Playability;
+    type: ReleaseType;
+    artists: PaginatedResponse<ArtistSimplified>;
+    coverArt: AlbumCoverArt;
+    discs: PaginatedResponse<{
+        number: number;
+        tracks: {
+            totalCount: number;
+        };
+    }>;
+    tracksV2: PaginatedResponse<{
+        track: Track;
+    }>;
+    uri: string;
+};
+export type PlaylistImageItem = {
+    extractedColors?: ExtractedColors;
+    sources: CoverArtSource[];
+};
+export type PlaylistOwner = {
+    __typename: string;
+    uri: string;
+    username: string;
+    name: string;
+    avatar?: {
+        sources: CoverArtSource[];
+    };
+};
+export type PlaylistTrackData = {
+    __typename: 'Track' | string;
+    uri: string;
+    name: string;
+    trackDuration: Duration;
+    playcount?: string;
+    albumOfTrack: {
+        uri: string;
+        name: string;
+        artists: {
+            items: ArtistSimplified[];
+        };
+        coverArt: AlbumCoverArt;
+    };
+    artists: {
+        items: ArtistSimplified[];
+    };
+    discNumber: number;
+    trackNumber: number;
+    playability: Playability;
+    contentRating: ContentRating;
+};
+export type PlaylistContentItem = {
+    uid: string;
+    addedAt: {
+        isoString: string;
+    };
+    addedBy?: {
+        data: PlaylistOwner;
+    };
+    item: {
+        __typename: string;
+        data: PlaylistTrackData;
+    };
+};
+export type PlaylistContent = {
+    __typename: string;
+    totalCount: number;
+    pagingInfo: {
+        offset: number;
+        limit: number;
+    };
+    items: PlaylistContentItem[];
+};
+export type PlaylistV2 = {
+    __typename: string;
+    uri: string;
+    name: string;
+    description: string;
+    ownerV2: {
+        data: PlaylistOwner;
+    };
+    images: {
+        items: PlaylistImageItem[];
+    };
+    collaborative: boolean;
+    followers: number;
+    sharingInfo: SharingInfo;
+    content: PlaylistContent;
+};
+export type PathfinderPlaylistResponse = {
+    data: {
+        playlistV2: PlaylistV2;
+    };
+    extensions: Record<string, unknown>;
+};
+export type PathfinderSearchResponse = {
+    data: {
+        searchV2: SearchV2;
+    };
+    extensions: Record<string, unknown>;
+};
+export type PathfinderArtistOverviewResponse = {
+    data: {
+        artistUnion: Artist;
+    };
+    extensions: Record<string, unknown>;
+};
+export type PathfinderGetAlbumResponse = {
+    data: {
+        albumUnion: AlbumUnion;
+    };
+    extensions: Record<string, unknown>;
+};
+export type HomeSubtitle = {
+    transformedLabel: string;
+    translatedBaseText: string | null;
+};
+export type HomeTitle = {
+    transformedLabel: string;
+    translatedBaseText: string | null;
+};
+export type HomeSectionData = {
+    __typename: 'HomeGenericSectionData';
+    headerEntity: {
+        __typename: string;
+    };
+    subtitle: HomeSubtitle;
+    title: HomeTitle;
+};
+export type PlaylistAttribute = {
+    key: string;
+    value: string;
+};
+export type PlaylistOwnerUser = {
+    __typename: 'User';
+    name: string;
+    uri: string;
+};
+export type HomePlaylist = {
+    __typename: 'Playlist';
+    attributes: PlaylistAttribute[];
+    description: string;
+    format: string;
+    images: {
+        items: PlaylistImageItem[];
+    };
+    name: string;
+    ownerV2: {
+        data: PlaylistOwnerUser;
+    };
+    uri: string;
+};
+export type HomePlaylistResponseWrapper = {
+    __typename: 'PlaylistResponseWrapper';
+    data: HomePlaylist;
+};
+export type HomeSectionItemContent = TrackResponseWrapper | ArtistResponseWrapper | AlbumResponseWrapper | HomePlaylistResponseWrapper;
+export type HomeSectionItem = {
+    data: null;
+    content: HomeSectionItemContent;
+    uri: string;
+};
+export type HomeSectionItems = {
+    items: HomeSectionItem[];
+    pagingInfo: {
+        nextOffset: number | null;
+    };
+    totalCount: number;
+};
+export type HomeSection = {
+    data: HomeSectionData;
+    sectionItems: HomeSectionItems;
+    uri: string;
+};
+export type PathfinderHomeResponse = {
+    data: {
+        home: {
+            sectionContainer: {
+                sections: {
+                    items: HomeSection[];
+                };
+            };
+        };
+    };
+    extensions: Record<string, unknown>;
+};

package/dist/spotify/types.js

@@ -0,0 +1,2 @@
+// https://github.com/NuclearPlayer/nuclear-plugin-something/blob/268992def6f8e052b21f3014bc7992809bf39e67/src/types.ts#L235 THANK YOU
+export {};

package/dist/youtube/index.d.ts

@@ -0,0 +1,16 @@
+import type { AlbumResponse, ArtistResponse, SearchResponse } from './types.js';
+import { App } from '../App.js';
+export * from './types.js';
+export default class YoutubeMusic implements App {
+    #private;
+    $youtubeClientVersion: string;
+    $youtubeClientBuild: string;
+    $googVisitorId: string;
+    $cookieString: string;
+    $getData(): Promise<void>;
+    $getCookies(): Promise<void>;
+    $getHeaders(): Promise<Record<string, string>>;
+    search(query: string): Promise<SearchResponse>;
+    getAlbum(uri: string): Promise<AlbumResponse>;
+    getArtist(uri: string): Promise<ArtistResponse>;
+}