@lucaperret/tidal-cli 1.1.2 → 1.2.3

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}`);

package/dist/playlist.d.ts

@@ -1,9 +1,52 @@
+import type { PlaylistInfo } from './types';
+export type { PlaylistInfo };
+export declare function listPlaylistsData(client: any, countryCode: string): Promise<PlaylistInfo[]>;
 export declare function listPlaylists(json: boolean): Promise<void>;
+export declare function createPlaylistData(name: string, description: string, client: any): Promise<{
+    id: string;
+    name: string;
+    description: string;
+}>;
 export declare function createPlaylist(name: string, description: string, json: boolean): Promise<void>;
+export declare function renamePlaylistData(playlistId: string, name: string, client: any): Promise<{
+    id: string;
+    name: string;
+    success: boolean;
+}>;
 export declare function renamePlaylist(playlistId: string, name: string, json: boolean): Promise<void>;
+export declare function deletePlaylistData(playlistId: string, client: any): Promise<{
+    id: string;
+    deleted: boolean;
+}>;
 export declare function deletePlaylist(playlistId: string, json: boolean): Promise<void>;
+export declare function addTrackToPlaylistData(playlistId: string, trackId: string, client: any): Promise<{
+    playlistId: string;
+    trackId: string;
+    added: boolean;
+}>;
 export declare function addTrackToPlaylist(playlistId: string, trackId: string, json: boolean): Promise<void>;
+export declare function removeTrackFromPlaylistData(playlistId: string, trackId: string, client: any): Promise<{
+    playlistId: string;
+    trackId: string;
+    removed: boolean;
+}>;
 export declare function removeTrackFromPlaylist(playlistId: string, trackId: string, json: boolean): Promise<void>;
+export declare function addAlbumToPlaylistData(playlistId: string, albumId: string, client: any, countryCode: string): Promise<{
+    playlistId: string;
+    albumId: string;
+    tracksAdded: number;
+}>;
 export declare function addAlbumToPlaylist(playlistId: string, albumId: string, json: boolean): Promise<void>;
+export declare function moveTrackInPlaylistData(playlistId: string, trackId: string, positionBefore: string, client: any): Promise<{
+    playlistId: string;
+    trackId: string;
+    positionBefore: string;
+    moved: boolean;
+}>;
 export declare function moveTrackInPlaylist(playlistId: string, trackId: string, positionBefore: string, json: boolean): Promise<void>;
+export declare function updatePlaylistDescriptionData(playlistId: string, description: string, client: any): Promise<{
+    id: string;
+    description: string;
+    success: boolean;
+}>;
 export declare function updatePlaylistDescription(playlistId: string, description: string, json: boolean): Promise<void>;

package/dist/playlist.js

@@ -1,30 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.listPlaylistsData = listPlaylistsData;
 exports.listPlaylists = listPlaylists;
+exports.createPlaylistData = createPlaylistData;
 exports.createPlaylist = createPlaylist;
+exports.renamePlaylistData = renamePlaylistData;
 exports.renamePlaylist = renamePlaylist;
+exports.deletePlaylistData = deletePlaylistData;
 exports.deletePlaylist = deletePlaylist;
+exports.addTrackToPlaylistData = addTrackToPlaylistData;
 exports.addTrackToPlaylist = addTrackToPlaylist;
+exports.removeTrackFromPlaylistData = removeTrackFromPlaylistData;
 exports.removeTrackFromPlaylist = removeTrackFromPlaylist;
+exports.addAlbumToPlaylistData = addAlbumToPlaylistData;
 exports.addAlbumToPlaylist = addAlbumToPlaylist;
+exports.moveTrackInPlaylistData = moveTrackInPlaylistData;
 exports.moveTrackInPlaylist = moveTrackInPlaylist;
+exports.updatePlaylistDescriptionData = updatePlaylistDescriptionData;
 exports.updatePlaylistDescription = updatePlaylistDescription;
 const auth_1 = require("./auth");
-async function listPlaylists(json) {
-    const client = await (0, auth_1.getApiClient)();
+async function listPlaylistsData(client, countryCode) {
     const { data, error } = await client.GET('/playlists', {
         params: {
             query: {
                 'filter[owners.id]': ['me'],
-                countryCode: await (0, auth_1.getCountryCode)(),
+                countryCode,
             },
         },
     });
     if (error || !data) {
-        console.error(`Error: Failed to list playlists — ${JSON.stringify(error)}`);
-        process.exit(1);
+        throw new Error(`Failed to list playlists — ${JSON.stringify(error)}`);
     }
-    const playlists = (data.data ?? []).map((p) => ({
+    return (data.data ?? []).map((p) => ({
         id: p.id,
         name: p.attributes?.name ?? 'Untitled',
         description: p.attributes?.description,
@@ -32,24 +39,34 @@ async function listPlaylists(json) {
         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;
+}
+async function listPlaylists(json) {
+    const client = await (0, auth_1.getApiClient)();
+    const countryCode = await (0, auth_1.getCountryCode)();
+    try {
+        const playlists = await listPlaylistsData(client, countryCode);
+        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();
     }
-    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}`);
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
     }
-    console.log();
 }
-async function createPlaylist(name, description, json) {
-    const client = await (0, auth_1.getApiClient)();
+async function createPlaylistData(name, description, client) {
     const { data, error } = await client.POST('/playlists', {
         body: {
             data: {
@@ -63,23 +80,31 @@ async function createPlaylist(name, description, json) {
         },
     });
     if (error || !data) {
-        console.error(`Error: Failed to create playlist — ${JSON.stringify(error)}`);
-        process.exit(1);
+        throw new Error(`Failed to create playlist — ${JSON.stringify(error)}`);
     }
     const created = data.data;
-    const result = {
+    return {
         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) {
+async function createPlaylist(name, description, json) {
     const client = await (0, auth_1.getApiClient)();
+    try {
+        const result = await createPlaylistData(name, description, client);
+        if (json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`\nPlaylist created: [${result.id}] ${result.name}`);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+}
+async function renamePlaylistData(playlistId, name, client) {
     const { error } = await client.PATCH('/playlists/{id}', {
         params: { path: { id: playlistId } },
         body: {
@@ -91,32 +116,50 @@ async function renamePlaylist(playlistId, name, json) {
         },
     });
     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;
+        throw new Error(`Failed to rename playlist — ${JSON.stringify(error)}`);
     }
-    console.log(`\nPlaylist ${playlistId} renamed to "${name}".`);
+    return { id: playlistId, name, success: true };
 }
-async function deletePlaylist(playlistId, json) {
+async function renamePlaylist(playlistId, name, json) {
     const client = await (0, auth_1.getApiClient)();
+    try {
+        const result = await renamePlaylistData(playlistId, name, client);
+        if (json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`\nPlaylist ${playlistId} renamed to "${name}".`);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+}
+async function deletePlaylistData(playlistId, client) {
     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;
+        throw new Error(`Failed to delete playlist — ${JSON.stringify(error)}`);
     }
-    console.log(`\nPlaylist ${playlistId} deleted.`);
+    return { id: playlistId, deleted: true };
 }
-async function addTrackToPlaylist(playlistId, trackId, json) {
+async function deletePlaylist(playlistId, json) {
     const client = await (0, auth_1.getApiClient)();
+    try {
+        const result = await deletePlaylistData(playlistId, client);
+        if (json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`\nPlaylist ${playlistId} deleted.`);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+}
+async function addTrackToPlaylistData(playlistId, trackId, client) {
     const { error } = await client.POST('/playlists/{id}/relationships/items', {
         params: { path: { id: playlistId } },
         body: {
@@ -124,30 +167,36 @@ async function addTrackToPlaylist(playlistId, trackId, json) {
         },
     });
     if (error) {
-        console.error(`Error: Failed to add track — ${JSON.stringify(error)}`);
-        process.exit(1);
+        throw new Error(`Failed to add track — ${JSON.stringify(error)}`);
     }
-    if (json) {
-        console.log(JSON.stringify({ playlistId, trackId, added: true }, null, 2));
-        return;
-    }
-    console.log(`\nTrack ${trackId} added to playlist ${playlistId}.`);
+    return { playlistId, trackId, added: true };
 }
-async function removeTrackFromPlaylist(playlistId, trackId, json) {
+async function addTrackToPlaylist(playlistId, trackId, json) {
     const client = await (0, auth_1.getApiClient)();
-    // Get playlist items to find the item index (required by the API)
+    try {
+        const result = await addTrackToPlaylistData(playlistId, trackId, client);
+        if (json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`\nTrack ${trackId} added to playlist ${playlistId}.`);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+}
+async function removeTrackFromPlaylistData(playlistId, trackId, client) {
     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);
+        throw new Error(`Failed to get playlist items — ${JSON.stringify(itemsError)}`);
     }
     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);
+        throw new Error(`Track ${trackId} not found in playlist ${playlistId}.`);
     }
     const { error } = await client.DELETE('/playlists/{id}/relationships/items', {
         params: { path: { id: playlistId } },
@@ -156,71 +205,82 @@ async function removeTrackFromPlaylist(playlistId, trackId, json) {
         },
     });
     if (error) {
-        console.error(`Error: Failed to remove track — ${JSON.stringify(error)}`);
-        process.exit(1);
+        throw new Error(`Failed to remove track — ${JSON.stringify(error)}`);
     }
-    if (json) {
-        console.log(JSON.stringify({ playlistId, trackId, removed: true }, null, 2));
-        return;
-    }
-    console.log(`\nTrack ${trackId} removed from playlist ${playlistId}.`);
+    return { playlistId, trackId, removed: true };
 }
-async function addAlbumToPlaylist(playlistId, albumId, json) {
+async function removeTrackFromPlaylist(playlistId, trackId, json) {
     const client = await (0, auth_1.getApiClient)();
-    // First get album tracks
+    try {
+        const result = await removeTrackFromPlaylistData(playlistId, trackId, client);
+        if (json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`\nTrack ${trackId} removed from playlist ${playlistId}.`);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+}
+async function addAlbumToPlaylistData(playlistId, albumId, client, countryCode) {
     const { data: albumData, error: albumError } = await client.GET('/albums/{id}', {
         params: {
             path: { id: albumId },
-            query: { countryCode: await (0, auth_1.getCountryCode)(), include: ['items'] },
+            query: { countryCode, include: ['items'] },
         },
     });
     if (albumError || !albumData) {
-        console.error(`Error: Failed to get album — ${JSON.stringify(albumError)}`);
-        process.exit(1);
+        throw new Error(`Failed to get album — ${JSON.stringify(albumError)}`);
     }
-    // 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);
+        throw new Error('No tracks found in album.');
     }
     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);
+        throw new Error(`Failed to add album tracks — ${JSON.stringify(error)}`);
     }
-    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}.`);
+    return { playlistId, albumId, tracksAdded: trackIds.length };
 }
-async function moveTrackInPlaylist(playlistId, trackId, positionBefore, json) {
+async function addAlbumToPlaylist(playlistId, albumId, json) {
     const client = await (0, auth_1.getApiClient)();
-    // Get playlist items to find the itemId for the track
+    const countryCode = await (0, auth_1.getCountryCode)();
+    try {
+        const result = await addAlbumToPlaylistData(playlistId, albumId, client, countryCode);
+        if (json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`\n${result.tracksAdded} tracks from album ${albumId} added to playlist ${playlistId}.`);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+}
+async function moveTrackInPlaylistData(playlistId, trackId, positionBefore, client) {
     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);
+        throw new Error(`Failed to get playlist items — ${JSON.stringify(itemsError)}`);
     }
     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);
+        throw new Error(`Track ${trackId} not found in playlist ${playlistId}.`);
     }
     const itemId = item.meta?.itemId;
     if (!itemId) {
-        console.error(`Error: Could not find itemId for track ${trackId}.`);
-        process.exit(1);
+        throw new Error(`Could not find itemId for track ${trackId}.`);
     }
     const meta = {};
     if (positionBefore !== 'end') {
@@ -234,18 +294,27 @@ async function moveTrackInPlaylist(playlistId, trackId, positionBefore, json) {
         },
     });
     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;
+        throw new Error(`Failed to move track — ${JSON.stringify(error)}`);
     }
-    const posDesc = positionBefore === 'end' ? 'to end of playlist' : `before item ${positionBefore}`;
-    console.log(`\nTrack ${trackId} moved ${posDesc} in playlist ${playlistId}.`);
+    return { playlistId, trackId, positionBefore, moved: true };
 }
-async function updatePlaylistDescription(playlistId, description, json) {
+async function moveTrackInPlaylist(playlistId, trackId, positionBefore, json) {
     const client = await (0, auth_1.getApiClient)();
+    try {
+        const result = await moveTrackInPlaylistData(playlistId, trackId, positionBefore, client);
+        if (json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        const posDesc = positionBefore === 'end' ? 'to end of playlist' : `before item ${positionBefore}`;
+        console.log(`\nTrack ${trackId} moved ${posDesc} in playlist ${playlistId}.`);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+}
+async function updatePlaylistDescriptionData(playlistId, description, client) {
     const { error } = await client.PATCH('/playlists/{id}', {
         params: { path: { id: playlistId } },
         body: {
@@ -257,13 +326,23 @@ async function updatePlaylistDescription(playlistId, description, json) {
         },
     });
     if (error) {
-        console.error(`Error: Failed to update playlist description — ${JSON.stringify(error)}`);
-        process.exit(1);
+        throw new Error(`Failed to update playlist description — ${JSON.stringify(error)}`);
     }
-    if (json) {
-        console.log(JSON.stringify({ id: playlistId, description, success: true }, null, 2));
-        return;
+    return { id: playlistId, description, success: true };
+}
+async function updatePlaylistDescription(playlistId, description, json) {
+    const client = await (0, auth_1.getApiClient)();
+    try {
+        const result = await updatePlaylistDescriptionData(playlistId, description, client);
+        if (json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`\nPlaylist ${playlistId} description updated.`);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
     }
-    console.log(`\nPlaylist ${playlistId} description updated.`);
 }
 //# sourceMappingURL=playlist.js.map