@supasayan/ytm 1.0.0

package/server/services/ytmusicService.js

@@ -0,0 +1,62 @@
+import YTMusic from 'ytmusic-api';
+
+const ytmusic = new YTMusic();
+const initPromise = ytmusic.initialize();
+
+export async function searchSongs(query) {
+  await initPromise;
+  try {
+    const results = await ytmusic.searchSongs(query);
+    return results.slice(0, 20).map(result => ({
+      videoId: result.videoId,
+      title: result.name,
+      artist: result.artist?.name || 'Unknown Artist',
+      album: result.album?.name || null,
+      duration: result.duration,
+      thumbnail: result.thumbnails?.[result.thumbnails.length - 1]?.url || null
+    }));
+  } catch (error) {
+    console.error('ytmusicService search error:', error);
+    throw new Error('Failed to search songs');
+  }
+}
+
+export async function getPlaylist(playlistId) {
+  await initPromise;
+  try {
+    const playlist = await ytmusic.getPlaylist(playlistId);
+    if (!playlist) throw new Error('Playlist not found');
+    
+    // In ytmusic-api, getPlaylist gets the metadata but NOT the tracks/videos.
+    // We must call getPlaylistVideos to retrieve the tracklist.
+    const videos = await ytmusic.getPlaylistVideos(playlistId);
+    
+    return {
+      title: playlist.name || 'Unknown Playlist',
+      trackCount: videos.length || playlist.trackCount || 0,
+      tracks: videos.map(result => ({
+        videoId: result.videoId,
+        title: result.name,
+        artist: result.artist?.name || 'Unknown Artist',
+        album: null, // Playlists usually don't return album names in basic response
+        duration: result.duration,
+        thumbnail: result.thumbnails?.[result.thumbnails.length - 1]?.url || null
+      }))
+    };
+  } catch (error) {
+    console.error('ytmusicService getPlaylist error:', error);
+    throw new Error('Failed to fetch playlist');
+  }
+}
+
+export async function getLyricsText(videoId) {
+  await initPromise;
+  try {
+    const lines = await ytmusic.getLyrics(videoId);
+    if (!lines || lines.length === 0) return null;
+    return lines.join('\n');
+  } catch (error) {
+    console.warn(`[ytmusicService] Lyrics not available for video ${videoId}:`, error.message);
+    return null;
+  }
+}

package/server/utils/dependencyChecker.js

@@ -0,0 +1,174 @@
+import fs from 'fs';
+import path from 'path';
+import https from 'https';
+import { execSync } from 'child_process';
+import ffmpeg from 'ffmpeg-static';
+import { getDataDir } from './paths.js';
+
+const BIN_DIR = path.join(getDataDir(), 'bin');
+let YTDLP_PATH = 'yt-dlp';
+let FFMPEG_PATH = ffmpeg || 'ffmpeg';
+
+const status = {
+  status: 'idle', // 'idle' | 'checking' | 'downloading' | 'ready' | 'failed'
+  ytDlp: 'idle', // 'idle' | 'checking' | 'downloading' | 'ready' | 'failed'
+  ffmpeg: 'idle', // 'idle' | 'checking' | 'ready' | 'failed'
+  error: null
+};
+
+function downloadFile(url, destPath) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(destPath);
+    function get(reqUrl) {
+      https.get(reqUrl, (response) => {
+        if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+          get(response.headers.location);
+          return;
+        }
+        if (response.statusCode !== 200) {
+          reject(new Error(`Failed to download from ${reqUrl}: Status Code ${response.statusCode}`));
+          return;
+        }
+        response.pipe(file);
+        file.on('finish', () => {
+          file.close(resolve);
+        });
+      }).on('error', (err) => {
+        fs.unlink(destPath, () => reject(err));
+      });
+    }
+    get(url);
+  });
+}
+
+export async function checkAndSetupDependencies() {
+  status.status = 'checking';
+  status.ytDlp = 'checking';
+  status.ffmpeg = 'checking';
+  console.log('[System Check] Commencing system dependency check...');
+
+  // 1. FFmpeg Verification
+  try {
+    if (ffmpeg) {
+      console.log(`[System Check] FFmpeg resolved via ffmpeg-static at: ${ffmpeg}`);
+      FFMPEG_PATH = ffmpeg;
+      status.ffmpeg = 'ready';
+    } else {
+      execSync('ffmpeg -version', { stdio: 'ignore' });
+      console.log('[System Check] FFmpeg resolved via global installation.');
+      FFMPEG_PATH = 'ffmpeg';
+      status.ffmpeg = 'ready';
+    }
+  } catch (err) {
+    console.error('[System Check] FFmpeg check failed globally.', err);
+    status.ffmpeg = 'failed';
+    status.error = 'FFmpeg is not installed on this system.';
+  }
+
+  // 2. yt-dlp Verification
+  try {
+    let resolvedGlobal = false;
+    if (process.platform === 'darwin') {
+      const commonPaths = ['/opt/homebrew/bin/yt-dlp', '/usr/local/bin/yt-dlp', '/usr/bin/yt-dlp'];
+      for (const p of commonPaths) {
+        if (fs.existsSync(p)) {
+          try {
+            execSync(`"${p}" --version`, { stdio: 'ignore' });
+            console.log(`[System Check] yt-dlp resolved at common macOS path: ${p}`);
+            YTDLP_PATH = p;
+            status.ytDlp = 'ready';
+            resolvedGlobal = true;
+            break;
+          } catch (e) {}
+        }
+      }
+    }
+
+    if (!resolvedGlobal) {
+      execSync('yt-dlp --version', { stdio: 'ignore' });
+      console.log('[System Check] yt-dlp resolved via global installation.');
+      YTDLP_PATH = 'yt-dlp';
+      status.ytDlp = 'ready';
+    }
+  } catch (err) {
+    console.log('[System Check] yt-dlp not found globally. Checking local bin/ folder...');
+    
+    // Ensure bin folder exists
+    if (!fs.existsSync(BIN_DIR)) {
+      fs.mkdirSync(BIN_DIR, { recursive: true });
+    }
+
+    const binaryName = process.platform === 'win32' ? 'yt-dlp.exe' : 'yt-dlp';
+    const localPath = path.join(BIN_DIR, binaryName);
+
+    if (fs.existsSync(localPath)) {
+      try {
+        if (process.platform !== 'win32') {
+          fs.chmodSync(localPath, '755');
+          if (process.platform === 'darwin') {
+            try { execSync(`xattr -d com.apple.quarantine "${localPath}"`, { stdio: 'ignore' }); } catch (e) {}
+          }
+        }
+        execSync(`"${localPath}" --version`, { stdio: 'ignore' });
+        console.log(`[System Check] Local yt-dlp found at: ${localPath}`);
+        YTDLP_PATH = localPath;
+        status.ytDlp = 'ready';
+      } catch (binErr) {
+        console.warn('[System Check] Local yt-dlp check failed, starting re-download.', binErr);
+        try { fs.unlinkSync(localPath); } catch (e) {}
+      }
+    }
+
+    // Download if not resolved
+    if (status.ytDlp !== 'ready') {
+      try {
+        status.status = 'downloading';
+        status.ytDlp = 'downloading';
+        console.log('[System Check] Downloading yt-dlp from GitHub...');
+
+        let downloadUrl = 'https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp';
+        if (process.platform === 'win32') {
+          downloadUrl = 'https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp.exe';
+        } else if (process.platform === 'darwin') {
+          // Use the shebang-based Python script instead of yt-dlp_macos to avoid PyInstaller 30s decompression delay on macOS
+          downloadUrl = 'https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp';
+        }
+
+        await downloadFile(downloadUrl, localPath);
+        
+        if (process.platform !== 'win32') {
+          fs.chmodSync(localPath, '755');
+          if (process.platform === 'darwin') {
+            try { execSync(`xattr -d com.apple.quarantine "${localPath}"`, { stdio: 'ignore' }); } catch (e) {}
+          }
+        }
+
+        // Final verification of downloaded binary
+        execSync(`"${localPath}" --version`, { stdio: 'ignore' });
+        console.log(`[System Check] yt-dlp successfully downloaded and verified at: ${localPath}`);
+        YTDLP_PATH = localPath;
+        status.ytDlp = 'ready';
+      } catch (dlErr) {
+        console.error('[System Check] Failed to download or verify local yt-dlp:', dlErr);
+        status.ytDlp = 'failed';
+        status.error = `yt-dlp is missing and auto-download failed: ${dlErr.message}`;
+      }
+    }
+  }
+
+  // Final Overall Status
+  if (status.ffmpeg === 'ready' && status.ytDlp === 'ready') {
+    status.status = 'ready';
+    status.error = null;
+    console.log('[System Check] Setup successful! All dependencies resolved.');
+  } else {
+    status.status = 'failed';
+    console.error('[System Check] Setup failed. Dependencies are incomplete.');
+  }
+}
+
+export function getDependencyStatus() {
+  return status;
+}
+
+export { YTDLP_PATH, FFMPEG_PATH };

package/server/utils/paths.js

@@ -0,0 +1,11 @@
+import os from 'os';
+import path from 'path';
+import fs from 'fs';
+
+export function getDataDir() {
+  const dir = path.join(os.homedir(), '.ytm');
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}

package/server/utils/sanitize.js

@@ -0,0 +1,9 @@
+export function sanitizeFilename(name) {
+  if (!name) return 'Unknown';
+  // Replace illegal filename characters with underscores
+  const sanitized = name.replace(/[\\/:*?"<>|]/g, '_');
+  // Trim whitespace
+  const trimmed = sanitized.trim();
+  // Limit to 200 chars
+  return trimmed.substring(0, 200);
+}