@lucaperret/tidal-cli 1.1.0 → 1.2.2

package/dist/index.js

@@ -18,8 +18,22 @@ const artist_1 = require("./artist");
 const track_1 = require("./track");
 const album_1 = require("./album");
 const recommend_1 = require("./recommend");
+const mix_1 = require("./mix");
 const user_1 = require("./user");
 const history_1 = require("./history");
+const search_history_1 = require("./search-history");
+const saved_1 = require("./saved");
+const share_1 = require("./share");
+const MIX_CATEGORIES = ['daily', 'discovery', 'new-release', 'offline'];
+function parseMixCategory(value) {
+    if (!value)
+        return undefined;
+    if (!MIX_CATEGORIES.includes(value)) {
+        console.error(`Error: invalid mix category "${value}". Use one of: ${MIX_CATEGORIES.join(', ')}`);
+        process.exit(2);
+    }
+    return value;
+}
 const program = new commander_1.Command();
 program
     .name('tidal-cli')
@@ -85,6 +99,24 @@ searchCmd
     .action(wrapAction(async (genre) => {
     await (0, search_1.search)('playlist', genre || 'top hits', getJson());
 }));
+searchCmd
+    .command('history')
+    .description('List your search history')
+    .action(wrapAction(async () => {
+    await (0, search_history_1.listSearchHistory)(getJson());
+}));
+searchCmd
+    .command('history-delete <entry-id>')
+    .description('Delete a single search history entry')
+    .action(wrapAction(async (entryId) => {
+    await (0, search_history_1.deleteSearchHistoryEntry)(entryId, getJson());
+}));
+searchCmd
+    .command('history-clear')
+    .description('Clear all search history entries')
+    .action(wrapAction(async () => {
+    await (0, search_history_1.clearSearchHistory)(getJson());
+}));
 // Artist
 const artistCmd = program
     .command('artist')
@@ -167,8 +199,71 @@ albumCmd
 program
     .command('recommend')
     .description('Get personalized recommendations')
+    .option('--type <category>', `Mix category: ${MIX_CATEGORIES.join(', ')}`)
+    .action(wrapAction(async (opts) => {
+    await (0, recommend_1.getRecommendations)(parseMixCategory(opts.type), getJson());
+}));
+// Mix
+const mixCmd = program
+    .command('mix')
+    .description('Browse personalized mix contents');
+mixCmd
+    .command('items <mix-id>')
+    .description('Get items inside a specific mix')
+    .requiredOption('--type <category>', `Mix category: ${MIX_CATEGORIES.join(', ')}`)
+    .action(wrapAction(async (mixId, opts) => {
+    const cat = parseMixCategory(opts.type);
+    if (!cat)
+        return;
+    await (0, mix_1.getMixItems)(cat, mixId, getJson());
+}));
+// Share
+program
+    .command('share <type> <id>')
+    .description('Create a share link for a track or album (type: track | album)')
+    .action(wrapAction(async (type, id) => {
+    const normalized = type === 'track' ? 'tracks' : type === 'album' ? 'albums' : null;
+    if (!normalized) {
+        console.error('Error: type must be "track" or "album"');
+        process.exit(2);
+    }
+    await (0, share_1.createShare)(normalized, id, getJson());
+}));
+// Saved (save for later)
+const savedCmd = program
+    .command('saved')
+    .description('Manage your save-for-later collection');
+savedCmd
+    .command('list')
+    .description('List items saved for later')
     .action(wrapAction(async () => {
-    await (0, recommend_1.getRecommendations)(getJson());
+    await (0, saved_1.listSavedItems)(getJson());
+}));
+savedCmd
+    .command('add')
+    .description('Save an item for later')
+    .requiredOption('--type <type>', 'Item type: tracks, albums, artists, playlists, videos')
+    .requiredOption('--id <id>', 'Item ID')
+    .action(wrapAction(async (opts) => {
+    const allowed = ['tracks', 'albums', 'artists', 'playlists', 'videos'];
+    if (!allowed.includes(opts.type)) {
+        console.error(`Error: invalid type. Use one of: ${allowed.join(', ')}`);
+        process.exit(2);
+    }
+    await (0, saved_1.addSavedItem)(opts.type, opts.id, getJson());
+}));
+savedCmd
+    .command('remove')
+    .description('Remove an item from saved')
+    .requiredOption('--type <type>', 'Item type')
+    .requiredOption('--id <id>', 'Item ID')
+    .action(wrapAction(async (opts) => {
+    const allowed = ['tracks', 'albums', 'artists', 'playlists', 'videos'];
+    if (!allowed.includes(opts.type)) {
+        console.error(`Error: invalid type. Use one of: ${allowed.join(', ')}`);
+        process.exit(2);
+    }
+    await (0, saved_1.removeSavedItem)(opts.type, opts.id, getJson());
 }));
 // User
 const userCmd = program

package/dist/library.d.ts

@@ -1,7 +1,30 @@
-type LibraryResourceType = 'artist' | 'album' | 'track' | 'video';
+import type { LibraryResourceType } from './types';
+export type { LibraryResourceType };
+export declare function addToLibraryData(resourceType: LibraryResourceType, resourceId: string, client: any): Promise<{
+    resourceType: string;
+    resourceId: string;
+    added: boolean;
+}>;
 export declare function addToLibrary(resourceType: LibraryResourceType, resourceId: string, json: boolean): Promise<void>;
+export declare function removeFromLibraryData(resourceType: LibraryResourceType, resourceId: string, client: any): Promise<{
+    resourceType: string;
+    resourceId: string;
+    removed: boolean;
+}>;
 export declare function removeFromLibrary(resourceType: LibraryResourceType, resourceId: string, json: boolean): Promise<void>;
+export declare function listFavoritedPlaylistsData(client: any): Promise<Array<{
+    id: string;
+    name: string;
+    numberOfItems?: number;
+}>>;
 export declare function listFavoritedPlaylists(json: boolean): Promise<void>;
+export declare function addPlaylistToFavoritesData(playlistId: string, client: any): Promise<{
+    playlistId: string;
+    added: boolean;
+}>;
 export declare function addPlaylistToFavorites(playlistId: string, json: boolean): Promise<void>;
+export declare function removePlaylistFromFavoritesData(playlistId: string, client: any): Promise<{
+    playlistId: string;
+    removed: boolean;
+}>;
 export declare function removePlaylistFromFavorites(playlistId: string, json: boolean): Promise<void>;
-export {};

package/dist/library.js

@@ -1,9 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.addToLibraryData = addToLibraryData;
 exports.addToLibrary = addToLibrary;
+exports.removeFromLibraryData = removeFromLibraryData;
 exports.removeFromLibrary = removeFromLibrary;
+exports.listFavoritedPlaylistsData = listFavoritedPlaylistsData;
 exports.listFavoritedPlaylists = listFavoritedPlaylists;
+exports.addPlaylistToFavoritesData = addPlaylistToFavoritesData;
 exports.addPlaylistToFavorites = addPlaylistToFavorites;
+exports.removePlaylistFromFavoritesData = removePlaylistFromFavoritesData;
 exports.removePlaylistFromFavorites = removePlaylistFromFavorites;
 const auth_1 = require("./auth");
 const collectionEndpoints = {
@@ -12,8 +17,7 @@ const collectionEndpoints = {
     track: { path: '/userCollectionTracks/{id}/relationships/items', type: 'tracks' },
     video: { path: '/userCollectionVideos/{id}/relationships/items', type: 'videos' },
 };
-async function addToLibrary(resourceType, resourceId, json) {
-    const client = await (0, auth_1.getApiClient)();
+async function addToLibraryData(resourceType, resourceId, client) {
     const endpoint = collectionEndpoints[resourceType];
     const { error } = await client.POST(endpoint.path, {
         params: { path: { id: 'me' } },
@@ -22,17 +26,26 @@ async function addToLibrary(resourceType, resourceId, json) {
         },
     });
     if (error) {
-        console.error(`Error: Failed to add ${resourceType} to library — ${JSON.stringify(error)}`);
-        process.exit(1);
+        throw new Error(`Failed to add ${resourceType} to library — ${JSON.stringify(error)}`);
     }
-    if (json) {
-        console.log(JSON.stringify({ resourceType, resourceId, added: true }, null, 2));
-        return;
-    }
-    console.log(`\n${capitalize(resourceType)} ${resourceId} added to your library.`);
+    return { resourceType, resourceId, added: true };
 }
-async function removeFromLibrary(resourceType, resourceId, json) {
+async function addToLibrary(resourceType, resourceId, json) {
     const client = await (0, auth_1.getApiClient)();
+    try {
+        const result = await addToLibraryData(resourceType, resourceId, client);
+        if (json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`\n${capitalize(resourceType)} ${resourceId} added to your library.`);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+}
+async function removeFromLibraryData(resourceType, resourceId, client) {
     const endpoint = collectionEndpoints[resourceType];
     const { error } = await client.DELETE(endpoint.path, {
         params: { path: { id: 'me' } },
@@ -41,17 +54,26 @@ async function removeFromLibrary(resourceType, resourceId, json) {
         },
     });
     if (error) {
-        console.error(`Error: Failed to remove ${resourceType} from library — ${JSON.stringify(error)}`);
-        process.exit(1);
-    }
-    if (json) {
-        console.log(JSON.stringify({ resourceType, resourceId, removed: true }, null, 2));
-        return;
+        throw new Error(`Failed to remove ${resourceType} from library — ${JSON.stringify(error)}`);
     }
-    console.log(`\n${capitalize(resourceType)} ${resourceId} removed from your library.`);
+    return { resourceType, resourceId, removed: true };
 }
-async function listFavoritedPlaylists(json) {
+async function removeFromLibrary(resourceType, resourceId, json) {
     const client = await (0, auth_1.getApiClient)();
+    try {
+        const result = await removeFromLibraryData(resourceType, resourceId, client);
+        if (json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`\n${capitalize(resourceType)} ${resourceId} removed from your library.`);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+}
+async function listFavoritedPlaylistsData(client) {
     const { data, error } = await client.GET('/userCollectionPlaylists/{id}/relationships/items', {
         params: {
             path: { id: 'me' },
@@ -61,11 +83,10 @@ async function listFavoritedPlaylists(json) {
         },
     });
     if (error || !data) {
-        console.error(`Error: Failed to list favorited playlists — ${JSON.stringify(error)}`);
-        process.exit(1);
+        throw new Error(`Failed to list favorited playlists — ${JSON.stringify(error)}`);
     }
     const included = data.included ?? [];
-    const playlists = included
+    return included
         .filter((item) => item.type === 'playlists')
         .map((item) => {
         const attrs = item.attributes;
@@ -75,22 +96,31 @@ async function listFavoritedPlaylists(json) {
             numberOfItems: attrs?.numberOfItems,
         };
     });
-    if (json) {
-        console.log(JSON.stringify(playlists, null, 2));
-        return;
-    }
-    if (playlists.length === 0) {
-        console.log('No favorited playlists found.');
-        return;
+}
+async function listFavoritedPlaylists(json) {
+    const client = await (0, auth_1.getApiClient)();
+    try {
+        const playlists = await listFavoritedPlaylistsData(client);
+        if (json) {
+            console.log(JSON.stringify(playlists, null, 2));
+            return;
+        }
+        if (playlists.length === 0) {
+            console.log('No favorited playlists found.');
+            return;
+        }
+        console.log('\nFavorited playlists:\n');
+        for (const p of playlists) {
+            console.log(`  [${p.id}] ${p.name} (${p.numberOfItems ?? 0} items)`);
+        }
+        console.log();
     }
-    console.log('\nFavorited playlists:\n');
-    for (const p of playlists) {
-        console.log(`  [${p.id}] ${p.name} (${p.numberOfItems ?? 0} items)`);
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
     }
-    console.log();
 }
-async function addPlaylistToFavorites(playlistId, json) {
-    const client = await (0, auth_1.getApiClient)();
+async function addPlaylistToFavoritesData(playlistId, client) {
     const { error } = await client.POST('/userCollectionPlaylists/{id}/relationships/items', {
         params: { path: { id: 'me' } },
         body: {
@@ -98,17 +128,26 @@ async function addPlaylistToFavorites(playlistId, json) {
         },
     });
     if (error) {
-        console.error(`Error: Failed to add playlist to favorites — ${JSON.stringify(error)}`);
-        process.exit(1);
-    }
-    if (json) {
-        console.log(JSON.stringify({ playlistId, added: true }, null, 2));
-        return;
+        throw new Error(`Failed to add playlist to favorites — ${JSON.stringify(error)}`);
     }
-    console.log(`\nPlaylist ${playlistId} added to favorites.`);
+    return { playlistId, added: true };
 }
-async function removePlaylistFromFavorites(playlistId, json) {
+async function addPlaylistToFavorites(playlistId, json) {
     const client = await (0, auth_1.getApiClient)();
+    try {
+        const result = await addPlaylistToFavoritesData(playlistId, client);
+        if (json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`\nPlaylist ${playlistId} added to favorites.`);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+}
+async function removePlaylistFromFavoritesData(playlistId, client) {
     const { error } = await client.DELETE('/userCollectionPlaylists/{id}/relationships/items', {
         params: { path: { id: 'me' } },
         body: {
@@ -116,14 +155,24 @@ async function removePlaylistFromFavorites(playlistId, json) {
         },
     });
     if (error) {
-        console.error(`Error: Failed to remove playlist from favorites — ${JSON.stringify(error)}`);
-        process.exit(1);
+        throw new Error(`Failed to remove playlist from favorites — ${JSON.stringify(error)}`);
     }
-    if (json) {
-        console.log(JSON.stringify({ playlistId, removed: true }, null, 2));
-        return;
+    return { playlistId, removed: true };
+}
+async function removePlaylistFromFavorites(playlistId, json) {
+    const client = await (0, auth_1.getApiClient)();
+    try {
+        const result = await removePlaylistFromFavoritesData(playlistId, client);
+        if (json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`\nPlaylist ${playlistId} removed from favorites.`);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
     }
-    console.log(`\nPlaylist ${playlistId} removed from favorites.`);
 }
 function capitalize(s) {
     return s.charAt(0).toUpperCase() + s.slice(1);

package/dist/mix.d.ts

@@ -0,0 +1,4 @@
+import type { MixCategory, MixItem } from './types';
+export type { MixItem };
+export declare function getMixItemsData(category: MixCategory, mixId: string, client: any, countryCode: string): Promise<MixItem[]>;
+export declare function getMixItems(category: MixCategory, mixId: string, json: boolean): Promise<void>;

package/dist/mix.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMixItemsData = getMixItemsData;
+exports.getMixItems = getMixItems;
+const auth_1 = require("./auth");
+const categoryEndpoints = {
+    daily: '/userDailyMixes/{id}/relationships/items',
+    discovery: '/userDiscoveryMixes/{id}/relationships/items',
+    'new-release': '/userNewReleaseMixes/{id}/relationships/items',
+    offline: '/userOfflineMixes/{id}/relationships/items',
+};
+async function getMixItemsData(category, mixId, client, countryCode) {
+    const { data, error } = await client.GET(categoryEndpoints[category], {
+        params: {
+            path: { id: mixId },
+            query: {
+                countryCode,
+                include: ['items'],
+            },
+        },
+    });
+    if (error || !data) {
+        throw new Error(`Failed to get mix items — ${JSON.stringify(error)}`);
+    }
+    const included = data.included ?? [];
+    return included.map((item) => {
+        const attrs = item.attributes ?? {};
+        return {
+            id: item.id,
+            type: item.type,
+            name: attrs.title ?? attrs.name ?? 'Untitled',
+        };
+    });
+}
+async function getMixItems(category, mixId, json) {
+    const client = await (0, auth_1.getApiClient)();
+    const countryCode = await (0, auth_1.getCountryCode)();
+    try {
+        const items = await getMixItemsData(category, mixId, client, countryCode);
+        if (json) {
+            console.log(JSON.stringify(items, null, 2));
+            return;
+        }
+        if (items.length === 0) {
+            console.log('No items found in this mix.');
+            return;
+        }
+        console.log(`\n${category} mix [${mixId}] items:\n`);
+        for (const item of items) {
+            console.log(`  [${item.id}] (${item.type}) ${item.name}`);
+        }
+        console.log();
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=mix.js.map

package/dist/playback.d.ts

@@ -1,3 +1,7 @@
+import type { PlaybackInfo, PlaybackUrl } from './types';
+export type { PlaybackInfo, PlaybackUrl };
+export declare function playbackInfoData(trackId: string, quality: string, client: any): Promise<PlaybackInfo>;
 export declare function playbackInfo(trackId: string, quality: string, json: boolean): Promise<void>;
+export declare function playbackUrlData(trackId: string, quality: string, client: any): Promise<PlaybackUrl>;
 export declare function playbackUrl(trackId: string, quality: string, json: boolean): Promise<void>;
 export declare function playbackPlay(trackId: string, quality: string): Promise<void>;

package/dist/playback.js

@@ -33,7 +33,9 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.playbackInfoData = playbackInfoData;
 exports.playbackInfo = playbackInfo;
+exports.playbackUrlData = playbackUrlData;
 exports.playbackUrl = playbackUrl;
 exports.playbackPlay = playbackPlay;
 const auth_1 = require("./auth");
@@ -62,8 +64,7 @@ function parseDataUri(dataUri) {
         throw new Error('Invalid data URI from trackManifests');
     return { mimeType: match[1], data: match[2] };
 }
-async function fetchTrackManifest(trackId, quality) {
-    const client = await (0, auth_1.getApiClient)();
+async function fetchTrackManifestData(trackId, quality, client) {
     const formats = qualityToFormats[quality] ?? qualityToFormats.HIGH;
     const { data, error } = await client.GET('/trackManifests/{id}', {
         params: {
@@ -78,13 +79,11 @@ async function fetchTrackManifest(trackId, quality) {
         },
     });
     if (error || !data) {
-        console.error(`Error: Failed to get track manifest — ${JSON.stringify(error)}`);
-        process.exit(1);
+        throw new Error(`Failed to get track manifest — ${JSON.stringify(error)}`);
     }
     const attrs = data.data?.attributes;
     if (!attrs?.uri) {
-        console.error('Error: No manifest URI in response.');
-        process.exit(1);
+        throw new Error('No manifest URI in response.');
     }
     const { mimeType, data: manifestBase64 } = parseDataUri(attrs.uri);
     return {
@@ -101,6 +100,11 @@ async function fetchTrackManifest(trackId, quality) {
         albumPeakAmplitude: attrs.albumAudioNormalizationData?.peakAmplitude ?? 0,
     };
 }
+// Keep backward-compatible internal helper
+async function fetchTrackManifest(trackId, quality) {
+    const client = await (0, auth_1.getApiClient)();
+    return fetchTrackManifestData(trackId, quality, client);
+}
 function decodeManifest(base64Manifest, mimeType) {
     const decoded = Buffer.from(base64Manifest, 'base64').toString('utf-8');
     // JSON manifest (BTS): has urls array
@@ -118,7 +122,6 @@ function decodeManifest(base64Manifest, mimeType) {
         const initMatch = decoded.match(/initialization="([^"]+)"/);
         const mediaMatch = decoded.match(/media="([^"]+)"/);
         const codecsMatch = decoded.match(/codecs="([^"]+)"/);
-        // Parse segment timeline: <S d="176128" r="6"/> means 7 segments, <S d="89088"/> means 1
         const segmentDurations = [];
         const sMatches = decoded.matchAll(/<S d="(\d+)"(?:\s+r="(\d+)")?\/>/g);
         let segNum = 1;
@@ -139,7 +142,6 @@ function decodeManifest(base64Manifest, mimeType) {
                 codecs: codecsMatch?.[1],
             };
         }
-        // Fallback: try BaseURL
         const baseUrlMatch = decoded.match(/<BaseURL>([^<]+)<\/BaseURL>/);
         if (baseUrlMatch) {
             return { type: 'direct', url: baseUrlMatch[1], codecs: codecsMatch?.[1] };
@@ -148,12 +150,10 @@ function decodeManifest(base64Manifest, mimeType) {
     throw new Error('Unable to parse manifest');
 }
 async function downloadDashStream(dash) {
-    // Download init segment
     const initRes = await fetch(dash.initUrl);
     if (!initRes.ok)
         throw new Error(`Failed to download init segment (${initRes.status})`);
     const initBuf = Buffer.from(await initRes.arrayBuffer());
-    // Download media segments
     const segBuffers = [initBuf];
     for (const segNum of dash.segments) {
         const segUrl = dash.mediaTemplate.replace('$Number$', String(segNum));
@@ -164,9 +164,9 @@ async function downloadDashStream(dash) {
     }
     return Buffer.concat(segBuffers);
 }
-async function playbackInfo(trackId, quality, json) {
-    const info = await fetchTrackManifest(trackId, quality);
-    const result = {
+async function playbackInfoData(trackId, quality, client) {
+    const info = await fetchTrackManifestData(trackId, quality, client);
+    return {
         trackId: info.trackId,
         presentation: info.trackPresentation,
         previewReason: info.previewReason,
@@ -178,57 +178,73 @@ async function playbackInfo(trackId, quality, json) {
         albumReplayGain: info.albumReplayGain,
         albumPeakAmplitude: info.albumPeakAmplitude,
     };
-    if (json) {
-        console.log(JSON.stringify(result, null, 2));
-        return;
+}
+async function playbackInfo(trackId, quality, json) {
+    const client = await (0, auth_1.getApiClient)();
+    try {
+        const result = await playbackInfoData(trackId, quality, client);
+        if (json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`\nPlayback info for track ${trackId}:\n`);
+        console.log(`  Quality:        ${result.audioQuality}`);
+        console.log(`  Formats:        ${result.formats?.join(', ')}`);
+        console.log(`  Presentation:   ${result.presentation}`);
+        if (result.previewReason) {
+            console.log(`  Preview reason: ${result.previewReason}`);
+        }
+        console.log(`  Manifest type:  ${result.manifestMimeType}`);
+        console.log(`  Track gain:     ${result.trackReplayGain} dB`);
+        console.log(`  Album gain:     ${result.albumReplayGain} dB`);
+        console.log();
     }
-    console.log(`\nPlayback info for track ${trackId}:\n`);
-    console.log(`  Quality:        ${result.audioQuality}`);
-    console.log(`  Formats:        ${result.formats.join(', ')}`);
-    console.log(`  Presentation:   ${result.presentation}`);
-    if (result.previewReason) {
-        console.log(`  Preview reason: ${result.previewReason}`);
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
     }
-    console.log(`  Manifest type:  ${result.manifestMimeType}`);
-    console.log(`  Track gain:     ${result.trackReplayGain} dB`);
-    console.log(`  Album gain:     ${result.albumReplayGain} dB`);
-    console.log();
 }
-async function playbackUrl(trackId, quality, json) {
-    const info = await fetchTrackManifest(trackId, quality);
+async function playbackUrlData(trackId, quality, client) {
+    const info = await fetchTrackManifestData(trackId, quality, client);
     const stream = decodeManifest(info.manifest, info.manifestMimeType);
     if (stream.type === 'direct') {
-        if (json) {
-            console.log(JSON.stringify({ trackId: info.trackId, url: stream.url, audioQuality: info.audioQuality }, null, 2));
-        }
-        else {
-            console.log(stream.url);
-        }
+        return { trackId: info.trackId, url: stream.url, audioQuality: info.audioQuality, type: 'direct' };
     }
     else if (stream.dash) {
+        return {
+            trackId: info.trackId,
+            type: 'dash',
+            initUrl: stream.dash.initUrl,
+            segmentCount: stream.dash.segments.length,
+            audioQuality: info.audioQuality,
+        };
+    }
+    throw new Error('No stream URL available for this track.');
+}
+async function playbackUrl(trackId, quality, json) {
+    const client = await (0, auth_1.getApiClient)();
+    try {
+        const result = await playbackUrlData(trackId, quality, client);
         if (json) {
-            console.log(JSON.stringify({
-                trackId: info.trackId,
-                type: 'dash',
-                initUrl: stream.dash.initUrl,
-                segmentCount: stream.dash.segments.length,
-                audioQuality: info.audioQuality,
-            }, null, 2));
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        if (result.type === 'direct') {
+            console.log(result.url);
         }
         else {
-            console.log(`DASH stream (${stream.dash.segments.length} segments)`);
-            console.log(`  Init: ${stream.dash.initUrl}`);
+            console.log(`DASH stream (${result.segmentCount} segments)`);
+            console.log(`  Init: ${result.initUrl}`);
         }
     }
-    else {
-        console.error('Error: No stream URL available for this track.');
+    catch (err) {
+        console.error(`Error: ${err.message}`);
         process.exit(1);
     }
 }
 async function playbackPlay(trackId, quality) {
     const info = await fetchTrackManifest(trackId, quality);
     const stream = decodeManifest(info.manifest, info.manifestMimeType);
-    // Determine file extension from format
     const isFlac = info.formats.includes('FLAC') || info.formats.includes('FLAC_HIRES');
     const ext = isFlac ? '.flac' : '.mp4';
     const tmpFile = path.join(os.tmpdir(), `tidal-${trackId}${ext}`);