@lucaperret/tidal-cli 1.1.0

package/dist/playlist.js

@@ -0,0 +1,269 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listPlaylists = listPlaylists;
+exports.createPlaylist = createPlaylist;
+exports.renamePlaylist = renamePlaylist;
+exports.deletePlaylist = deletePlaylist;
+exports.addTrackToPlaylist = addTrackToPlaylist;
+exports.removeTrackFromPlaylist = removeTrackFromPlaylist;
+exports.addAlbumToPlaylist = addAlbumToPlaylist;
+exports.moveTrackInPlaylist = moveTrackInPlaylist;
+exports.updatePlaylistDescription = updatePlaylistDescription;
+const auth_1 = require("./auth");
+async function listPlaylists(json) {
+    const client = await (0, auth_1.getApiClient)();
+    const { data, error } = await client.GET('/playlists', {
+        params: {
+            query: {
+                'filter[owners.id]': ['me'],
+                countryCode: await (0, auth_1.getCountryCode)(),
+            },
+        },
+    });
+    if (error || !data) {
+        console.error(`Error: Failed to list playlists — ${JSON.stringify(error)}`);
+        process.exit(1);
+    }
+    const playlists = (data.data ?? []).map((p) => ({
+        id: p.id,
+        name: p.attributes?.name ?? 'Untitled',
+        description: p.attributes?.description,
+        numberOfItems: p.attributes?.numberOfItems,
+        createdAt: p.attributes?.createdAt,
+        lastModifiedAt: p.attributes?.lastModifiedAt,
+    }));
+    if (json) {
+        console.log(JSON.stringify(playlists, null, 2));
+        return;
+    }
+    if (playlists.length === 0) {
+        console.log('No playlists found.');
+        return;
+    }
+    console.log('\nYour playlists:\n');
+    for (const p of playlists) {
+        console.log(`  [${p.id}] ${p.name} (${p.numberOfItems ?? 0} tracks)`);
+        if (p.description)
+            console.log(`    ${p.description}`);
+    }
+    console.log();
+}
+async function createPlaylist(name, description, json) {
+    const client = await (0, auth_1.getApiClient)();
+    const { data, error } = await client.POST('/playlists', {
+        body: {
+            data: {
+                type: 'playlists',
+                attributes: {
+                    name,
+                    description,
+                    accessType: 'UNLISTED',
+                },
+            },
+        },
+    });
+    if (error || !data) {
+        console.error(`Error: Failed to create playlist — ${JSON.stringify(error)}`);
+        process.exit(1);
+    }
+    const created = data.data;
+    const result = {
+        id: created.id,
+        name: created.attributes?.name ?? name,
+        description: created.attributes?.description ?? description,
+    };
+    if (json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    console.log(`\nPlaylist created: [${result.id}] ${result.name}`);
+}
+async function renamePlaylist(playlistId, name, json) {
+    const client = await (0, auth_1.getApiClient)();
+    const { error } = await client.PATCH('/playlists/{id}', {
+        params: { path: { id: playlistId } },
+        body: {
+            data: {
+                type: 'playlists',
+                id: playlistId,
+                attributes: { name },
+            },
+        },
+    });
+    if (error) {
+        console.error(`Error: Failed to rename playlist — ${JSON.stringify(error)}`);
+        process.exit(1);
+    }
+    if (json) {
+        console.log(JSON.stringify({ id: playlistId, name, success: true }, null, 2));
+        return;
+    }
+    console.log(`\nPlaylist ${playlistId} renamed to "${name}".`);
+}
+async function deletePlaylist(playlistId, json) {
+    const client = await (0, auth_1.getApiClient)();
+    const { error } = await client.DELETE('/playlists/{id}', {
+        params: { path: { id: playlistId } },
+    });
+    if (error) {
+        console.error(`Error: Failed to delete playlist — ${JSON.stringify(error)}`);
+        process.exit(1);
+    }
+    if (json) {
+        console.log(JSON.stringify({ id: playlistId, deleted: true }, null, 2));
+        return;
+    }
+    console.log(`\nPlaylist ${playlistId} deleted.`);
+}
+async function addTrackToPlaylist(playlistId, trackId, json) {
+    const client = await (0, auth_1.getApiClient)();
+    const { error } = await client.POST('/playlists/{id}/relationships/items', {
+        params: { path: { id: playlistId } },
+        body: {
+            data: [{ id: trackId, type: 'tracks' }],
+        },
+    });
+    if (error) {
+        console.error(`Error: Failed to add track — ${JSON.stringify(error)}`);
+        process.exit(1);
+    }
+    if (json) {
+        console.log(JSON.stringify({ playlistId, trackId, added: true }, null, 2));
+        return;
+    }
+    console.log(`\nTrack ${trackId} added to playlist ${playlistId}.`);
+}
+async function removeTrackFromPlaylist(playlistId, trackId, json) {
+    const client = await (0, auth_1.getApiClient)();
+    // Get playlist items to find the item index (required by the API)
+    const { data: itemsData, error: itemsError } = await client.GET('/playlists/{id}/relationships/items', {
+        params: { path: { id: playlistId } },
+    });
+    if (itemsError || !itemsData) {
+        console.error(`Error: Failed to get playlist items — ${JSON.stringify(itemsError)}`);
+        process.exit(1);
+    }
+    const items = itemsData.data ?? [];
+    const item = items.find((i) => i.id === trackId);
+    if (!item) {
+        console.error(`Error: Track ${trackId} not found in playlist ${playlistId}.`);
+        process.exit(1);
+    }
+    const { error } = await client.DELETE('/playlists/{id}/relationships/items', {
+        params: { path: { id: playlistId } },
+        body: {
+            data: [{ id: trackId, type: 'tracks', meta: { itemId: item.meta.itemId } }],
+        },
+    });
+    if (error) {
+        console.error(`Error: Failed to remove track — ${JSON.stringify(error)}`);
+        process.exit(1);
+    }
+    if (json) {
+        console.log(JSON.stringify({ playlistId, trackId, removed: true }, null, 2));
+        return;
+    }
+    console.log(`\nTrack ${trackId} removed from playlist ${playlistId}.`);
+}
+async function addAlbumToPlaylist(playlistId, albumId, json) {
+    const client = await (0, auth_1.getApiClient)();
+    // First get album tracks
+    const { data: albumData, error: albumError } = await client.GET('/albums/{id}', {
+        params: {
+            path: { id: albumId },
+            query: { countryCode: await (0, auth_1.getCountryCode)(), include: ['items'] },
+        },
+    });
+    if (albumError || !albumData) {
+        console.error(`Error: Failed to get album — ${JSON.stringify(albumError)}`);
+        process.exit(1);
+    }
+    // Extract track IDs from included items
+    const included = albumData.included ?? [];
+    const trackIds = included
+        .filter((item) => item.type === 'tracks')
+        .map((item) => ({ id: item.id, type: 'tracks' }));
+    if (trackIds.length === 0) {
+        console.error('Error: No tracks found in album.');
+        process.exit(1);
+    }
+    const { error } = await client.POST('/playlists/{id}/relationships/items', {
+        params: { path: { id: playlistId } },
+        body: { data: trackIds },
+    });
+    if (error) {
+        console.error(`Error: Failed to add album tracks — ${JSON.stringify(error)}`);
+        process.exit(1);
+    }
+    if (json) {
+        console.log(JSON.stringify({ playlistId, albumId, tracksAdded: trackIds.length }, null, 2));
+        return;
+    }
+    console.log(`\n${trackIds.length} tracks from album ${albumId} added to playlist ${playlistId}.`);
+}
+async function moveTrackInPlaylist(playlistId, trackId, positionBefore, json) {
+    const client = await (0, auth_1.getApiClient)();
+    // Get playlist items to find the itemId for the track
+    const { data: itemsData, error: itemsError } = await client.GET('/playlists/{id}/relationships/items', {
+        params: { path: { id: playlistId } },
+    });
+    if (itemsError || !itemsData) {
+        console.error(`Error: Failed to get playlist items — ${JSON.stringify(itemsError)}`);
+        process.exit(1);
+    }
+    const items = itemsData.data ?? [];
+    const item = items.find((i) => i.id === trackId);
+    if (!item) {
+        console.error(`Error: Track ${trackId} not found in playlist ${playlistId}.`);
+        process.exit(1);
+    }
+    const itemId = item.meta?.itemId;
+    if (!itemId) {
+        console.error(`Error: Could not find itemId for track ${trackId}.`);
+        process.exit(1);
+    }
+    const meta = {};
+    if (positionBefore !== 'end') {
+        meta.positionBefore = positionBefore;
+    }
+    const { error } = await client.PATCH('/playlists/{id}/relationships/items', {
+        params: { path: { id: playlistId } },
+        body: {
+            data: [{ id: trackId, type: 'tracks', meta: { itemId } }],
+            meta,
+        },
+    });
+    if (error) {
+        console.error(`Error: Failed to move track — ${JSON.stringify(error)}`);
+        process.exit(1);
+    }
+    if (json) {
+        console.log(JSON.stringify({ playlistId, trackId, positionBefore, moved: true }, null, 2));
+        return;
+    }
+    const posDesc = positionBefore === 'end' ? 'to end of playlist' : `before item ${positionBefore}`;
+    console.log(`\nTrack ${trackId} moved ${posDesc} in playlist ${playlistId}.`);
+}
+async function updatePlaylistDescription(playlistId, description, json) {
+    const client = await (0, auth_1.getApiClient)();
+    const { error } = await client.PATCH('/playlists/{id}', {
+        params: { path: { id: playlistId } },
+        body: {
+            data: {
+                type: 'playlists',
+                id: playlistId,
+                attributes: { description },
+            },
+        },
+    });
+    if (error) {
+        console.error(`Error: Failed to update playlist description — ${JSON.stringify(error)}`);
+        process.exit(1);
+    }
+    if (json) {
+        console.log(JSON.stringify({ id: playlistId, description, success: true }, null, 2));
+        return;
+    }
+    console.log(`\nPlaylist ${playlistId} description updated.`);
+}
+//# sourceMappingURL=playlist.js.map

package/dist/recommend.d.ts

@@ -0,0 +1 @@
+export declare function getRecommendations(json: boolean): Promise<void>;

package/dist/recommend.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRecommendations = getRecommendations;
+const auth_1 = require("./auth");
+async function getRecommendations(json) {
+    const client = await (0, auth_1.getApiClient)();
+    const { data, error } = await client.GET('/userRecommendations/me', {
+        params: {
+            query: {
+                countryCode: await (0, auth_1.getCountryCode)(),
+                include: ['discoveryMixes', 'myMixes', 'newArrivalMixes'],
+            },
+        },
+    });
+    if (error || !data) {
+        console.error(`Error: Failed to get recommendations — ${JSON.stringify(error)}`);
+        process.exit(1);
+    }
+    const included = data.included ?? [];
+    if (json) {
+        console.log(JSON.stringify(included, null, 2));
+        return;
+    }
+    if (included.length === 0) {
+        console.log('No recommendations found.');
+        return;
+    }
+    console.log('\nYour recommendations:\n');
+    for (const item of included) {
+        const attrs = item.attributes;
+        const name = attrs?.title ?? attrs?.name ?? 'Untitled';
+        console.log(`  [${item.id}] (${item.type}) ${name}`);
+    }
+    console.log();
+}
+//# sourceMappingURL=recommend.js.map

package/dist/search.d.ts

@@ -0,0 +1,4 @@
+type SearchType = 'artist' | 'album' | 'track' | 'video' | 'playlist';
+export declare function search(type: SearchType, query: string, json: boolean): Promise<void>;
+export declare function searchSuggestions(query: string, json: boolean): Promise<void>;
+export {};

package/dist/search.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.search = search;
+exports.searchSuggestions = searchSuggestions;
+const auth_1 = require("./auth");
+function formatDuration(isoDuration) {
+    if (!isoDuration)
+        return '';
+    // ISO 8601 duration: PT3M45S
+    const match = isoDuration.match(/PT(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?/);
+    if (!match)
+        return isoDuration;
+    const h = match[1] ? `${match[1]}:` : '';
+    const m = (match[2] ?? '0').padStart(h ? 2 : 1, '0');
+    const s = (match[3] ?? '0').padStart(2, '0');
+    return `${h}${m}:${s}`;
+}
+async function search(type, query, json) {
+    const client = await (0, auth_1.getApiClient)();
+    const includeMap = {
+        artist: 'artists',
+        album: 'albums',
+        track: 'tracks',
+        video: 'videos',
+        playlist: 'playlists',
+    };
+    const { data, error } = await client.GET('/searchResults/{id}', {
+        params: {
+            path: { id: query },
+            query: {
+                countryCode: await (0, auth_1.getCountryCode)(),
+                include: [includeMap[type]],
+            },
+        },
+    });
+    if (error || !data) {
+        console.error(`Error: Search failed — ${JSON.stringify(error)}`);
+        process.exit(1);
+    }
+    const included = data.included ?? [];
+    const results = [];
+    for (const item of included) {
+        if (item.type === 'artists' && type === 'artist') {
+            const attrs = item.attributes;
+            results.push({
+                id: item.id,
+                type: 'artist',
+                name: attrs?.name ?? 'Unknown',
+                extra: { popularity: attrs?.popularity },
+            });
+        }
+        else if (item.type === 'albums' && type === 'album') {
+            const attrs = item.attributes;
+            results.push({
+                id: item.id,
+                type: 'album',
+                name: attrs?.title ?? 'Unknown',
+                extra: {
+                    albumType: attrs?.albumType,
+                    numberOfItems: attrs?.numberOfItems,
+                    releaseDate: attrs?.releaseDate,
+                    duration: formatDuration(attrs?.duration),
+                },
+            });
+        }
+        else if (item.type === 'tracks' && type === 'track') {
+            const attrs = item.attributes;
+            results.push({
+                id: item.id,
+                type: 'track',
+                name: attrs?.title ?? 'Unknown',
+                extra: {
+                    duration: formatDuration(attrs?.duration),
+                    explicit: attrs?.explicit,
+                    isrc: attrs?.isrc,
+                    popularity: attrs?.popularity,
+                },
+            });
+        }
+        else if (item.type === 'videos' && type === 'video') {
+            const attrs = item.attributes;
+            results.push({
+                id: item.id,
+                type: 'video',
+                name: attrs?.title ?? 'Unknown',
+                extra: {
+                    duration: formatDuration(attrs?.duration),
+                    explicit: attrs?.explicit,
+                    popularity: attrs?.popularity,
+                },
+            });
+        }
+        else if (item.type === 'playlists' && type === 'playlist') {
+            const attrs = item.attributes;
+            results.push({
+                id: item.id,
+                type: 'playlist',
+                name: attrs?.name ?? 'Unknown',
+                extra: {
+                    numberOfItems: attrs?.numberOfItems,
+                    description: attrs?.description,
+                },
+            });
+        }
+    }
+    // Sort by popularity (most relevant first) — skip albums and playlists which lack a direct popularity field
+    if (type !== 'album' && type !== 'playlist') {
+        results.sort((a, b) => {
+            const pa = a.extra?.popularity ?? 0;
+            const pb = b.extra?.popularity ?? 0;
+            return pb - pa;
+        });
+    }
+    if (json) {
+        console.log(JSON.stringify(results, null, 2));
+        return;
+    }
+    if (results.length === 0) {
+        console.log(`No ${type}s found for "${query}".`);
+        return;
+    }
+    const typeLabel = type === 'playlist' ? 'playlists' : `${type}s`;
+    console.log(`\nSearch results for "${query}" (${typeLabel}):\n`);
+    for (const r of results) {
+        const extras = r.extra
+            ? Object.entries(r.extra)
+                .filter(([, v]) => v !== undefined && v !== null)
+                .map(([k, v]) => `${k}: ${v}`)
+                .join(', ')
+            : '';
+        console.log(`  [${r.id}] ${r.name}${extras ? ` (${extras})` : ''}`);
+    }
+    console.log();
+}
+async function searchSuggestions(query, json) {
+    const client = await (0, auth_1.getApiClient)();
+    const { data, error } = await client.GET('/searchSuggestions/{id}', {
+        params: {
+            path: { id: query },
+            query: {
+                countryCode: await (0, auth_1.getCountryCode)(),
+                include: ['directHits'],
+            },
+        },
+    });
+    if (error || !data) {
+        console.error(`Error: Failed to get search suggestions — ${JSON.stringify(error)}`);
+        process.exit(1);
+    }
+    const attrs = data.data?.attributes ?? {};
+    const suggestions = (attrs.suggestions ?? []).map((s) => s.query ?? s);
+    const included = data.included ?? [];
+    const directHits = included.map((item) => {
+        const itemAttrs = item.attributes;
+        return {
+            id: item.id,
+            type: item.type,
+            name: itemAttrs?.title ?? itemAttrs?.name ?? 'Unknown',
+        };
+    });
+    const result = { suggestions, directHits };
+    if (json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
+    }
+    if (suggestions.length > 0) {
+        console.log(`\nSuggestions for "${query}":\n`);
+        for (const s of suggestions) {
+            console.log(`  ${s}`);
+        }
+    }
+    if (directHits.length > 0) {
+        console.log(`\nDirect hits:\n`);
+        for (const h of directHits) {
+            console.log(`  [${h.id}] (${h.type}) ${h.name}`);
+        }
+    }
+    if (suggestions.length === 0 && directHits.length === 0) {
+        console.log(`No suggestions found for "${query}".`);
+    }
+    console.log();
+}
+//# sourceMappingURL=search.js.map

package/dist/session.d.ts

@@ -0,0 +1,7 @@
+export declare function loadStorage(): Record<string, string>;
+export declare function saveStorage(data: Record<string, string>): void;
+/**
+ * Install a globalThis.localStorage polyfill backed by ~/.tidal-cli/session.json.
+ * Must be called before importing @tidal-music/auth.
+ */
+export declare function installLocalStorage(): void;

package/dist/session.js

@@ -0,0 +1,120 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadStorage = loadStorage;
+exports.saveStorage = saveStorage;
+exports.installLocalStorage = installLocalStorage;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const SESSION_DIR = path.join(os.homedir(), '.tidal-cli');
+const SESSION_FILE = path.join(SESSION_DIR, 'session.json');
+function ensureDir() {
+    if (!fs.existsSync(SESSION_DIR)) {
+        fs.mkdirSync(SESSION_DIR, { mode: 0o700 });
+    }
+}
+function loadStorage() {
+    ensureDir();
+    if (!fs.existsSync(SESSION_FILE))
+        return {};
+    try {
+        return JSON.parse(fs.readFileSync(SESSION_FILE, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+function saveStorage(data) {
+    ensureDir();
+    fs.writeFileSync(SESSION_FILE, JSON.stringify(data, null, 2), { mode: 0o600 });
+}
+/**
+ * Install a globalThis.localStorage polyfill backed by ~/.tidal-cli/session.json.
+ * Must be called before importing @tidal-music/auth.
+ */
+function installLocalStorage() {
+    // Always install our file-backed polyfill — Node.js 22+ has a built-in
+    // localStorage that requires --localstorage-file to work, so we override it.
+    let store = loadStorage();
+    const localStorage = {
+        getItem(key) {
+            // Re-read from disk to pick up any changes
+            store = loadStorage();
+            return store[key] ?? null;
+        },
+        setItem(key, value) {
+            store[key] = value;
+            saveStorage(store);
+        },
+        removeItem(key) {
+            delete store[key];
+            saveStorage(store);
+        },
+        clear() {
+            store = {};
+            saveStorage(store);
+        },
+        key(index) {
+            return Object.keys(store)[index] ?? null;
+        },
+        get length() {
+            return Object.keys(store).length;
+        },
+    };
+    Object.defineProperty(globalThis, 'localStorage', {
+        value: localStorage,
+        writable: false,
+        configurable: true,
+    });
+}
+// Polyfill browser APIs that @tidal-music/auth expects in Node.js
+if (typeof globalThis.CustomEvent === 'undefined') {
+    globalThis.CustomEvent = class CustomEvent extends Event {
+        detail;
+        constructor(type, params) {
+            super(type, params);
+            this.detail = params?.detail;
+        }
+    };
+}
+// EventTarget-based dispatchEvent/addEventListener for globalThis
+if (typeof globalThis.dispatchEvent !== 'function') {
+    const target = new EventTarget();
+    globalThis.addEventListener = target.addEventListener.bind(target);
+    globalThis.removeEventListener = target.removeEventListener.bind(target);
+    globalThis.dispatchEvent = target.dispatchEvent.bind(target);
+}
+//# sourceMappingURL=session.js.map

package/dist/track.d.ts

@@ -0,0 +1,4 @@
+export declare function getTrackInfo(trackId: string, json: boolean): Promise<void>;
+export declare function getTrackRadio(trackId: string, json: boolean): Promise<void>;
+export declare function getTrackByIsrc(isrc: string, json: boolean): Promise<void>;
+export declare function getSimilarTracks(trackId: string, json: boolean): Promise<void>;