ssdl 1.0.0

package/src/app.js

@@ -0,0 +1,327 @@
+import { createInputHandler } from './tui/input.js';
+import { render, c, cursor, screen } from './tui/renderer.js';
+import { formatDuration } from './utils/format.js';
+import { loadConfig, saveConfig, hasCredentials } from './utils/config.js';
+import { textInput } from './tui/input.js';
+import * as spotify from './services/spotify.js';
+import { showWelcome } from './screens/Welcome.js';
+import { showURLInput } from './screens/URLInput.js';
+import { showSearch } from './screens/Search.js';
+import { showTrackList } from './screens/TrackList.js';
+import { showDownloading } from './screens/Downloading.js';
+import { showComplete } from './screens/Complete.js';
+
+/**
+ * Main application — handles screen routing and state management
+ */
+export async function startApp(initialUrl = null) {
+    const input = createInputHandler();
+    const config = loadConfig();
+
+    // Ensure clean exit
+    process.on('exit', () => {
+        cursor.show();
+        if (process.stdin.isTTY) {
+            try { process.stdin.setRawMode(false); } catch { }
+        }
+    });
+
+    cursor.hide();
+
+    try {
+        // ─── Step 1: Check / prompt for Spotify credentials ────
+        if (!hasCredentials(config)) {
+            await promptCredentials(input, config);
+        }
+
+        // ─── Step 2: Authenticate with Spotify ─────────────────
+        if (!spotify.isAuthenticated()) {
+            screen.clear();
+            render('\n' + c.cyan('  Authenticating with Spotify...'));
+
+            try {
+                await spotify.authenticate(config.spotifyClientId, config.spotifyClientSecret);
+            } catch (err) {
+                render('\n' + c.red(`  ✗ Authentication failed: ${err.message}\n\n`) +
+                    c.dim('  Check your Client ID and Secret.\n') +
+                    c.dim('  Run ssdl again to re-enter credentials.\n'));
+
+                // Clear saved credentials so they're prompted again
+                config.spotifyClientId = '';
+                config.spotifyClientSecret = '';
+                saveConfig(config);
+
+                cursor.show();
+                input.destroy();
+                process.exit(1);
+            }
+        }
+
+        // ─── Step 3: If a URL was passed as argument, skip to it ─
+        if (initialUrl) {
+            await handleUrl(initialUrl, config, input);
+            cursor.show();
+            input.destroy();
+            return;
+        }
+
+        // ─── Step 4: Main loop — Welcome screen ────────────────
+        let running = true;
+        while (running) {
+            const action = await showWelcome(input);
+
+            switch (action) {
+                case 'url': {
+                    const url = await showURLInput(input);
+                    if (url) {
+                        await handleUrl(url, config, input);
+                    }
+                    break;
+                }
+
+                case 'search': {
+                    const track = await showSearch(input);
+                    if (track) {
+                        await handleTracks([track], 'track', config, input);
+                    }
+                    break;
+                }
+
+                case 'settings': {
+                    await showSettings(input, config);
+                    break;
+                }
+
+                case 'exit':
+                    running = false;
+                    break;
+            }
+        }
+    } finally {
+        cursor.show();
+        input.destroy();
+        screen.clear();
+        console.log(c.dim('  Goodbye!\n'));
+    }
+}
+
+/**
+ * Handle a Spotify URL — parse, fetch metadata, show tracks, download
+ */
+async function handleUrl(url, config, input) {
+    const parsed = spotify.parseSpotifyUrl(url);
+
+    if (!parsed) {
+        render(
+            '\n' +
+            c.red('  Invalid Spotify URL\n\n') +
+            c.dim('  Supported formats:\n') +
+            c.dim('    open.spotify.com/track/...\n') +
+            c.dim('    open.spotify.com/album/...\n') +
+            c.dim('    open.spotify.com/playlist/...\n\n') +
+            c.dim('  Press Enter to go back')
+        );
+
+        return new Promise((resolve) => {
+            input.clearHandlers();
+            input.on('return', () => { input.clearHandlers(); resolve(); });
+            input.on('escape', () => { input.clearHandlers(); resolve(); });
+        });
+    }
+
+    // Fetch metadata
+    const typeLabel = parsed.type.charAt(0).toUpperCase() + parsed.type.slice(1);
+    render('\n' + c.cyan(`  Fetching ${typeLabel.toLowerCase()} info...`));
+
+    let data;
+    try {
+        switch (parsed.type) {
+            case 'track':
+                data = await spotify.getTrack(parsed.id);
+                break;
+            case 'playlist':
+                data = await spotify.getPlaylist(parsed.id);
+                break;
+            case 'album':
+                data = await spotify.getAlbum(parsed.id);
+                break;
+        }
+    } catch (err) {
+        render(
+            '\n' +
+            c.red(`  Failed to fetch: ${err.message}\n\n`) +
+            c.dim('  Check the URL and try again\n\n') +
+            c.dim('  Press Enter to go back')
+        );
+        return new Promise((resolve) => {
+            input.clearHandlers();
+            input.on('return', () => { input.clearHandlers(); resolve(); });
+            input.on('escape', () => { input.clearHandlers(); resolve(); });
+        });
+    }
+
+    // For single track, show preview first
+    if (parsed.type === 'track') {
+        const confirmed = await showTrackPreview(data, input);
+        if (confirmed) {
+            await handleTracks([data], 'track', config, input);
+        }
+    } else {
+        await handleTracks(data, parsed.type, config, input);
+    }
+}
+
+/**
+ * Show a preview of a single track before downloading
+ */
+async function showTrackPreview(track, input) {
+    return new Promise((resolve) => {
+        let content = '\n';
+        content += c.brightCyan('  Track found\n');
+        content += c.dim('  ─────────────────────────────────────────────────────\n\n');
+        content += `  ${c.brightWhite(track.title)}\n`;
+        content += `  ${c.cyan(track.artist)}\n`;
+        content += `  ${c.dim(track.album)}`;
+        if (track.releaseDate) content += c.dim(`  (${track.releaseDate.slice(0, 4)})`);
+        content += '\n';
+        content += `  ${c.dim(formatDuration(track.duration))}\n`;
+        content += '\n';
+        content += c.dim('  ─────────────────────────────────────────────────────\n');
+        content += '\n';
+        content += c.dim('  Enter download | Esc back');
+
+        render(content);
+
+        input.clearHandlers();
+        input.on('return', () => { input.clearHandlers(); resolve(true); });
+        input.on('escape', () => { input.clearHandlers(); resolve(false); });
+    });
+}
+
+/**
+ * Handle track selection and download flow
+ */
+async function handleTracks(data, type, config, input) {
+    // Show track list for selection (for playlists/albums)
+    const selectedTracks = await showTrackList(data, type, input);
+    if (!selectedTracks || selectedTracks.length === 0) return;
+
+    // Download
+    const startTime = Date.now();
+    const results = await showDownloading(selectedTracks, config.downloadDir);
+
+    // Show completion
+    const action = await showComplete(results, config.downloadDir, startTime, input);
+    if (action === 'quit') {
+        cursor.show();
+        input.destroy();
+        process.exit(0);
+    }
+}
+
+/**
+ * Prompt for Spotify credentials on first run
+ */
+async function promptCredentials(input, config) {
+    render(
+        '\n' +
+        c.brightCyan('  Welcome to ssdl!\n\n') +
+        c.white('  To get started, you need Spotify API credentials.\n\n') +
+        c.dim('  1. Go to ') + c.cyan('https://developer.spotify.com/dashboard') + '\n' +
+        c.dim('  2. Create a new app\n') +
+        c.dim('  3. Copy your Client ID and Client Secret\n\n')
+    );
+
+    // Get Client ID
+    const clientId = await textInput(input, (text) => {
+        let content = '\n';
+        content += c.brightCyan('  Spotify Setup\n\n');
+        content += c.dim('  Create an app at: ') + c.cyan('https://developer.spotify.com/dashboard\n\n');
+        content += c.white('  Enter your Client ID:\n');
+        content += `  > ${text}${c.dim('█')}\n`;
+        render(content);
+    });
+
+    if (!clientId) {
+        console.log(c.red('\n  Setup cancelled.\n'));
+        process.exit(1);
+    }
+
+    // Get Client Secret
+    const clientSecret = await textInput(input, (text) => {
+        let content = '\n';
+        content += c.brightCyan('  Spotify Setup\n\n');
+        content += c.green(`  ✓  Client ID: ${clientId.slice(0, 8)}...\n\n`);
+        content += c.white('  Enter your Client Secret:\n');
+        content += `  > ${text}${c.dim('█')}\n`;
+        render(content);
+    });
+
+    if (!clientSecret) {
+        console.log(c.red('\n  Setup cancelled.\n'));
+        process.exit(1);
+    }
+
+    // Save credentials
+    config.spotifyClientId = clientId.trim();
+    config.spotifyClientSecret = clientSecret.trim();
+    saveConfig(config);
+
+    render('\n' + c.green('  ✓  Credentials saved to ~/.ssdl/config.json\n'));
+    await new Promise(r => setTimeout(r, 1000));
+}
+
+/**
+ * Settings screen
+ */
+async function showSettings(input, config) {
+    const items = [
+        { label: `Download directory: ${c.cyan(config.downloadDir)}`, value: 'downloadDir' },
+        { label: `Reset Spotify credentials`, value: 'resetCreds' },
+        { label: `Back`, value: 'back' },
+    ];
+
+    const { menuSelect } = await import('./tui/input.js');
+
+    const selectedIdx = await menuSelect(items, input, (items, selected) => {
+        let content = '\n';
+        content += c.brightCyan('  Settings\n\n');
+
+        items.forEach((item, i) => {
+            const prefix = i === selected ? c.brightCyan('  ❯ ') : '    ';
+            const label = i === selected ? c.brightWhite(item.label) : item.label;
+            content += `${prefix}${label}\n`;
+        });
+
+        content += '\n' + c.dim('  ↑/↓ navigate │ Enter select │ Esc back');
+        render(content);
+    });
+
+    if (selectedIdx === -1 || items[selectedIdx].value === 'back') return;
+
+    if (items[selectedIdx].value === 'downloadDir') {
+        const newDir = await textInput(input, (text) => {
+            let content = '\n';
+            content += c.brightCyan('  Set download directory:\n\n');
+            content += `  > ${text}${c.dim('█')}\n\n`;
+            content += c.dim(`  Current: ${config.downloadDir}\n`);
+            content += c.dim('  Press Enter to save, Esc to cancel\n');
+            render(content);
+        }, config.downloadDir);
+
+        if (newDir) {
+            config.downloadDir = newDir.trim();
+            saveConfig(config);
+            render('\n' + c.green('  ✓  Download directory updated!\n'));
+            await new Promise(r => setTimeout(r, 1000));
+        }
+    }
+
+    if (items[selectedIdx].value === 'resetCreds') {
+        config.spotifyClientId = '';
+        config.spotifyClientSecret = '';
+        saveConfig(config);
+        render('\n' + c.green('  ✓  Credentials cleared. You\'ll be prompted on next run.\n'));
+        await new Promise(r => setTimeout(r, 1500));
+    }
+}

package/src/constants.js

@@ -0,0 +1,91 @@
+// ─── App Info ────────────────────────────────────────────
+export const APP_NAME = 'ssdl';
+export const APP_VERSION = '1.0.0';
+export const APP_DESCRIPTION = 'Spotify Song Downloader';
+
+// ─── Paths ───────────────────────────────────────────────
+import { homedir } from 'os';
+import { join } from 'path';
+
+export const CONFIG_DIR = join(homedir(), '.ssdl');
+export const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+export const DEFAULT_DOWNLOAD_DIR = join(homedir(), 'Music', 'ssdl');
+
+// ─── Spotify ─────────────────────────────────────────────
+export const SPOTIFY_TOKEN_URL = 'https://accounts.spotify.com/api/token';
+export const SPOTIFY_API_BASE = 'https://api.spotify.com/v1';
+
+// ─── ANSI Colors ─────────────────────────────────────────
+export const COLORS = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  italic: '\x1b[3m',
+  underline: '\x1b[4m',
+
+  // Foreground
+  black: '\x1b[30m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m',
+  white: '\x1b[37m',
+
+  // Bright foreground
+  brightBlack: '\x1b[90m',
+  brightRed: '\x1b[91m',
+  brightGreen: '\x1b[92m',
+  brightYellow: '\x1b[93m',
+  brightBlue: '\x1b[94m',
+  brightMagenta: '\x1b[95m',
+  brightCyan: '\x1b[96m',
+  brightWhite: '\x1b[97m',
+
+  // Background
+  bgBlack: '\x1b[40m',
+  bgRed: '\x1b[41m',
+  bgGreen: '\x1b[42m',
+  bgYellow: '\x1b[43m',
+  bgBlue: '\x1b[44m',
+  bgMagenta: '\x1b[45m',
+  bgCyan: '\x1b[46m',
+  bgWhite: '\x1b[47m',
+};
+
+// ─── Box Drawing Characters ──────────────────────────────
+export const BOX = {
+  topLeft: '╭',
+  topRight: '╮',
+  bottomLeft: '╰',
+  bottomRight: '╯',
+  horizontal: '─',
+  vertical: '│',
+  teeRight: '├',
+  teeLeft: '┤',
+  teeDown: '┬',
+  teeUp: '┴',
+  cross: '┼',
+};
+
+// ─── Symbols ─────────────────────────────────────────────
+export const SYMBOLS = {
+  check: '✅',
+  cross: '❌',
+  spinner: '🔄',
+  queue: '⏳',
+  music: '🎵',
+  folder: '📁',
+  link: '🔗',
+  search: '🔍',
+  download: '⬇️',
+  settings: '⚙️',
+  clipboard: '📋',
+  arrow: '❯',
+  dot: '●',
+  block: '█',
+  blockLight: '░',
+  blockMed: '▒',
+  blockFull: '████',
+};

package/src/screens/Complete.js

@@ -0,0 +1,73 @@
+import { render, c } from '../tui/renderer.js';
+import { formatBytes, formatTime, truncate } from '../utils/format.js';
+
+/**
+ * Show the completion screen with download summary
+ * @param {object[]} results - Array of download results
+ * @param {string} outputDir - Download directory
+ * @param {number} startTime - Timestamp when downloads started
+ * @returns {Promise<string>} 'back' or 'quit'
+ */
+export async function showComplete(results, outputDir, startTime, input) {
+    const totalTime = (Date.now() - startTime) / 1000;
+    const successful = results.filter(r => r.success);
+    const failed = results.filter(r => !r.success);
+    const totalSize = successful.reduce((sum, r) => sum + (r.fileSize || 0), 0);
+
+    return new Promise((resolve) => {
+        let content = '\n';
+
+        // Header
+        if (failed.length === 0) {
+            content += c.brightGreen('  All downloads complete!\n');
+        } else if (successful.length > 0) {
+            content += c.yellow(`  Downloads finished with ${failed.length} error${failed.length > 1 ? 's' : ''}\n`);
+        } else {
+            content += c.red('  All downloads failed\n');
+        }
+
+        content += c.dim('  ─────────────────────────────────────────────────────\n\n');
+
+        // Successful downloads
+        if (successful.length > 0) {
+            content += c.dim('  Saved to: ') + c.cyan(outputDir + '/') + '\n\n';
+
+            for (let i = 0; i < successful.length; i++) {
+                const r = successful[i];
+                const num = c.dim(String(i + 1).padStart(2) + '.');
+                const name = truncate(`${r.track.title} — ${r.track.artist}`, 42);
+                const size = r.fileSize ? c.dim(formatBytes(r.fileSize)) : '';
+                content += `  ${c.green('+')} ${num} ${name}  ${size}\n`;
+            }
+        }
+
+        // Failed downloads
+        if (failed.length > 0) {
+            content += '\n';
+            content += c.red(`  Failed:\n`);
+            for (const r of failed) {
+                const name = truncate(`${r.track.title} — ${r.track.artist}`, 42);
+                content += `  ${c.red('x')}    ${name}\n`;
+                content += c.dim(`         ${r.error}\n`);
+            }
+        }
+
+        // Summary bar
+        content += '\n';
+        content += c.dim('  ─────────────────────────────────────────────────────\n');
+        const parts = [];
+        parts.push(`${successful.length}/${results.length} downloaded`);
+        if (totalSize > 0) parts.push(formatBytes(totalSize));
+        parts.push(formatTime(totalTime));
+        content += `  ${c.brightCyan(parts.join('  |  '))}\n`;
+
+        content += '\n' + c.dim('  Enter go back | Q quit');
+
+        render(content);
+
+        input.clearHandlers();
+        input.on('return', () => { input.clearHandlers(); resolve('back'); });
+        input.on('q', () => { input.clearHandlers(); resolve('quit'); });
+        input.on('Q', () => { input.clearHandlers(); resolve('quit'); });
+    });
+}

package/src/screens/Downloading.js

@@ -0,0 +1,176 @@
+import { render, progressBar, c } from '../tui/renderer.js';
+import { searchTrack } from '../services/youtube.js';
+import { downloadTrack } from '../services/downloader.js';
+import { embedMetadata } from '../services/metadata.js';
+import { truncate, formatBytes } from '../utils/format.js';
+import { statSync } from 'fs';
+
+/**
+ * Show the download progress screen
+ * Downloads all selected tracks sequentially
+ * @param {object[]} tracks - Array of track metadata
+ * @param {string} outputDir - Download directory
+ * @returns {Promise<object[]>} Array of download results
+ */
+export async function showDownloading(tracks, outputDir) {
+    const results = [];
+    const startTime = Date.now();
+
+    // Status for each track
+    const statuses = tracks.map(() => ({
+        status: 'queued', percent: 0, message: '', filePath: '', fileSize: 0,
+    }));
+
+    function drawProgress() {
+        let content = '\n';
+        const done = statuses.filter(s => s.status === 'done').length;
+        const errors = statuses.filter(s => s.status === 'error').length;
+        const elapsed = Math.round((Date.now() - startTime) / 1000);
+
+        // Header with overall progress
+        content += c.brightCyan(`  Downloading`) + c.dim(` ${done}/${tracks.length}`) + '\n';
+        content += c.dim(`  ─────────────────────────────────────────────────────\n`);
+
+        // Calculate visible window
+        const maxVisible = Math.min(tracks.length, Math.max(8, process.stdout.rows - 10));
+
+        // Find the current active track to center view on it
+        let activeIdx = statuses.findIndex(s =>
+            s.status === 'searching' || s.status === 'downloading' || s.status === 'metadata'
+        );
+        if (activeIdx === -1) activeIdx = done + errors;
+
+        let startIdx = Math.max(0, activeIdx - Math.floor(maxVisible / 2));
+        let endIdx = Math.min(tracks.length, startIdx + maxVisible);
+        if (endIdx - startIdx < maxVisible) startIdx = Math.max(0, endIdx - maxVisible);
+
+        for (let i = startIdx; i < endIdx; i++) {
+            const track = tracks[i];
+            const s = statuses[i];
+            const label = truncate(`${track.title} — ${track.artist}`, 36);
+            const num = c.dim(String(i + 1).padStart(2) + '.');
+
+            let icon, statusText;
+
+            switch (s.status) {
+                case 'queued':
+                    icon = c.dim('·');
+                    statusText = c.dim('waiting');
+                    content += `  ${icon} ${num} ${c.dim(label)}\n`;
+                    break;
+                case 'searching':
+                    icon = c.cyan('~');
+                    statusText = c.cyan('finding match...');
+                    content += `  ${icon} ${num} ${label}  ${statusText}\n`;
+                    break;
+                case 'downloading': {
+                    icon = c.yellow('>');
+                    const bar = progressBar(s.percent, 12);
+                    content += `  ${icon} ${num} ${label}\n`;
+                    content += `         ${bar}  ${c.dim(s.message || '')}\n`;
+                    break;
+                }
+                case 'metadata':
+                    icon = c.cyan('>');
+                    statusText = c.cyan('tagging...');
+                    content += `  ${icon} ${num} ${c.cyan(label)}  ${statusText}\n`;
+                    break;
+                case 'done': {
+                    icon = c.green('+');
+                    const size = s.fileSize > 0 ? c.dim(` ${formatBytes(s.fileSize)}`) : '';
+                    content += `  ${icon} ${num} ${c.green(label)}${size}\n`;
+                    break;
+                }
+                case 'error':
+                    icon = c.red('x');
+                    content += `  ${icon} ${num} ${c.red(label)}  ${c.dim(s.message)}\n`;
+                    break;
+            }
+        }
+
+        // Scroll indicator
+        if (tracks.length > maxVisible) {
+            content += c.dim(`\n  ... ${startIdx + 1}-${endIdx} of ${tracks.length}\n`);
+        }
+
+        // Footer status bar
+        content += '\n';
+        const mins = Math.floor(elapsed / 60);
+        const secs = elapsed % 60;
+        const timeStr = mins > 0 ? `${mins}m ${secs}s` : `${secs}s`;
+        content += c.dim(`  Elapsed: ${timeStr}`);
+        if (errors > 0) content += c.red(`  |  ${errors} failed`);
+
+        render(content);
+    }
+
+    // Download each track sequentially
+    for (let i = 0; i < tracks.length; i++) {
+        const track = tracks[i];
+
+        // Step 1: Find on YouTube
+        statuses[i].status = 'searching';
+        drawProgress();
+
+        let ytResult;
+        try {
+            ytResult = await searchTrack(track.title, track.artist, track.duration);
+            if (!ytResult) throw new Error('No match found');
+        } catch (err) {
+            statuses[i].status = 'error';
+            statuses[i].message = err.message;
+            results.push({ track, success: false, error: err.message });
+            drawProgress();
+            continue;
+        }
+
+        // Step 2: Download from YouTube
+        statuses[i].status = 'downloading';
+        drawProgress();
+
+        let filePath;
+        try {
+            filePath = await downloadTrack(ytResult.url, track, outputDir, (percent, msg) => {
+                statuses[i].percent = percent;
+                statuses[i].message = msg;
+                drawProgress();
+            });
+        } catch (err) {
+            statuses[i].status = 'error';
+            statuses[i].message = err.message;
+            results.push({ track, success: false, error: err.message });
+            drawProgress();
+            continue;
+        }
+
+        // Step 3: Embed metadata
+        statuses[i].status = 'metadata';
+        drawProgress();
+
+        try {
+            await embedMetadata(filePath, track);
+        } catch {
+            // Metadata failure is non-critical
+        }
+
+        // Done
+        statuses[i].status = 'done';
+        statuses[i].filePath = filePath;
+        try {
+            statuses[i].fileSize = statSync(filePath).size;
+        } catch {
+            statuses[i].fileSize = 0;
+        }
+
+        results.push({
+            track,
+            success: true,
+            filePath,
+            fileSize: statuses[i].fileSize,
+        });
+
+        drawProgress();
+    }
+
+    return results;
+}