@lucaperret/tidal-cli 1.1.0 → 1.2.2

package/dist/saved.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listSavedItemsData = listSavedItemsData;
+exports.listSavedItems = listSavedItems;
+exports.addSavedItemData = addSavedItemData;
+exports.addSavedItem = addSavedItem;
+exports.removeSavedItemData = removeSavedItemData;
+exports.removeSavedItem = removeSavedItem;
+const auth_1 = require("./auth");
+async function listSavedItemsData(client) {
+    const { data, error } = await client.GET('/userCollectionSaveForLaters/{id}/relationships/items', {
+        params: {
+            path: { id: 'me' },
+            query: { include: ['items'] },
+        },
+    });
+    if (error || !data) {
+        throw new Error(`Failed to list saved 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 listSavedItems(json) {
+    const client = await (0, auth_1.getApiClient)();
+    try {
+        const items = await listSavedItemsData(client);
+        if (json) {
+            console.log(JSON.stringify(items, null, 2));
+            return;
+        }
+        if (items.length === 0) {
+            console.log('No saved items found.');
+            return;
+        }
+        console.log('\nSaved for later:\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);
+    }
+}
+async function addSavedItemData(itemType, itemId, client) {
+    const { error } = await client.POST('/userCollectionSaveForLaters/{id}/relationships/items', {
+        params: { path: { id: 'me' } },
+        body: {
+            data: [{ id: itemId, type: itemType }],
+        },
+    });
+    if (error) {
+        throw new Error(`Failed to save item — ${JSON.stringify(error)}`);
+    }
+    return { id: itemId, type: itemType, added: true };
+}
+async function addSavedItem(itemType, itemId, json) {
+    const client = await (0, auth_1.getApiClient)();
+    try {
+        const result = await addSavedItemData(itemType, itemId, client);
+        if (json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`\n${itemType} ${itemId} saved for later.`);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+}
+async function removeSavedItemData(itemType, itemId, client) {
+    const { error } = await client.DELETE('/userCollectionSaveForLaters/{id}/relationships/items', {
+        params: { path: { id: 'me' } },
+        body: {
+            data: [{ id: itemId, type: itemType }],
+        },
+    });
+    if (error) {
+        throw new Error(`Failed to remove saved item — ${JSON.stringify(error)}`);
+    }
+    return { id: itemId, type: itemType, removed: true };
+}
+async function removeSavedItem(itemType, itemId, json) {
+    const client = await (0, auth_1.getApiClient)();
+    try {
+        const result = await removeSavedItemData(itemType, itemId, client);
+        if (json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`\n${itemType} ${itemId} removed from saved.`);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=saved.js.map

package/dist/search-history.d.ts

@@ -0,0 +1,13 @@
+import type { SearchHistoryEntry } from './types';
+export type { SearchHistoryEntry };
+export declare function listSearchHistoryData(client: any, countryCode: string): Promise<SearchHistoryEntry[]>;
+export declare function listSearchHistory(json: boolean): Promise<void>;
+export declare function deleteSearchHistoryEntryData(entryId: string, client: any): Promise<{
+    id: string;
+    deleted: boolean;
+}>;
+export declare function deleteSearchHistoryEntry(entryId: string, json: boolean): Promise<void>;
+export declare function clearSearchHistoryData(client: any, countryCode: string): Promise<{
+    deleted: number;
+}>;
+export declare function clearSearchHistory(json: boolean): Promise<void>;

package/dist/search-history.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listSearchHistoryData = listSearchHistoryData;
+exports.listSearchHistory = listSearchHistory;
+exports.deleteSearchHistoryEntryData = deleteSearchHistoryEntryData;
+exports.deleteSearchHistoryEntry = deleteSearchHistoryEntry;
+exports.clearSearchHistoryData = clearSearchHistoryData;
+exports.clearSearchHistory = clearSearchHistory;
+const auth_1 = require("./auth");
+async function listSearchHistoryData(client, countryCode) {
+    const { data, error } = await client.GET('/searchHistoryEntries', {
+        params: {
+            query: { countryCode },
+        },
+    });
+    if (error || !data) {
+        throw new Error(`Failed to list search history — ${JSON.stringify(error)}`);
+    }
+    const items = data.data ?? [];
+    return items.map((item) => ({
+        id: item.id,
+        query: item.attributes?.query ?? '',
+    }));
+}
+async function listSearchHistory(json) {
+    const client = await (0, auth_1.getApiClient)();
+    const countryCode = await (0, auth_1.getCountryCode)();
+    try {
+        const entries = await listSearchHistoryData(client, countryCode);
+        if (json) {
+            console.log(JSON.stringify(entries, null, 2));
+            return;
+        }
+        if (entries.length === 0) {
+            console.log('No search history found.');
+            return;
+        }
+        console.log('\nYour search history:\n');
+        for (const entry of entries) {
+            console.log(`  [${entry.id}] ${entry.query}`);
+        }
+        console.log();
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+}
+async function deleteSearchHistoryEntryData(entryId, client) {
+    const { error } = await client.DELETE('/searchHistoryEntries/{id}', {
+        params: { path: { id: entryId } },
+    });
+    if (error) {
+        throw new Error(`Failed to delete search history entry — ${JSON.stringify(error)}`);
+    }
+    return { id: entryId, deleted: true };
+}
+async function deleteSearchHistoryEntry(entryId, json) {
+    const client = await (0, auth_1.getApiClient)();
+    try {
+        const result = await deleteSearchHistoryEntryData(entryId, client);
+        if (json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`\nSearch history entry ${entryId} deleted.`);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+}
+async function clearSearchHistoryData(client, countryCode) {
+    const entries = await listSearchHistoryData(client, countryCode);
+    await Promise.all(entries.map((e) => deleteSearchHistoryEntryData(e.id, client)));
+    return { deleted: entries.length };
+}
+async function clearSearchHistory(json) {
+    const client = await (0, auth_1.getApiClient)();
+    const countryCode = await (0, auth_1.getCountryCode)();
+    try {
+        const result = await clearSearchHistoryData(client, countryCode);
+        if (json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`\nCleared ${result.deleted} search history entries.`);
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=search-history.js.map

package/dist/search.d.ts

@@ -1,4 +1,6 @@
-type SearchType = 'artist' | 'album' | 'track' | 'video' | 'playlist';
+import type { SearchType, SearchResult, SearchSuggestionsResult } from './types';
+export type { SearchType, SearchResult, SearchSuggestionsResult };
+export declare function searchData(type: SearchType, query: string, client: any, countryCode: string): Promise<SearchResult[]>;
 export declare function search(type: SearchType, query: string, json: boolean): Promise<void>;
+export declare function searchSuggestionsData(query: string, client: any, countryCode: string): Promise<SearchSuggestionsResult>;
 export declare function searchSuggestions(query: string, json: boolean): Promise<void>;
-export {};

package/dist/search.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.searchData = searchData;
 exports.search = search;
+exports.searchSuggestionsData = searchSuggestionsData;
 exports.searchSuggestions = searchSuggestions;
 const auth_1 = require("./auth");
 function formatDuration(isoDuration) {
@@ -15,8 +17,7 @@ function formatDuration(isoDuration) {
     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)();
+async function searchData(type, query, client, countryCode) {
     const includeMap = {
         artist: 'artists',
         album: 'albums',
@@ -28,14 +29,13 @@ async function search(type, query, json) {
         params: {
             path: { id: query },
             query: {
-                countryCode: await (0, auth_1.getCountryCode)(),
+                countryCode,
                 include: [includeMap[type]],
             },
         },
     });
     if (error || !data) {
-        console.error(`Error: Search failed — ${JSON.stringify(error)}`);
-        process.exit(1);
+        throw new Error(`Search failed — ${JSON.stringify(error)}`);
     }
     const included = data.included ?? [];
     const results = [];
@@ -111,41 +111,51 @@ async function search(type, query, json) {
             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;
+    return results;
+}
+async function search(type, query, json) {
+    const client = await (0, auth_1.getApiClient)();
+    const countryCode = await (0, auth_1.getCountryCode)();
+    try {
+        const results = await searchData(type, query, client, countryCode);
+        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();
     }
-    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})` : ''}`);
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
     }
-    console.log();
 }
-async function searchSuggestions(query, json) {
-    const client = await (0, auth_1.getApiClient)();
+async function searchSuggestionsData(query, client, countryCode) {
     const { data, error } = await client.GET('/searchSuggestions/{id}', {
         params: {
             path: { id: query },
             query: {
-                countryCode: await (0, auth_1.getCountryCode)(),
+                countryCode,
                 include: ['directHits'],
             },
         },
     });
     if (error || !data) {
-        console.error(`Error: Failed to get search suggestions — ${JSON.stringify(error)}`);
-        process.exit(1);
+        throw new Error(`Failed to get search suggestions — ${JSON.stringify(error)}`);
     }
     const attrs = data.data?.attributes ?? {};
     const suggestions = (attrs.suggestions ?? []).map((s) => s.query ?? s);
@@ -158,26 +168,37 @@ async function searchSuggestions(query, json) {
             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}`);
+    return { suggestions, directHits };
+}
+async function searchSuggestions(query, json) {
+    const client = await (0, auth_1.getApiClient)();
+    const countryCode = await (0, auth_1.getCountryCode)();
+    try {
+        const result = await searchSuggestionsData(query, client, countryCode);
+        if (json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
         }
-    }
-    if (directHits.length > 0) {
-        console.log(`\nDirect hits:\n`);
-        for (const h of directHits) {
-            console.log(`  [${h.id}] (${h.type}) ${h.name}`);
+        if (result.suggestions.length > 0) {
+            console.log(`\nSuggestions for "${query}":\n`);
+            for (const s of result.suggestions) {
+                console.log(`  ${s}`);
+            }
+        }
+        if (result.directHits.length > 0) {
+            console.log(`\nDirect hits:\n`);
+            for (const h of result.directHits) {
+                console.log(`  [${h.id}] (${h.type}) ${h.name}`);
+            }
         }
+        if (result.suggestions.length === 0 && result.directHits.length === 0) {
+            console.log(`No suggestions found for "${query}".`);
+        }
+        console.log();
     }
-    if (suggestions.length === 0 && directHits.length === 0) {
-        console.log(`No suggestions found for "${query}".`);
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
     }
-    console.log();
 }
 //# sourceMappingURL=search.js.map

package/dist/session.js

@@ -42,15 +42,20 @@ 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 });
+    try {
+        if (!fs.existsSync(SESSION_DIR)) {
+            fs.mkdirSync(SESSION_DIR, { mode: 0o700 });
+        }
+    }
+    catch {
+        // Serverless / read-only filesystem — skip
     }
 }
 function loadStorage() {
-    ensureDir();
-    if (!fs.existsSync(SESSION_FILE))
-        return {};
     try {
+        ensureDir();
+        if (!fs.existsSync(SESSION_FILE))
+            return {};
         return JSON.parse(fs.readFileSync(SESSION_FILE, 'utf-8'));
     }
     catch {
@@ -58,8 +63,13 @@ function loadStorage() {
     }
 }
 function saveStorage(data) {
-    ensureDir();
-    fs.writeFileSync(SESSION_FILE, JSON.stringify(data, null, 2), { mode: 0o600 });
+    try {
+        ensureDir();
+        fs.writeFileSync(SESSION_FILE, JSON.stringify(data, null, 2), { mode: 0o600 });
+    }
+    catch {
+        // Serverless / read-only filesystem — skip
+    }
 }
 /**
  * Install a globalThis.localStorage polyfill backed by ~/.tidal-cli/session.json.

package/dist/share.d.ts

@@ -0,0 +1,5 @@
+import type { ShareLink } from './types';
+export type { ShareLink };
+export type ShareableType = 'tracks' | 'albums';
+export declare function createShareData(resourceType: ShareableType, resourceId: string, client: any): Promise<ShareLink>;
+export declare function createShare(resourceType: ShareableType, resourceId: string, json: boolean): Promise<void>;

package/dist/share.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createShareData = createShareData;
+exports.createShare = createShare;
+const auth_1 = require("./auth");
+async function createShareData(resourceType, resourceId, client) {
+    const { data, error } = await client.POST('/shares', {
+        body: {
+            data: {
+                type: 'shares',
+                relationships: {
+                    sharedResources: {
+                        data: [{ id: resourceId, type: resourceType }],
+                    },
+                },
+            },
+        },
+    });
+    if (error || !data) {
+        throw new Error(`Failed to create share — ${JSON.stringify(error)}`);
+    }
+    const created = data.data ?? {};
+    const attrs = created.attributes ?? {};
+    const tidalLink = (attrs.externalLinks ?? []).find((l) => /tidal\.com/i.test(l?.href ?? ''));
+    return {
+        id: created.id,
+        code: attrs.code ?? '',
+        createdAt: attrs.createdAt,
+        url: tidalLink?.href ?? attrs.externalLinks?.[0]?.href,
+    };
+}
+async function createShare(resourceType, resourceId, json) {
+    const client = await (0, auth_1.getApiClient)();
+    try {
+        const result = await createShareData(resourceType, resourceId, client);
+        if (json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(`\nShare created for ${resourceType} ${resourceId}:`);
+        console.log(`  Code: ${result.code}`);
+        if (result.url)
+            console.log(`  URL: ${result.url}`);
+        if (result.createdAt)
+            console.log(`  Created: ${result.createdAt}`);
+        console.log();
+    }
+    catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=share.js.map

package/dist/track.d.ts

@@ -1,4 +1,18 @@
+import type { TrackInfo, SimilarTrack, RadioPlaylist } from './types';
+export type { TrackInfo, SimilarTrack };
+export declare function getTrackInfoData(trackId: string, client: any, countryCode: string): Promise<TrackInfo>;
 export declare function getTrackInfo(trackId: string, json: boolean): Promise<void>;
+export declare function getTrackRadioData(trackId: string, client: any, countryCode: string): Promise<RadioPlaylist[]>;
 export declare function getTrackRadio(trackId: string, json: boolean): Promise<void>;
+interface TrackByIsrcResult {
+    id: string;
+    title: string;
+    artists: string[];
+    duration: string;
+    isrc?: string;
+    popularity?: number;
+}
+export declare function getTrackByIsrcData(isrc: string, client: any, countryCode: string): Promise<TrackByIsrcResult[]>;
 export declare function getTrackByIsrc(isrc: string, json: boolean): Promise<void>;
+export declare function getSimilarTracksData(trackId: string, client: any, countryCode: string): Promise<SimilarTrack[]>;
 export declare function getSimilarTracks(trackId: string, json: boolean): Promise<void>;