@involvex/youtube-music-cli 0.0.22 → 0.0.24

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+## [0.0.24](https://github.com/involvex/youtube-music-cli/compare/v0.0.23...v0.0.24) (2026-02-20)
+
+### Features
+
+- add YouTube URL support for play command ([c09e411](https://github.com/involvex/youtube-music-cli/commit/c09e411dd36e5670727d3914203c5c66de08457b))
+
+## [0.0.23](https://github.com/involvex/youtube-music-cli/compare/v0.0.22...v0.0.23) (2026-02-20)
+
 ## [0.0.22](https://github.com/involvex/youtube-music-cli/compare/v0.0.21...v0.0.22) (2026-02-20)
 
 ### Features

package/dist/source/cli.js

@@ -15,7 +15,7 @@ import { APP_VERSION } from "./utils/constants.js";
 const cli = meow(`
 	Usage
 	  $ youtube-music-cli
-	  $ youtube-music-cli play <track-id>
+	  $ youtube-music-cli play <track-id|youtube-url>
 	  $ youtube-music-cli search <query>
 	  $ youtube-music-cli playlist <playlist-id>
 	  $ youtube-music-cli suggestions

package/dist/source/services/scrobbling/scrobbling.service.js

@@ -38,7 +38,7 @@ function buildLastfmSignature(params, secret) {
         .sort()
         .map(k => `${k}${params[k]}`)
         .join('');
-    return createHash('md5')
+    return createHash('sha256')
         .update(sorted + secret)
         .digest('hex');
 }

package/dist/source/services/web/static-file.service.d.ts

@@ -7,6 +7,7 @@ declare class StaticFileService {
      * Get MIME type for a file extension
      */
     private getMimeType;
+    private resolveSafeFilePath;
     /**
      * Load index.html into memory
      */

package/dist/source/services/web/static-file.service.js

@@ -1,7 +1,7 @@
 // Static file serving service for web UI
 import { readFile } from 'node:fs/promises';
 import { existsSync } from 'node:fs';
-import { extname, join, dirname } from 'node:path';
+import { extname, join, dirname, normalize, resolve, sep } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { logger } from "../logger/logger.service.js";
 const MIME_TYPES = {
@@ -55,6 +55,23 @@ class StaticFileService {
         const ext = extname(filePath).toLowerCase();
         return MIME_TYPES[ext] || 'application/octet-stream';
     }
+    resolveSafeFilePath(urlPath) {
+        let decodedPath;
+        try {
+            decodedPath = decodeURIComponent(urlPath);
+        }
+        catch {
+            return null;
+        }
+        const relativePath = normalize(decodedPath).replace(/^[\\/]+/, '');
+        const rootPath = resolve(this.webDistDir);
+        const resolvedPath = resolve(rootPath, relativePath);
+        const rootPrefix = rootPath.endsWith(sep) ? rootPath : `${rootPath}${sep}`;
+        if (resolvedPath !== rootPath && !resolvedPath.startsWith(rootPrefix)) {
+            return null;
+        }
+        return resolvedPath;
+    }
     /**
      * Load index.html into memory
      */
@@ -111,7 +128,12 @@ class StaticFileService {
             return;
         }
         // Serve static files
-        const filePath = join(this.webDistDir, urlPath);
+        const filePath = this.resolveSafeFilePath(urlPath);
+        if (!filePath) {
+            res.writeHead(400, { 'Content-Type': 'text/plain' });
+            res.end('Bad Request');
+            return;
+        }
         try {
             // Check if file exists
             if (!existsSync(filePath)) {

package/dist/source/services/youtube-music/api.js

@@ -1,10 +1,105 @@
-import { Innertube } from 'youtubei.js';
+import { Innertube, Log } from 'youtubei.js';
 import { logger } from "../logger/logger.service.js";
 import { getSearchCache } from "../cache/cache.service.js";
 // Initialize YouTube client
 let ytClient = null;
+function toMusicSearchType(searchType) {
+    switch (searchType) {
+        case 'songs': {
+            return 'song';
+        }
+        case 'albums': {
+            return 'album';
+        }
+        case 'artists': {
+            return 'artist';
+        }
+        case 'playlists': {
+            return 'playlist';
+        }
+        default: {
+            return 'all';
+        }
+    }
+}
+function getMusicShelfItems(shelf) {
+    if (!shelf || typeof shelf !== 'object') {
+        return [];
+    }
+    const contents = shelf.contents;
+    if (!Array.isArray(contents)) {
+        return [];
+    }
+    return contents.filter((item) => !!item && typeof item === 'object');
+}
+function parseVideoId(value) {
+    const trimmedValue = value.trim();
+    if (!trimmedValue) {
+        return null;
+    }
+    if (!trimmedValue.includes('://') && !trimmedValue.includes('/')) {
+        return trimmedValue;
+    }
+    try {
+        const parsedUrl = new URL(trimmedValue);
+        const vParam = parsedUrl.searchParams.get('v');
+        if (vParam) {
+            return vParam;
+        }
+        const host = parsedUrl.hostname.toLowerCase();
+        const isYouTubeHost = host === 'youtu.be' ||
+            host === 'youtube.com' ||
+            host.endsWith('.youtube.com') ||
+            host === 'music.youtube.com';
+        if (!isYouTubeHost) {
+            return null;
+        }
+        if (host === 'youtu.be') {
+            const pathId = parsedUrl.pathname.split('/').filter(Boolean)[0];
+            if (pathId) {
+                return pathId;
+            }
+        }
+        const pathId = parsedUrl.pathname
+            .split('/')
+            .filter(Boolean)
+            .find(part => part.length >= 8);
+        return pathId ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+function toTrack(item) {
+    const rawId = item.id?.trim() ?? '';
+    const videoId = rawId ? parseVideoId(rawId) : null;
+    if (!videoId) {
+        return null;
+    }
+    const artists = item.artists && item.artists.length > 0
+        ? item.artists.map(artist => ({
+            artistId: artist.channel_id || artist.id || '',
+            name: artist.name ?? 'Unknown',
+        }))
+        : [
+            {
+                artistId: item.author?.channel_id || item.author?.id || '',
+                name: item.author?.name ?? 'Unknown',
+            },
+        ];
+    return {
+        videoId,
+        title: item.title || item.name || 'Unknown',
+        artists,
+        duration: typeof item.duration === 'number'
+            ? item.duration
+            : (item.duration?.seconds ?? 0),
+    };
+}
 async function getClient() {
     if (!ytClient) {
+        // Suppress noisy youtubei.js parser warnings in TUI output.
+        Log.setLevel(Log.Level.ERROR);
         ytClient = await Innertube.create();
     }
     return ytClient;
@@ -13,7 +108,8 @@ class MusicService {
     searchCache = getSearchCache();
     async search(query, options = {}) {
         const searchType = options.type || 'all';
-        const cacheKey = `search:${searchType}:${options.limit ?? 20}:${query}`;
+        const resultLimit = options.limit ?? 20;
+        const cacheKey = `search:${searchType}:${resultLimit}:${query}`;
         // Return cached result if available
         const cached = this.searchCache.get(cacheKey);
         if (cached) {
@@ -26,17 +122,97 @@ class MusicService {
         const results = [];
         try {
             const yt = await getClient();
-            const search = (await yt.search(query));
-            // Process search results based on type
+            const musicSearch = (await yt.music.search(query, {
+                type: toMusicSearchType(searchType),
+            }));
             if (searchType === 'all' || searchType === 'songs') {
-                const videos = search.videos;
-                if (videos) {
-                    for (const video of videos) {
-                        if (video.type === 'Video' || video.id) {
+                const songItems = [
+                    ...getMusicShelfItems(musicSearch.songs),
+                    ...getMusicShelfItems(musicSearch.videos),
+                ];
+                for (const item of songItems) {
+                    const track = toTrack(item);
+                    if (!track) {
+                        continue;
+                    }
+                    results.push({
+                        type: 'song',
+                        data: track,
+                    });
+                }
+            }
+            if (searchType === 'all' || searchType === 'playlists') {
+                for (const playlist of getMusicShelfItems(musicSearch.playlists)) {
+                    const playlistId = playlist.id?.trim();
+                    if (!playlistId) {
+                        continue;
+                    }
+                    results.push({
+                        type: 'playlist',
+                        data: {
+                            playlistId,
+                            name: playlist.title || playlist.name || 'Unknown Playlist',
+                            tracks: [],
+                        },
+                    });
+                }
+            }
+            if (searchType === 'all' || searchType === 'artists') {
+                for (const artist of getMusicShelfItems(musicSearch.artists)) {
+                    const artistId = artist.id?.trim() ||
+                        artist.author?.channel_id ||
+                        artist.author?.id ||
+                        '';
+                    if (!artistId) {
+                        continue;
+                    }
+                    results.push({
+                        type: 'artist',
+                        data: {
+                            artistId,
+                            name: artist.name ||
+                                artist.title ||
+                                artist.author?.name ||
+                                'Unknown Artist',
+                        },
+                    });
+                }
+            }
+            if (searchType === 'all' || searchType === 'albums') {
+                for (const album of getMusicShelfItems(musicSearch.albums)) {
+                    const albumId = album.id?.trim();
+                    if (!albumId) {
+                        continue;
+                    }
+                    results.push({
+                        type: 'album',
+                        data: {
+                            albumId,
+                            name: album.title || album.name || 'Unknown Album',
+                            artists: (album.artists ?? []).map(artist => ({
+                                artistId: artist.channel_id || artist.id || '',
+                                name: artist.name ?? 'Unknown',
+                            })),
+                            tracks: [],
+                        },
+                    });
+                }
+            }
+            if (results.length === 0) {
+                const search = (await yt.search(query));
+                if (searchType === 'all' || searchType === 'songs') {
+                    const videos = search.videos;
+                    if (videos) {
+                        for (const video of videos) {
+                            const rawVideoId = video.id || video.video_id || '';
+                            const videoId = parseVideoId(rawVideoId);
+                            if ((!video.type && !rawVideoId) || !videoId) {
+                                continue;
+                            }
                             results.push({
                                 type: 'song',
                                 data: {
-                                    videoId: video.id || video.video_id || '',
+                                    videoId,
                                     title: (typeof video.title === 'string'
                                         ? video.title
                                         : video.title?.text) || 'Unknown',
@@ -56,46 +232,50 @@ class MusicService {
                         }
                     }
                 }
-            }
-            if (searchType === 'all' || searchType === 'playlists') {
-                const playlists = search.playlists;
-                if (playlists) {
-                    for (const playlist of playlists) {
-                        results.push({
-                            type: 'playlist',
-                            data: {
-                                playlistId: playlist.id || '',
-                                name: (typeof playlist.title === 'string'
-                                    ? playlist.title
-                                    : playlist.title?.text) || 'Unknown Playlist',
-                                tracks: [],
-                            },
-                        });
+                if (searchType === 'all' || searchType === 'playlists') {
+                    const playlists = search.playlists;
+                    if (playlists) {
+                        for (const playlist of playlists) {
+                            results.push({
+                                type: 'playlist',
+                                data: {
+                                    playlistId: playlist.id || '',
+                                    name: (typeof playlist.title === 'string'
+                                        ? playlist.title
+                                        : playlist.title?.text) || 'Unknown Playlist',
+                                    tracks: [],
+                                },
+                            });
+                        }
                     }
                 }
-            }
-            if (searchType === 'all' || searchType === 'artists') {
-                const channels = search.channels;
-                if (channels) {
-                    for (const channel of channels) {
-                        results.push({
-                            type: 'artist',
-                            data: {
-                                artistId: channel.id || channel.channelId || '',
-                                name: (typeof channel.author === 'string'
-                                    ? channel.author
-                                    : channel.author?.name) || 'Unknown Artist',
-                            },
-                        });
+                if (searchType === 'all' || searchType === 'artists') {
+                    const channels = search.channels;
+                    if (channels) {
+                        for (const channel of channels) {
+                            results.push({
+                                type: 'artist',
+                                data: {
+                                    artistId: channel.id || channel.channelId || '',
+                                    name: (typeof channel.author === 'string'
+                                        ? channel.author
+                                        : channel.author?.name) || 'Unknown Artist',
+                                },
+                            });
+                        }
                     }
                 }
             }
         }
         catch (error) {
-            console.error('Search failed:', error);
+            logger.error('MusicService', 'Search failed', {
+                query,
+                searchType,
+                error: error instanceof Error ? error.message : String(error),
+            });
         }
         const response = {
-            results,
+            results: results.slice(0, resultLimit),
             hasMore: false,
         };
         // Cache the result
@@ -103,8 +283,13 @@ class MusicService {
         return response;
     }
     async getTrack(videoId) {
+        const normalizedVideoId = parseVideoId(videoId);
+        if (!normalizedVideoId) {
+            logger.warn('MusicService', 'Invalid track id/url provided', { videoId });
+            return null;
+        }
         return {
-            videoId,
+            videoId: normalizedVideoId,
             title: 'Unknown Track',
             artists: [],
         };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@involvex/youtube-music-cli",
-	"version": "0.0.22",
+	"version": "0.0.24",
 	"description": "- A Commandline music player for youtube-music",
 	"repository": {
 		"type": "git",

package/readme.md

@@ -105,7 +105,7 @@ brew install involvex/youtube-music-cli/youtube-music-cli
 winget install Involvex.YoutubeMusicCLI
 ```
 
-> Maintainers: tag pushes trigger `.github/workflows/homebrew-publish.yml` and `.github/workflows/winget-publish.yml`. Set `WINGETCREATE_TOKEN` and make sure `Involvex.YoutubeMusicCLI` exists in winget-pkgs for automated updates.
+> Maintainers: tag pushes trigger `.github/workflows/homebrew-publish.yml` and `.github/workflows/winget-publish.yml`. Homebrew uses the tap format `involvex/youtube-music-cli/youtube-music-cli`, so ensure the formula file exists on the default branch at `Formula/youtube-music-cli.rb` for the tap installation to work. Set `WINGETCREATE_TOKEN` and make sure `Involvex.YoutubeMusicCLI` exists in winget-pkgs for automated updates.
 
 ### From Source
 
@@ -131,7 +131,7 @@ youtube-music-cli
 
 ```bash
 # Play a specific track
-youtube-music-cli play <video-id>
+youtube-music-cli play <video-id|youtube-url>
 
 # Search for music
 youtube-music-cli search "artist or song name"