ssdl 1.0.0

package/src/services/youtube.js

@@ -0,0 +1,151 @@
+/**
+ * YouTube Music search — finds the best matching video for a track
+ * Uses YouTube Music's public search to avoid needing an API key
+ */
+
+const YT_MUSIC_URL = 'https://music.youtube.com';
+const YT_SEARCH_URL = 'https://www.youtube.com/results';
+
+/**
+ * Search for a track on YouTube and return the best match
+ */
+export async function searchTrack(title, artist, durationMs) {
+    const query = `${title} ${artist}`;
+
+    try {
+        // Try YouTube search page scrape
+        const result = await searchYouTube(query, durationMs);
+        if (result) return result;
+    } catch {
+        // Fallback: try a simpler search
+    }
+
+    // Fallback: use a basic search approach
+    return searchYouTubeFallback(query, durationMs);
+}
+
+/**
+ * Search YouTube by scraping search results page
+ */
+async function searchYouTube(query, durationMs) {
+    const encoded = encodeURIComponent(query);
+    const url = `${YT_SEARCH_URL}?search_query=${encoded}`;
+
+    const res = await fetch(url, {
+        headers: {
+            'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            'Accept-Language': 'en-US,en;q=0.9',
+        },
+    });
+
+    if (!res.ok) return null;
+
+    const html = await res.text();
+
+    // Extract ytInitialData JSON from the page
+    const dataMatch = html.match(/var ytInitialData = ({.*?});<\/script>/s);
+    if (!dataMatch) return null;
+
+    try {
+        const data = JSON.parse(dataMatch[1]);
+        const contents = data?.contents?.twoColumnSearchResultsRenderer?.primaryContents
+            ?.sectionListRenderer?.contents;
+
+        if (!contents) return null;
+
+        const videos = [];
+
+        for (const section of contents) {
+            const items = section?.itemSectionRenderer?.contents;
+            if (!items) continue;
+
+            for (const item of items) {
+                const video = item?.videoRenderer;
+                if (!video) continue;
+
+                const videoId = video.videoId;
+                const videoTitle = video?.title?.runs?.[0]?.text || '';
+                const videoDuration = parseDuration(video?.lengthText?.simpleText);
+
+                if (videoId && videoTitle) {
+                    videos.push({
+                        videoId,
+                        title: videoTitle,
+                        duration: videoDuration,
+                        url: `https://www.youtube.com/watch?v=${videoId}`,
+                    });
+                }
+            }
+        }
+
+        if (videos.length === 0) return null;
+
+        // Find best match by duration similarity
+        if (durationMs) {
+            const targetDuration = durationMs / 1000;
+            videos.sort((a, b) => {
+                const diffA = Math.abs(a.duration - targetDuration);
+                const diffB = Math.abs(b.duration - targetDuration);
+                return diffA - diffB;
+            });
+
+            // Only accept matches within 10 seconds of target duration
+            if (Math.abs(videos[0].duration - targetDuration) <= 10) {
+                return videos[0];
+            }
+        }
+
+        // If no duration match, return first result
+        return videos[0];
+    } catch {
+        return null;
+    }
+}
+
+/**
+ * Fallback: construct a YouTube Music search URL and extract video ID
+ * from the redirect
+ */
+async function searchYouTubeFallback(query, durationMs) {
+    const encoded = encodeURIComponent(query + ' audio');
+    const url = `${YT_SEARCH_URL}?search_query=${encoded}`;
+
+    const res = await fetch(url, {
+        headers: {
+            'User-Agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+            'Accept-Language': 'en-US,en;q=0.9',
+        },
+    });
+
+    if (!res.ok) return null;
+
+    const html = await res.text();
+
+    // Extract video IDs from the page with regex
+    const videoIds = [...html.matchAll(/\"videoId\":\"([a-zA-Z0-9_-]{11})\"/g)]
+        .map(m => m[1])
+        .filter((id, idx, arr) => arr.indexOf(id) === idx); // unique
+
+    if (videoIds.length === 0) {
+        throw new Error(`No YouTube results found for "${query}"`);
+    }
+
+    // Return first video
+    return {
+        videoId: videoIds[0],
+        title: query,
+        duration: durationMs ? durationMs / 1000 : 0,
+        url: `https://www.youtube.com/watch?v=${videoIds[0]}`,
+    };
+}
+
+/**
+ * Parse duration string "M:SS" or "H:MM:SS" to seconds
+ */
+function parseDuration(str) {
+    if (!str) return 0;
+    const parts = str.split(':').map(Number);
+    if (parts.length === 3) return parts[0] * 3600 + parts[1] * 60 + parts[2];
+    if (parts.length === 2) return parts[0] * 60 + parts[1];
+    return 0;
+}

package/src/tui/input.js

@@ -0,0 +1,247 @@
+import readline from 'readline';
+
+// ─── Key Input Handler ───────────────────────────────────
+// Creates a raw-mode key listener that dispatches to callbacks
+export function createInputHandler() {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: true,
+    });
+
+    // Enable raw mode for keypress detection
+    if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+    }
+    readline.emitKeypressEvents(process.stdin, rl);
+
+    const handlers = {};
+    let textBuffer = '';
+    let textMode = false;
+    let textCallback = null;
+    let textRenderCallback = null;
+
+    process.stdin.on('keypress', (str, key) => {
+        if (!key) return;
+
+        // Ctrl+C always exits
+        if (key.ctrl && key.name === 'c') {
+            cleanup();
+            process.exit(0);
+        }
+
+        // Text input mode
+        if (textMode) {
+            if (key.name === 'return') {
+                textMode = false;
+                if (textCallback) textCallback(textBuffer);
+                return;
+            }
+            if (key.name === 'escape') {
+                textMode = false;
+                textBuffer = '';
+                if (handlers['escape']) handlers['escape']();
+                return;
+            }
+            if (key.name === 'backspace') {
+                textBuffer = textBuffer.slice(0, -1);
+                if (textRenderCallback) textRenderCallback(textBuffer);
+                return;
+            }
+            if (str && !key.ctrl && !key.meta) {
+                textBuffer += str;
+                if (textRenderCallback) textRenderCallback(textBuffer);
+                return;
+            }
+            return;
+        }
+
+        // Navigation mode
+        const keyName = key.name;
+        if (handlers[keyName]) {
+            handlers[keyName](key);
+        }
+        if (key.name === 'space' && handlers['space']) {
+            handlers['space'](key);
+        }
+        if (str === 'a' && handlers['a']) handlers['a'](key);
+        if (str === 'A' && handlers['A']) handlers['A'](key);
+        if (str === 'q' && handlers['q']) handlers['q'](key);
+        if (str === 'Q' && handlers['Q']) handlers['Q'](key);
+    });
+
+    function cleanup() {
+        if (process.stdin.isTTY) {
+            process.stdin.setRawMode(false);
+        }
+        rl.close();
+    }
+
+    return {
+        // Register a key handler
+        on(keyName, callback) {
+            handlers[keyName] = callback;
+            return this;
+        },
+
+        // Remove a key handler
+        off(keyName) {
+            delete handlers[keyName];
+            return this;
+        },
+
+        // Clear all handlers
+        clearHandlers() {
+            for (const key of Object.keys(handlers)) {
+                delete handlers[key];
+            }
+            return this;
+        },
+
+        // Enter text input mode
+        startTextInput(initialValue = '', onChange, onSubmit) {
+            textBuffer = initialValue;
+            textMode = true;
+            textCallback = onSubmit;
+            textRenderCallback = onChange;
+        },
+
+        // Exit text input mode
+        stopTextInput() {
+            textMode = false;
+            textBuffer = '';
+            textCallback = null;
+            textRenderCallback = null;
+        },
+
+        // Get current text buffer
+        getTextBuffer() {
+            return textBuffer;
+        },
+
+        // Cleanup
+        destroy() {
+            cleanup();
+        },
+    };
+}
+
+// ─── Simple Menu Selector ────────────────────────────────
+// Returns a promise that resolves with the selected index
+export function menuSelect(items, input, renderFn) {
+    return new Promise((resolve) => {
+        let selectedIdx = 0;
+
+        function draw() {
+            renderFn(items, selectedIdx);
+        }
+
+        input.clearHandlers();
+
+        input.on('up', () => {
+            selectedIdx = (selectedIdx - 1 + items.length) % items.length;
+            draw();
+        });
+
+        input.on('down', () => {
+            selectedIdx = (selectedIdx + 1) % items.length;
+            draw();
+        });
+
+        input.on('return', () => {
+            input.clearHandlers();
+            resolve(selectedIdx);
+        });
+
+        input.on('escape', () => {
+            input.clearHandlers();
+            resolve(-1);
+        });
+
+        draw();
+    });
+}
+
+// ─── Checkbox Selector ───────────────────────────────────
+// Returns a promise that resolves with a Set of selected indices
+export function checkboxSelect(items, input, renderFn) {
+    return new Promise((resolve) => {
+        let selectedIdx = 0;
+        const checked = new Set();
+
+        // Start with all checked
+        items.forEach((_, i) => checked.add(i));
+
+        function draw() {
+            renderFn(items, selectedIdx, checked);
+        }
+
+        input.clearHandlers();
+
+        input.on('up', () => {
+            selectedIdx = (selectedIdx - 1 + items.length) % items.length;
+            draw();
+        });
+
+        input.on('down', () => {
+            selectedIdx = (selectedIdx + 1) % items.length;
+            draw();
+        });
+
+        input.on('space', () => {
+            if (checked.has(selectedIdx)) {
+                checked.delete(selectedIdx);
+            } else {
+                checked.add(selectedIdx);
+            }
+            draw();
+        });
+
+        input.on('a', () => {
+            if (checked.size === items.length) {
+                checked.clear();
+            } else {
+                items.forEach((_, i) => checked.add(i));
+            }
+            draw();
+        });
+
+        input.on('return', () => {
+            input.clearHandlers();
+            resolve(checked);
+        });
+
+        input.on('escape', () => {
+            input.clearHandlers();
+            resolve(null);
+        });
+
+        draw();
+    });
+}
+
+// ─── Text Input ──────────────────────────────────────────
+// Returns a promise that resolves with the entered text
+export function textInput(input, renderFn, initialValue = '') {
+    return new Promise((resolve) => {
+        input.clearHandlers();
+
+        input.startTextInput(
+            initialValue,
+            (text) => renderFn(text),    // onChange
+            (text) => {                  // onSubmit
+                input.clearHandlers();
+                resolve(text);
+            }
+        );
+
+        input.on('escape', () => {
+            input.stopTextInput();
+            input.clearHandlers();
+            resolve(null);
+        });
+
+        // Initial render
+        renderFn(initialValue);
+    });
+}

package/src/tui/renderer.js

@@ -0,0 +1,208 @@
+import { COLORS, BOX, SYMBOLS } from '../constants.js';
+
+// ─── Cursor Control ──────────────────────────────────────
+export const cursor = {
+    hide: () => process.stdout.write('\x1b[?25l'),
+    show: () => process.stdout.write('\x1b[?25h'),
+    moveTo: (row, col) => process.stdout.write(`\x1b[${row};${col}H`),
+    moveUp: (n = 1) => process.stdout.write(`\x1b[${n}A`),
+    moveDown: (n = 1) => process.stdout.write(`\x1b[${n}B`),
+    saveCursor: () => process.stdout.write('\x1b[s'),
+    restoreCursor: () => process.stdout.write('\x1b[u'),
+};
+
+// ─── Screen Control ──────────────────────────────────────
+export const screen = {
+    clear: () => process.stdout.write('\x1b[2J\x1b[H'),
+    clearLine: () => process.stdout.write('\x1b[2K'),
+    clearDown: () => process.stdout.write('\x1b[J'),
+    getSize: () => ({
+        width: process.stdout.columns || 80,
+        height: process.stdout.rows || 24,
+    }),
+};
+
+// ─── Color Helpers ───────────────────────────────────────
+export const c = {
+    reset: (str) => `${COLORS.reset}${str}${COLORS.reset}`,
+    bold: (str) => `${COLORS.bold}${str}${COLORS.reset}`,
+    dim: (str) => `${COLORS.dim}${str}${COLORS.reset}`,
+    italic: (str) => `${COLORS.italic}${str}${COLORS.reset}`,
+
+    red: (str) => `${COLORS.red}${str}${COLORS.reset}`,
+    green: (str) => `${COLORS.green}${str}${COLORS.reset}`,
+    yellow: (str) => `${COLORS.yellow}${str}${COLORS.reset}`,
+    blue: (str) => `${COLORS.blue}${str}${COLORS.reset}`,
+    magenta: (str) => `${COLORS.magenta}${str}${COLORS.reset}`,
+    cyan: (str) => `${COLORS.cyan}${str}${COLORS.reset}`,
+    white: (str) => `${COLORS.white}${str}${COLORS.reset}`,
+
+    brightGreen: (str) => `${COLORS.brightGreen}${str}${COLORS.reset}`,
+    brightCyan: (str) => `${COLORS.brightCyan}${str}${COLORS.reset}`,
+    brightYellow: (str) => `${COLORS.brightYellow}${str}${COLORS.reset}`,
+    brightMagenta: (str) => `${COLORS.brightMagenta}${str}${COLORS.reset}`,
+    brightBlue: (str) => `${COLORS.brightBlue}${str}${COLORS.reset}`,
+    brightWhite: (str) => `${COLORS.brightWhite}${str}${COLORS.reset}`,
+
+    // Gradient-ish effect using bright colors
+    gradient: (str) => `${COLORS.brightCyan}${str}${COLORS.reset}`,
+};
+
+// ─── Box Drawing ─────────────────────────────────────────
+export function drawBox(text, options = {}) {
+    const { width = 45, padding = 1 } = options;
+    const innerWidth = width - 2;
+    const lines = [];
+
+    // Top border
+    lines.push(c.cyan(`${BOX.topLeft}${BOX.horizontal.repeat(innerWidth)}${BOX.topRight}`));
+
+    // Padding top
+    for (let i = 0; i < padding; i++) {
+        lines.push(c.cyan(`${BOX.vertical}${' '.repeat(innerWidth)}${BOX.vertical}`));
+    }
+
+    // Content lines
+    const textLines = Array.isArray(text) ? text : [text];
+    for (const line of textLines) {
+        const stripped = stripAnsi(line);
+        const padLen = Math.max(0, innerWidth - stripped.length);
+        const leftPad = Math.floor(padLen / 2);
+        const rightPad = padLen - leftPad;
+        lines.push(
+            c.cyan(BOX.vertical) +
+            ' '.repeat(leftPad) + line + ' '.repeat(rightPad) +
+            c.cyan(BOX.vertical)
+        );
+    }
+
+    // Padding bottom
+    for (let i = 0; i < padding; i++) {
+        lines.push(c.cyan(`${BOX.vertical}${' '.repeat(innerWidth)}${BOX.vertical}`));
+    }
+
+    // Bottom border
+    lines.push(c.cyan(`${BOX.bottomLeft}${BOX.horizontal.repeat(innerWidth)}${BOX.bottomRight}`));
+
+    return lines.join('\n');
+}
+
+// ─── Progress Bar ────────────────────────────────────────
+export function progressBar(percent, width = 20) {
+    const filled = Math.round((percent / 100) * width);
+    const empty = width - filled;
+    const bar = c.brightGreen('█'.repeat(filled)) + c.dim('░'.repeat(empty));
+    const pct = `${Math.round(percent)}%`.padStart(4);
+    return `[${bar}] ${pct}`;
+}
+
+// ─── Table Drawing ───────────────────────────────────────
+export function drawTable(headers, rows, options = {}) {
+    const { selected = -1, checked = new Set() } = options;
+
+    // Calculate column widths
+    const colWidths = headers.map((h, i) => {
+        const maxRow = rows.reduce((max, row) => Math.max(max, stripAnsi(String(row[i] || '')).length), 0);
+        return Math.max(stripAnsi(h).length, maxRow) + 2;
+    });
+
+    const totalWidth = colWidths.reduce((a, b) => a + b, 0) + headers.length + 1;
+    const lines = [];
+
+    // Top border
+    lines.push(
+        c.dim('┌') +
+        colWidths.map(w => c.dim('─'.repeat(w))).join(c.dim('┬')) +
+        c.dim('┐')
+    );
+
+    // Header
+    const headerLine = colWidths.map((w, i) => {
+        const text = ` ${headers[i]}`;
+        return c.bold(c.cyan(text.padEnd(w)));
+    }).join(c.dim('│'));
+    lines.push(c.dim('│') + headerLine + c.dim('│'));
+
+    // Header separator
+    lines.push(
+        c.dim('├') +
+        colWidths.map(w => c.dim('─'.repeat(w))).join(c.dim('┼')) +
+        c.dim('┤')
+    );
+
+    // Data rows
+    rows.forEach((row, rowIdx) => {
+        const isSelected = rowIdx === selected;
+        const isChecked = checked.has(rowIdx);
+
+        const rowLine = colWidths.map((w, i) => {
+            let text = ` ${String(row[i] || '')}`;
+            if (isSelected) {
+                text = c.brightCyan(text.padEnd(w));
+            } else if (isChecked) {
+                text = c.green(text.padEnd(w));
+            } else {
+                text = text.padEnd(w);
+            }
+            return text;
+        }).join(c.dim('│'));
+
+        const prefix = isSelected ? c.brightCyan('❯') : ' ';
+        const checkMark = isChecked ? c.green('✓') : ' ';
+
+        lines.push(c.dim('│') + rowLine + c.dim('│') + ` ${checkMark}`);
+    });
+
+    // Bottom border
+    lines.push(
+        c.dim('└') +
+        colWidths.map(w => c.dim('─'.repeat(w))).join(c.dim('┴')) +
+        c.dim('┘')
+    );
+
+    return lines.join('\n');
+}
+
+// ─── Render ──────────────────────────────────────────────
+export function render(content) {
+    screen.clear();
+    process.stdout.write(content + '\n');
+}
+
+// ─── Spinner ─────────────────────────────────────────────
+const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+
+export function createSpinner(text) {
+    let frameIdx = 0;
+    let interval = null;
+    let line = 0;
+
+    return {
+        start(row = 0) {
+            line = row;
+            cursor.hide();
+            interval = setInterval(() => {
+                cursor.moveTo(line, 1);
+                screen.clearLine();
+                const frame = c.cyan(SPINNER_FRAMES[frameIdx]);
+                process.stdout.write(`  ${frame} ${text}`);
+                frameIdx = (frameIdx + 1) % SPINNER_FRAMES.length;
+            }, 80);
+        },
+        stop(finalText) {
+            if (interval) clearInterval(interval);
+            cursor.moveTo(line, 1);
+            screen.clearLine();
+            if (finalText) {
+                process.stdout.write(`  ${c.green('✓')} ${finalText}\n`);
+            }
+            cursor.show();
+        },
+    };
+}
+
+// ─── Utility: strip ANSI codes for width calculation ─────
+export function stripAnsi(str) {
+    // eslint-disable-next-line no-control-regex
+    return str.replace(/\x1b\[[0-9;]*m/g, '');
+}

package/src/utils/config.js

@@ -0,0 +1,64 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { CONFIG_DIR, CONFIG_FILE, DEFAULT_DOWNLOAD_DIR } from '../constants.js';
+
+const DEFAULT_CONFIG = {
+    spotifyClientId: '',
+    spotifyClientSecret: '',
+    downloadDir: DEFAULT_DOWNLOAD_DIR,
+    audioQuality: 'best',
+    audioFormat: 'mp3',
+};
+
+/**
+ * Load config from ~/.ssdl/config.json
+ * Creates default config if it doesn't exist
+ */
+export function loadConfig() {
+    try {
+        if (!existsSync(CONFIG_DIR)) {
+            mkdirSync(CONFIG_DIR, { recursive: true });
+        }
+
+        if (!existsSync(CONFIG_FILE)) {
+            saveConfig(DEFAULT_CONFIG);
+            return { ...DEFAULT_CONFIG };
+        }
+
+        const raw = readFileSync(CONFIG_FILE, 'utf-8');
+        const config = JSON.parse(raw);
+        return { ...DEFAULT_CONFIG, ...config };
+    } catch {
+        return { ...DEFAULT_CONFIG };
+    }
+}
+
+/**
+ * Save config to ~/.ssdl/config.json
+ */
+export function saveConfig(config) {
+    try {
+        if (!existsSync(CONFIG_DIR)) {
+            mkdirSync(CONFIG_DIR, { recursive: true });
+        }
+        writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8');
+    } catch (err) {
+        console.error('Failed to save config:', err.message);
+    }
+}
+
+/**
+ * Check if Spotify credentials are configured
+ */
+export function hasCredentials(config) {
+    return !!(config.spotifyClientId && config.spotifyClientSecret);
+}
+
+/**
+ * Update specific config values
+ */
+export function updateConfig(updates) {
+    const config = loadConfig();
+    const updated = { ...config, ...updates };
+    saveConfig(updated);
+    return updated;
+}