@supasayan/ytm 1.0.0

package/server/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "ytm-downloader-server",
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "node --watch index.js"
+  },
+  "dependencies": {
+    "express": "^4.21.0",
+    "cors": "^2.8.5",
+    "ytmusic-api": "^5.0.0",
+    "ffmpeg-static": "^5.2.0"
+  }
+}

package/server/routes/browse.js

@@ -0,0 +1,23 @@
+import express from 'express';
+import { exec } from 'child_process';
+
+const router = express.Router();
+
+router.get('/', (req, res) => {
+  // Use macOS native AppleScript to open a folder picker
+  const script = `osascript -e 'POSIX path of (choose folder with prompt "Select Download Directory")'`;
+  
+  exec(script, (error, stdout, stderr) => {
+    if (error) {
+      console.error('Browse folder error:', error);
+      // User probably clicked 'Cancel' in the dialog
+      return res.status(400).json({ error: 'Folder selection cancelled or failed' });
+    }
+    
+    // Clean up the trailing newline
+    const selectedPath = stdout.trim();
+    res.json({ path: selectedPath });
+  });
+});
+
+export default router;

package/server/routes/download.js

@@ -0,0 +1,339 @@
+import express from 'express';
+import crypto from 'crypto';
+import fs from 'fs';
+import path from 'path';
+import { spawn } from 'child_process';
+import { downloadTrack } from '../services/downloadService.js';
+import { getLyricsText } from '../services/ytmusicService.js';
+import { FFMPEG_PATH, YTDLP_PATH } from '../utils/dependencyChecker.js';
+import { getDataDir } from '../utils/paths.js';
+
+const router = express.Router();
+
+const downloadsMap = new Map();
+const sseClients = new Set();
+const dirtyDownloads = new Set();
+
+// Queue state
+let downloadQueue = [];
+let activeDownloads = 0;
+const MAX_CONCURRENT = 3;
+let isQueuePaused = false;
+let queueSaveTimeout = null;
+
+const QUEUE_FILE = path.join(getDataDir(), 'queue.json');
+const QUEUE_FILE_TEMP = path.join(getDataDir(), 'queue.temp.json');
+
+// ---------------------------------------------------------
+// Disk Persistence
+// ---------------------------------------------------------
+function loadQueueFromDisk() {
+  if (fs.existsSync(QUEUE_FILE)) {
+    try {
+      const data = JSON.parse(fs.readFileSync(QUEUE_FILE, 'utf-8'));
+      if (Array.isArray(data.downloadsMap)) {
+        for (const [id, dl] of data.downloadsMap) {
+          // Reset 'downloading' to 'queued' on startup to allow them to retry
+          if (dl.status === 'downloading') {
+            dl.status = 'queued';
+            dl.percent = '0%';
+            dl.speed = '';
+            dl.eta = '';
+          }
+          downloadsMap.set(id, dl);
+        }
+      }
+      if (Array.isArray(data.downloadQueue)) {
+        downloadQueue = data.downloadQueue;
+      }
+      console.log(`[Queue] Loaded ${downloadQueue.length} pending tasks and ${downloadsMap.size} map entries from disk.`);
+    } catch (err) {
+      console.error('[Queue] Failed to load queue.json:', err);
+    }
+  }
+}
+
+function saveQueueToDisk() {
+  try {
+    const data = {
+      downloadsMap: Array.from(downloadsMap.entries()),
+      downloadQueue
+    };
+    fs.writeFileSync(QUEUE_FILE_TEMP, JSON.stringify(data, null, 2));
+    fs.renameSync(QUEUE_FILE_TEMP, QUEUE_FILE);
+  } catch (err) {
+    console.error('[Queue] Failed to save queue to disk:', err);
+  }
+}
+
+function scheduleSave() {
+  if (queueSaveTimeout) clearTimeout(queueSaveTimeout);
+  queueSaveTimeout = setTimeout(saveQueueToDisk, 2000);
+}
+
+// Load on boot, then start processing immediately just in case
+loadQueueFromDisk();
+processQueue(); // Kickoff any pending items loaded from disk
+
+// ---------------------------------------------------------
+// SSE Delta Streaming
+// ---------------------------------------------------------
+setInterval(() => {
+  if (dirtyDownloads.size > 0 && sseClients.size > 0) {
+    const updates = [];
+    for (const id of dirtyDownloads) {
+      const dl = downloadsMap.get(id);
+      if (dl) updates.push([id, dl]);
+    }
+    const payload = JSON.stringify({ type: 'DELTA', data: updates });
+    for (const client of sseClients) {
+      client.write(`data: ${payload}\n\n`);
+    }
+    dirtyDownloads.clear();
+  }
+}, 500);
+
+function markDirty(downloadId) {
+  dirtyDownloads.add(downloadId);
+  scheduleSave();
+}
+
+// ---------------------------------------------------------
+// Queue Processing
+// ---------------------------------------------------------
+async function processQueue() {
+  if (isQueuePaused || activeDownloads >= MAX_CONCURRENT || downloadQueue.length === 0) {
+    return;
+  }
+
+  activeDownloads++;
+  const task = downloadQueue.shift();
+  const { downloadId, videoId, title, outputDir, downloadLyrics } = task;
+
+  // Add 1.5s jitter before starting
+  await new Promise(resolve => setTimeout(resolve, 1500));
+
+  const onProgress = (progress) => {
+    const dl = downloadsMap.get(downloadId);
+    if (dl) {
+      dl.status = 'downloading';
+      dl.percent = progress.percent;
+      dl.speed = progress.speed;
+      dl.eta = progress.eta;
+      markDirty(downloadId);
+    }
+  };
+
+  const onComplete = async () => {
+    const dl = downloadsMap.get(downloadId);
+    if (dl) {
+      const sanitizedTitle = dl.title.replace(/[\\/:*?"<>|]/g, '_');
+      const finalPath = path.join(outputDir, `${sanitizedTitle}.m4a`);
+      
+      if (downloadLyrics) {
+        try {
+          const lyricsText = await getLyricsText(videoId);
+          if (lyricsText) {
+            await embedLyricsToM4A(finalPath, lyricsText);
+          }
+        } catch (err) {
+          console.error(`[Lyrics] Failed to download or embed lyrics for track: ${dl.title}`, err);
+        }
+      }
+
+      dl.status = 'completed';
+      dl.percent = '100%';
+      dl.filePath = finalPath;
+      markDirty(downloadId);
+    }
+    activeDownloads--;
+    processQueue();
+  };
+
+  const onError = (err) => {
+    const dl = downloadsMap.get(downloadId);
+    if (dl) {
+      dl.status = 'error';
+      dl.error = err.message;
+      markDirty(downloadId);
+    }
+    activeDownloads--;
+    
+    // Chain-Reaction Guards
+    const msg = err.message || '';
+    if (msg.includes('429') || msg.includes('403') || msg.includes('Sign in to confirm')) {
+      console.warn(`[Queue] YouTube Rate Limit/Ban detected! Pausing queue for 5 minutes.`);
+      isQueuePaused = true;
+      setTimeout(() => {
+        console.log(`[Queue] Resuming queue after 5 minute pause.`);
+        isQueuePaused = false;
+        processQueue();
+      }, 300000);
+    } else if (msg.includes('ENOSPC') || msg.includes('No space left')) {
+      console.error(`[Queue] Disk Full (ENOSPC)! Pausing queue indefinitely.`);
+      isQueuePaused = true;
+    } else {
+      processQueue();
+    }
+  };
+
+  // Pre-flight directory check
+  if (!fs.existsSync(outputDir)) {
+    try {
+      fs.mkdirSync(outputDir, { recursive: true });
+    } catch (err) {
+      onError(new Error(`Failed to create output directory: ${err.message}`));
+      return;
+    }
+  }
+
+  downloadTrack(videoId, title, outputDir, onProgress, onComplete, onError);
+}
+
+// ---------------------------------------------------------
+// Endpoints
+// ---------------------------------------------------------
+router.post('/', (req, res) => {
+  const { videoId, title, artist, album, thumbnail, outputDir, downloadLyrics } = req.body;
+  if (!videoId || !outputDir) return res.status(400).json({ error: 'Missing videoId or outputDir' });
+
+  // Duplicate Check
+  for (const dl of downloadsMap.values()) {
+    if (dl.videoId === videoId && (dl.status === 'queued' || dl.status === 'downloading')) {
+      return res.json({ downloadId: dl.downloadId, message: 'Already queued or downloading' });
+    }
+  }
+
+  const downloadId = crypto.randomUUID();
+  downloadsMap.set(downloadId, {
+    downloadId, videoId, title: title || 'Unknown Title', artist: artist || 'Unknown Artist',
+    album: album || null, thumbnail: thumbnail || null, status: 'queued', percent: '0%', speed: '', eta: ''
+  });
+  
+  markDirty(downloadId);
+  downloadQueue.push({ downloadId, videoId, title: title || 'Unknown Title', outputDir, downloadLyrics });
+  res.json({ downloadId, message: 'Download queued' });
+  
+  processQueue();
+});
+
+router.post('/bulk', (req, res) => {
+  const { songs, outputDir, downloadLyrics } = req.body;
+  if (!Array.isArray(songs) || !outputDir) return res.status(400).json({ error: 'Missing songs array or outputDir' });
+
+  // Pre-flight check
+  if (!fs.existsSync(outputDir)) {
+    try { fs.mkdirSync(outputDir, { recursive: true }); }
+    catch (err) { return res.status(400).json({ error: `Output directory invalid: ${err.message}` }); }
+  }
+
+  const queuedIds = [];
+  for (const song of songs) {
+    const { videoId, title, artist, album, thumbnail } = song;
+    if (!videoId) continue;
+    
+    // Duplicate Check
+    let isDupe = false;
+    for (const dl of downloadsMap.values()) {
+      if (dl.videoId === videoId && (dl.status === 'queued' || dl.status === 'downloading')) {
+        isDupe = true; break;
+      }
+    }
+    if (isDupe) continue;
+
+    const downloadId = crypto.randomUUID();
+    downloadsMap.set(downloadId, {
+      downloadId, videoId, title: title || 'Unknown Title', artist: artist || 'Unknown Artist',
+      album: album || null, thumbnail: thumbnail || null, status: 'queued', percent: '0%', speed: '', eta: ''
+    });
+    
+    markDirty(downloadId);
+    downloadQueue.push({ downloadId, videoId, title: title || 'Unknown Title', outputDir, downloadLyrics });
+    queuedIds.push(downloadId);
+  }
+
+  res.json({ queuedIds, message: `${queuedIds.length} downloads queued` });
+  processQueue();
+});
+
+router.post('/clear-queue', (req, res) => {
+  // Empty pending queue (does not stop actively downloading items)
+  downloadQueue = [];
+  // Update map state for ones that were purely queued
+  for (const dl of downloadsMap.values()) {
+    if (dl.status === 'queued') {
+      dl.status = 'error';
+      dl.error = 'Cancelled by user';
+      markDirty(dl.downloadId);
+    }
+  }
+  scheduleSave();
+  res.json({ message: 'Pending queue cleared' });
+});
+
+router.post('/clear-cache', (req, res) => {
+  for (const [id, dl] of downloadsMap.entries()) {
+    if (dl.status === 'completed' || dl.status === 'error') {
+      downloadsMap.delete(id);
+    }
+  }
+  scheduleSave();
+
+  import('child_process').then(({ exec }) => {
+    exec(`"${YTDLP_PATH}" --rm-cache-dir`, (err, stdout, stderr) => {
+      if (err) console.error('Failed to clear yt-dlp cache:', err);
+      else console.log('yt-dlp cache cleared successfully:', stdout.trim());
+    });
+  });
+
+  // Force broadcast initial state to sync UI deletion
+  const payload = JSON.stringify({ type: 'INITIAL', data: Array.from(downloadsMap.entries()) });
+  for (const client of sseClients) {
+    client.write(`data: ${payload}\n\n`);
+  }
+  res.json({ message: 'Cache cleared successfully' });
+});
+
+router.get('/progress', (req, res) => {
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    'Connection': 'keep-alive'
+  });
+
+  sseClients.add(res);
+
+  // Send INITIAL payload
+  res.write(`data: ${JSON.stringify({ type: 'INITIAL', data: Array.from(downloadsMap.entries()) })}\n\n`);
+
+  req.on('close', () => {
+    sseClients.delete(res);
+  });
+});
+
+// Helper at end
+function embedLyricsToM4A(filePath, lyricsText) {
+  return new Promise((resolve, reject) => {
+    const tempPath = filePath.replace(/\.m4a$/, '.temp.m4a');
+    const args = ['-y', '-i', filePath, '-metadata', `lyrics=${lyricsText}`, '-c', 'copy', tempPath];
+    const proc = spawn(FFMPEG_PATH, args);
+    proc.on('close', (code) => {
+      if (code === 0) {
+        try {
+          if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
+          fs.renameSync(tempPath, filePath);
+          resolve();
+        } catch (e) { reject(e); }
+      } else {
+        if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath);
+        reject(new Error(`FFmpeg exited with code ${code}`));
+      }
+    });
+    proc.on('error', (err) => {
+      if (fs.existsSync(tempPath)) fs.unlinkSync(tempPath);
+      reject(err);
+    });
+  });
+}
+
+export default router;

package/server/routes/playLocal.js

@@ -0,0 +1,50 @@
+import express from 'express';
+import fs from 'fs';
+
+const router = express.Router();
+
+router.get('/', (req, res) => {
+  const { path: filePath } = req.query;
+
+  if (!filePath) {
+    return res.status(400).json({ error: 'Missing file path' });
+  }
+
+  // Very basic check to ensure it's playing an m4a file
+  if (!filePath.endsWith('.m4a')) {
+    return res.status(400).json({ error: 'Only .m4a files are supported' });
+  }
+
+  if (!fs.existsSync(filePath)) {
+    return res.status(404).json({ error: 'File not found' });
+  }
+
+  const stat = fs.statSync(filePath);
+  const fileSize = stat.size;
+  const range = req.headers.range;
+
+  if (range) {
+    const parts = range.replace(/bytes=/, "").split("-");
+    const start = parseInt(parts[0], 10);
+    const end = parts[1] ? parseInt(parts[1], 10) : fileSize - 1;
+    const chunksize = (end - start) + 1;
+    const file = fs.createReadStream(filePath, { start, end });
+    
+    res.writeHead(206, {
+      'Content-Range': `bytes ${start}-${end}/${fileSize}`,
+      'Accept-Ranges': 'bytes',
+      'Content-Length': chunksize,
+      'Content-Type': 'audio/mp4',
+    });
+    
+    file.pipe(res);
+  } else {
+    res.writeHead(200, {
+      'Content-Length': fileSize,
+      'Content-Type': 'audio/mp4',
+    });
+    fs.createReadStream(filePath).pipe(res);
+  }
+});
+
+export default router;

package/server/routes/playlist.js

@@ -0,0 +1,28 @@
+import express from 'express';
+import { getPlaylist } from '../services/ytmusicService.js';
+
+const router = express.Router();
+
+router.post('/', async (req, res) => {
+  const urlStr = req.body.url;
+  if (!urlStr) {
+    return res.status(400).json({ error: 'Missing playlist URL' });
+  }
+
+  try {
+    const parsedUrl = new URL(urlStr);
+    const playlistId = parsedUrl.searchParams.get('list');
+    
+    if (!playlistId) {
+      return res.status(400).json({ error: 'Invalid playlist URL. Must contain a "list=" parameter.' });
+    }
+
+    const playlistData = await getPlaylist(playlistId);
+    res.json(playlistData);
+  } catch (error) {
+    console.error('Playlist route error:', error);
+    res.status(500).json({ error: 'Failed to fetch playlist', details: error.message });
+  }
+});
+
+export default router;

package/server/routes/search.js

@@ -0,0 +1,21 @@
+import express from 'express';
+import { searchSongs } from '../services/ytmusicService.js';
+
+const router = express.Router();
+
+router.get('/', async (req, res) => {
+  const query = req.query.q;
+  if (!query) {
+    return res.status(400).json({ error: 'Missing search query' });
+  }
+
+  try {
+    const results = await searchSongs(query);
+    res.json({ results });
+  } catch (error) {
+    console.error('Search route error:', error);
+    res.status(500).json({ error: 'Search failed', details: error.message });
+  }
+});
+
+export default router;

package/server/routes/stream.js

@@ -0,0 +1,53 @@
+import express from 'express';
+import { spawn } from 'child_process';
+import { YTDLP_PATH } from '../utils/dependencyChecker.js';
+
+const router = express.Router();
+
+router.get('/:videoId', (req, res) => {
+  const { videoId } = req.params;
+
+  if (!videoId) {
+    return res.status(400).json({ error: 'Missing videoId' });
+  }
+
+  res.setHeader('Content-Type', 'audio/mp4');
+  res.setHeader('Transfer-Encoding', 'chunked');
+  res.setHeader('Cache-Control', 'no-store');
+
+  const args = [
+    '--no-cache-dir',
+    '--extractor-args', 'youtube:player_client=android_vr,web,mweb',
+    '-f', 'bestaudio[ext=m4a]/bestaudio',
+    '--no-playlist',
+    '-o', '-',
+    `https://music.youtube.com/watch?v=${videoId}`
+  ];
+
+  const proc = spawn(YTDLP_PATH, args);
+
+  proc.stdout.pipe(res);
+
+  proc.stderr.on('data', (data) => {
+    // Only log errors, ignore warnings
+    const msg = data.toString();
+    if (msg.includes('ERROR:')) {
+      console.error(`[yt-dlp stream error] ${msg}`);
+    }
+  });
+
+  req.on('close', () => {
+    if (proc && !proc.killed) {
+      proc.kill('SIGINT');
+    }
+  });
+
+  proc.on('error', (err) => {
+    console.error('Failed to start yt-dlp process:', err);
+    if (!res.headersSent) {
+      res.status(500).end('Internal Server Error');
+    }
+  });
+});
+
+export default router;

package/server/services/downloadService.js

@@ -0,0 +1,143 @@
+import { spawn } from 'child_process';
+import { sanitizeFilename } from '../utils/sanitize.js';
+import fs from 'fs';
+import path from 'path';
+import { YTDLP_PATH } from '../utils/dependencyChecker.js';
+
+const activeProcesses = new Set();
+
+const killActiveProcesses = () => {
+  for (const proc of activeProcesses) {
+    if (!proc.killed) {
+      console.log(`[Shutdown] Killing orphaned yt-dlp process PID: ${proc.pid}`);
+      try { proc.kill('SIGKILL'); } catch (e) {}
+    }
+  }
+};
+
+process.on('exit', killActiveProcesses);
+process.on('SIGINT', () => {
+  killActiveProcesses();
+  process.exit(0);
+});
+process.on('SIGTERM', () => {
+  killActiveProcesses();
+  process.exit(0);
+});
+
+function cleanupTempFiles(outputDir, title) {
+  try {
+    if (!fs.existsSync(outputDir) || !title) return;
+
+    // Sanitize title matching yt-dlp filename cleaning rules
+    const sanitizedTitle = title.replace(/[\\/:*?"<>|]/g, '_');
+
+    const files = fs.readdirSync(outputDir);
+    // Temporary formats generated during downloading and post-processing
+    const tempExtensions = ['.webp', '.jpg', '.jpeg', '.png', '.part', '.ytdl', '.temp'];
+
+    files.forEach(file => {
+      // Check if file prefix matches the sanitized title
+      if (file.startsWith(sanitizedTitle)) {
+        const ext = path.extname(file).toLowerCase();
+        if (tempExtensions.includes(ext) || file.endsWith('.temp.webp') || file.endsWith('.m4a.part')) {
+          const fullPath = path.join(outputDir, file);
+          if (fs.existsSync(fullPath)) {
+            fs.unlinkSync(fullPath);
+            console.log(`[Clean-up] Cleaned stray failure file: ${file}`);
+          }
+        }
+      }
+    });
+  } catch (err) {
+    console.error('[Clean-up] Failed to delete temp files:', err);
+  }
+}
+
+export function downloadTrack(videoId, title, outputDir, onProgress, onComplete, onError) {
+  // Ensure output directory exists
+  if (!fs.existsSync(outputDir)) {
+    try {
+      fs.mkdirSync(outputDir, { recursive: true });
+    } catch (err) {
+      onError(new Error(`Failed to create output directory: ${err.message}`));
+      return null;
+    }
+  }
+
+  const args = [
+    '--no-cache-dir',
+    '--extractor-args', 'youtube:player_client=android_vr,web,mweb',
+    '-f', 'bestaudio[ext=m4a]/bestaudio',
+    '-x',
+    '--audio-format', 'm4a',
+    '--embed-metadata',
+    '--embed-thumbnail',
+    '--progress-template', '%(progress)j',
+    '-o', path.join(outputDir, '%(title)s.%(ext)s'),
+    '--no-playlist',
+    `https://music.youtube.com/watch?v=${videoId}`
+  ];
+
+  const proc = spawn(YTDLP_PATH, args, { timeout: 300000 }); // 5 minutes hard timeout
+  activeProcesses.add(proc);
+  
+  let stderrData = '';
+
+  proc.stdout.on('data', (data) => {
+    const lines = data.toString().split('\n');
+    lines.forEach(line => {
+      const trimmed = line.trim();
+      if (trimmed && trimmed.startsWith('{') && trimmed.endsWith('}')) {
+        try {
+          const progressInfo = JSON.parse(trimmed);
+          onProgress({
+            percent: progressInfo._percent_str || '0%',
+            speed: progressInfo._speed_str || 'Unknown',
+            eta: progressInfo._eta_str || 'Unknown'
+          });
+        } catch (e) {
+          // Ignore non-JSON stdout
+        }
+      }
+    });
+  });
+
+  proc.stderr.on('data', (data) => {
+    const msg = data.toString();
+    stderrData += msg;
+    console.error(`[yt-dlp stderr] ${msg}`);
+    if (msg.toLowerCase().includes('ffmpeg is not installed') || msg.toLowerCase().includes('ffprobe is not installed')) {
+      onError(new Error('FFmpeg is not installed'));
+    }
+  });
+
+  proc.on('close', (code, signal) => {
+    activeProcesses.delete(proc);
+    if (signal === 'SIGTERM') {
+      onError(new Error('Process timeout (5 minutes exceeded)'));
+      return;
+    }
+    if (code === 0) {
+      onComplete();
+    } else {
+      cleanupTempFiles(outputDir, title);
+      const lines = stderrData.split('\n');
+      const errorLine = lines.find(l => l.trim().startsWith('ERROR:')) || '';
+      const cleanError = errorLine ? errorLine.replace(/ERROR:\s*/i, '').trim() : `yt-dlp exited with code ${code}`;
+      onError(new Error(cleanError));
+    }
+  });
+
+  proc.on('error', (err) => {
+    activeProcesses.delete(proc);
+    cleanupTempFiles(outputDir, title);
+    if (err.code === 'ENOENT') {
+      onError(new Error('yt-dlp is not installed.'));
+    } else {
+      onError(err);
+    }
+  });
+
+  return proc;
+}