@rv404/mcp-launchpad 1.0.0

package/dist/backends/youtube.js

@@ -0,0 +1,936 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+const execAsync = promisify(exec);
+// ============================================================================
+// Configuration
+// ============================================================================
+// YouTube Data API v3 (optional - for metadata)
+const YOUTUBE_API_KEY = process.env.YOUTUBE_API_KEY;
+// Gemini API for video analysis (reuses existing env var)
+const GOOGLE_API_KEY = process.env.GOOGLE_API_KEY;
+const GEMINI_BASE_URL = 'https://generativelanguage.googleapis.com/v1beta';
+// Output directory for downloads - uses env var or user home directory
+const getDefaultDataDir = () => {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || '.';
+    return path.join(homeDir, '.router-mcp', 'data');
+};
+const DATA_DIR = process.env.ROUTER_MCP_DATA_DIR || process.env.MCP_FILE_OUTPUT_DIR || getDefaultDataDir();
+const YOUTUBE_DIR = path.join(DATA_DIR, 'youtube');
+const DOWNLOADS_DIR = path.join(YOUTUBE_DIR, 'downloads');
+const TRANSCRIPTS_DIR = path.join(YOUTUBE_DIR, 'transcripts');
+const ANALYSES_DIR = path.join(YOUTUBE_DIR, 'analyses');
+// Ensure directories exist
+function ensureDirectories() {
+    for (const dir of [YOUTUBE_DIR, DOWNLOADS_DIR, TRANSCRIPTS_DIR, ANALYSES_DIR]) {
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    }
+}
+// ============================================================================
+// Action Definitions
+// ============================================================================
+const actions = [
+    // Metadata
+    {
+        name: 'get_metadata',
+        description: 'Get video metadata: title, channel, duration, description, view count, publish date, thumbnails.',
+        params: [
+            { name: 'url', type: 'string', required: true, description: 'YouTube video URL or video ID' },
+        ],
+    },
+    // Transcript
+    {
+        name: 'get_transcript',
+        description: 'Get video transcript/captions with timestamps. Supports multiple languages.',
+        params: [
+            { name: 'url', type: 'string', required: true, description: 'YouTube video URL or video ID' },
+            { name: 'language', type: 'string', required: false, description: 'Language code (e.g., "en", "es", "auto"). Default: "en"' },
+            { name: 'format', type: 'string', required: false, description: 'Output format: "text" (plain text), "timestamped" (with timestamps), "srt" (SubRip format). Default: "timestamped"' },
+        ],
+    },
+    // Chapters
+    {
+        name: 'get_chapters',
+        description: 'Get video chapters if available (from description timestamps).',
+        params: [
+            { name: 'url', type: 'string', required: true, description: 'YouTube video URL or video ID' },
+        ],
+    },
+    // Downloads
+    {
+        name: 'download_audio',
+        description: 'Download audio from a YouTube video (MP3 format). Requires yt-dlp installed.',
+        params: [
+            { name: 'url', type: 'string', required: true, description: 'YouTube video URL or video ID' },
+            { name: 'outputPath', type: 'string', required: false, description: 'Custom output path. Default: auto-generated in youtube/downloads/' },
+        ],
+    },
+    {
+        name: 'download_video',
+        description: 'Download video from YouTube. Requires yt-dlp installed.',
+        params: [
+            { name: 'url', type: 'string', required: true, description: 'YouTube video URL or video ID' },
+            { name: 'quality', type: 'string', required: false, description: 'Video quality: "best", "1080p", "720p", "480p", "worst". Default: "720p"' },
+            { name: 'outputPath', type: 'string', required: false, description: 'Custom output path. Default: auto-generated in youtube/downloads/' },
+        ],
+    },
+    // Analysis
+    {
+        name: 'summarize',
+        description: 'Get a concise summary of the video based on its transcript.',
+        params: [
+            { name: 'url', type: 'string', required: true, description: 'YouTube video URL or video ID' },
+            { name: 'style', type: 'string', required: false, description: 'Summary style: "brief" (1-2 paragraphs), "detailed" (section by section), "bullets" (key points). Default: "brief"' },
+        ],
+    },
+    {
+        name: 'analyze',
+        description: 'Full hybrid analysis: transcript analysis + optional Gemini visual analysis for comprehensive understanding.',
+        params: [
+            { name: 'url', type: 'string', required: true, description: 'YouTube video URL or video ID' },
+            { name: 'mode', type: 'string', required: false, description: 'Analysis mode: "transcript" (fast, text-only), "visual" (Gemini video analysis), "full" (both combined). Default: "transcript"' },
+            { name: 'questions', type: 'array', required: false, description: 'Specific questions to answer about the video content' },
+            { name: 'extractCode', type: 'boolean', required: false, description: 'Extract code snippets from programming videos. Default: false' },
+            { name: 'outputPath', type: 'string', required: false, description: 'Save analysis to file. Default: returns in response' },
+        ],
+    },
+    {
+        name: 'extract_code',
+        description: 'Extract code snippets mentioned or shown in programming tutorial videos.',
+        params: [
+            { name: 'url', type: 'string', required: true, description: 'YouTube video URL or video ID' },
+            { name: 'language', type: 'string', required: false, description: 'Programming language to focus on (e.g., "python", "javascript"). Default: auto-detect' },
+        ],
+    },
+];
+// ============================================================================
+// Utility Functions
+// ============================================================================
+function extractVideoId(urlOrId) {
+    // Already a video ID (11 characters)
+    if (/^[a-zA-Z0-9_-]{11}$/.test(urlOrId)) {
+        return urlOrId;
+    }
+    // Various YouTube URL formats
+    const patterns = [
+        /(?:youtube\.com\/watch\?v=|youtu\.be\/|youtube\.com\/embed\/|youtube\.com\/v\/)([a-zA-Z0-9_-]{11})/,
+        /youtube\.com\/shorts\/([a-zA-Z0-9_-]{11})/,
+    ];
+    for (const pattern of patterns) {
+        const match = urlOrId.match(pattern);
+        if (match) {
+            return match[1];
+        }
+    }
+    throw new Error(`Invalid YouTube URL or video ID: ${urlOrId}`);
+}
+function formatDuration(seconds) {
+    const hours = Math.floor(seconds / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    const secs = Math.floor(seconds % 60);
+    if (hours > 0) {
+        return `${hours}:${minutes.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')}`;
+    }
+    return `${minutes}:${secs.toString().padStart(2, '0')}`;
+}
+function formatTimestamp(seconds) {
+    const hours = Math.floor(seconds / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    const secs = Math.floor(seconds % 60);
+    const ms = Math.floor((seconds % 1) * 1000);
+    if (hours > 0) {
+        return `${hours.toString().padStart(2, '0')}:${minutes.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')},${ms.toString().padStart(3, '0')}`;
+    }
+    return `00:${minutes.toString().padStart(2, '0')}:${secs.toString().padStart(2, '0')},${ms.toString().padStart(3, '0')}`;
+}
+// yt-dlp executable - should be installed and available on PATH
+// Install with: pip install yt-dlp
+const YT_DLP_PATHS = [
+    'yt-dlp', // Standard: on PATH (recommended)
+    'yt-dlp.exe', // Windows: on PATH
+];
+let ytDlpPath = null;
+async function checkYtDlp() {
+    // Return cached path if already found
+    if (ytDlpPath)
+        return true;
+    for (const ytdlp of YT_DLP_PATHS) {
+        try {
+            await execAsync(`"${ytdlp}" --version`);
+            ytDlpPath = ytdlp;
+            return true;
+        }
+        catch {
+            continue;
+        }
+    }
+    return false;
+}
+function getYtDlpCommand() {
+    return ytDlpPath ? `"${ytDlpPath}"` : 'yt-dlp';
+}
+// ============================================================================
+// Get Metadata (using yt-dlp for reliability)
+// ============================================================================
+async function getMetadata(params) {
+    const { url } = params;
+    if (!url || typeof url !== 'string') {
+        throw new Error('url is required');
+    }
+    const videoId = extractVideoId(url);
+    // Try YouTube Data API first if available
+    if (YOUTUBE_API_KEY) {
+        try {
+            const apiUrl = `https://www.googleapis.com/youtube/v3/videos?part=snippet,contentDetails,statistics&id=${videoId}&key=${YOUTUBE_API_KEY}`;
+            const response = await fetch(apiUrl);
+            if (response.ok) {
+                const data = await response.json();
+                if (data.items && data.items.length > 0) {
+                    const item = data.items[0];
+                    const snippet = item.snippet || {};
+                    const contentDetails = item.contentDetails || {};
+                    const statistics = item.statistics || {};
+                    // Parse ISO 8601 duration
+                    let durationSeconds = 0;
+                    const durationMatch = contentDetails.duration?.match(/PT(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?/);
+                    if (durationMatch) {
+                        durationSeconds = (parseInt(durationMatch[1] || '0') * 3600) +
+                            (parseInt(durationMatch[2] || '0') * 60) +
+                            parseInt(durationMatch[3] || '0');
+                    }
+                    return {
+                        success: true,
+                        videoId,
+                        title: snippet.title,
+                        channel: snippet.channelTitle,
+                        description: snippet.description,
+                        publishedAt: snippet.publishedAt,
+                        duration: formatDuration(durationSeconds),
+                        durationSeconds,
+                        viewCount: statistics.viewCount ? parseInt(statistics.viewCount) : null,
+                        likeCount: statistics.likeCount ? parseInt(statistics.likeCount) : null,
+                        commentCount: statistics.commentCount ? parseInt(statistics.commentCount) : null,
+                        tags: snippet.tags || [],
+                        thumbnails: snippet.thumbnails,
+                        url: `https://www.youtube.com/watch?v=${videoId}`,
+                    };
+                }
+            }
+        }
+        catch {
+            // Fall through to yt-dlp
+        }
+    }
+    // Fallback to yt-dlp
+    if (!(await checkYtDlp())) {
+        throw new Error('yt-dlp is not installed. Install it with: pip install yt-dlp');
+    }
+    try {
+        const { stdout } = await execAsync(`${getYtDlpCommand()} --dump-json --no-download "https://www.youtube.com/watch?v=${videoId}"`, { maxBuffer: 10 * 1024 * 1024 });
+        const info = JSON.parse(stdout);
+        return {
+            success: true,
+            videoId,
+            title: info.title,
+            channel: info.channel || info.uploader,
+            description: info.description,
+            publishedAt: info.upload_date ? `${info.upload_date.slice(0, 4)}-${info.upload_date.slice(4, 6)}-${info.upload_date.slice(6, 8)}` : null,
+            duration: info.duration ? formatDuration(info.duration) : null,
+            durationSeconds: info.duration,
+            viewCount: info.view_count,
+            likeCount: info.like_count,
+            commentCount: info.comment_count,
+            tags: info.tags || [],
+            thumbnail: info.thumbnail,
+            hasChapters: !!(info.chapters && info.chapters.length > 0),
+            chapterCount: info.chapters?.length || 0,
+            url: `https://www.youtube.com/watch?v=${videoId}`,
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to get metadata: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+// ============================================================================
+// Get Transcript
+// ============================================================================
+async function getTranscript(params) {
+    const { url, language = 'en', format = 'timestamped' } = params;
+    if (!url || typeof url !== 'string') {
+        throw new Error('url is required');
+    }
+    const videoId = extractVideoId(url);
+    if (!(await checkYtDlp())) {
+        throw new Error('yt-dlp is not installed. Install it with: pip install yt-dlp');
+    }
+    ensureDirectories();
+    // Download subtitles using yt-dlp
+    const tempDir = path.join(TRANSCRIPTS_DIR, `temp_${videoId}_${Date.now()}`);
+    fs.mkdirSync(tempDir, { recursive: true });
+    try {
+        // Try to get subtitles (auto-generated or manual)
+        const langArg = language === 'auto' ? '--sub-langs "en.*,.*"' : `--sub-langs "${language}.*,en.*"`;
+        await execAsync(`${getYtDlpCommand()} --write-auto-sub --write-sub ${langArg} --sub-format json3 --skip-download -o "${path.join(tempDir, '%(id)s')}" "https://www.youtube.com/watch?v=${videoId}"`, { maxBuffer: 10 * 1024 * 1024 });
+        // Find the downloaded subtitle file
+        const files = fs.readdirSync(tempDir);
+        const subFile = files.find(f => f.endsWith('.json3'));
+        if (!subFile) {
+            // Try VTT format as fallback
+            await execAsync(`${getYtDlpCommand()} --write-auto-sub --write-sub ${langArg} --sub-format vtt --skip-download -o "${path.join(tempDir, '%(id)s')}" "https://www.youtube.com/watch?v=${videoId}"`, { maxBuffer: 10 * 1024 * 1024 });
+            const vttFiles = fs.readdirSync(tempDir);
+            const vttFile = vttFiles.find(f => f.endsWith('.vtt'));
+            if (!vttFile) {
+                throw new Error('No captions available for this video');
+            }
+            // Parse VTT file
+            const vttContent = fs.readFileSync(path.join(tempDir, vttFile), 'utf-8');
+            const segments = parseVTT(vttContent);
+            return formatTranscriptOutput(videoId, segments, format);
+        }
+        // Parse JSON3 format
+        const json3Content = fs.readFileSync(path.join(tempDir, subFile), 'utf-8');
+        const json3Data = JSON.parse(json3Content);
+        const segments = [];
+        if (json3Data.events) {
+            for (const event of json3Data.events) {
+                if (event.segs && event.tStartMs !== undefined) {
+                    const text = event.segs.map(s => s.utf8 || '').join('').trim();
+                    if (text && !text.startsWith('[')) { // Skip [Music] etc
+                        segments.push({
+                            start: event.tStartMs / 1000,
+                            duration: (event.dDurationMs || 0) / 1000,
+                            text,
+                        });
+                    }
+                }
+            }
+        }
+        return formatTranscriptOutput(videoId, segments, format);
+    }
+    finally {
+        // Cleanup temp directory
+        try {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+}
+function parseVTT(content) {
+    const segments = [];
+    const lines = content.split('\n');
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i].trim();
+        // Look for timestamp line (00:00:00.000 --> 00:00:00.000)
+        const timestampMatch = line.match(/(\d{2}:\d{2}:\d{2}\.\d{3})\s*-->\s*(\d{2}:\d{2}:\d{2}\.\d{3})/);
+        if (timestampMatch) {
+            const startTime = parseVTTTimestamp(timestampMatch[1]);
+            const endTime = parseVTTTimestamp(timestampMatch[2]);
+            // Collect text lines until empty line
+            const textLines = [];
+            i++;
+            while (i < lines.length && lines[i].trim() !== '') {
+                // Remove VTT tags like <c> </c>
+                const cleanedLine = lines[i].replace(/<[^>]+>/g, '').trim();
+                if (cleanedLine && !cleanedLine.startsWith('[')) {
+                    textLines.push(cleanedLine);
+                }
+                i++;
+            }
+            if (textLines.length > 0) {
+                segments.push({
+                    start: startTime,
+                    duration: endTime - startTime,
+                    text: textLines.join(' '),
+                });
+            }
+        }
+        i++;
+    }
+    return segments;
+}
+function parseVTTTimestamp(timestamp) {
+    const parts = timestamp.split(':');
+    const hours = parseInt(parts[0]);
+    const minutes = parseInt(parts[1]);
+    const secondsParts = parts[2].split('.');
+    const seconds = parseInt(secondsParts[0]);
+    const ms = parseInt(secondsParts[1] || '0');
+    return hours * 3600 + minutes * 60 + seconds + ms / 1000;
+}
+function formatTranscriptOutput(videoId, segments, format) {
+    // Deduplicate consecutive similar segments
+    const deduped = [];
+    for (const seg of segments) {
+        if (deduped.length === 0 || deduped[deduped.length - 1].text !== seg.text) {
+            deduped.push(seg);
+        }
+    }
+    if (format === 'text') {
+        return {
+            success: true,
+            videoId,
+            format: 'text',
+            text: deduped.map(s => s.text).join(' '),
+            segmentCount: deduped.length,
+        };
+    }
+    if (format === 'srt') {
+        const srtLines = [];
+        deduped.forEach((seg, idx) => {
+            srtLines.push(String(idx + 1));
+            srtLines.push(`${formatTimestamp(seg.start)} --> ${formatTimestamp(seg.start + seg.duration)}`);
+            srtLines.push(seg.text);
+            srtLines.push('');
+        });
+        return {
+            success: true,
+            videoId,
+            format: 'srt',
+            srt: srtLines.join('\n'),
+            segmentCount: deduped.length,
+        };
+    }
+    // Default: timestamped
+    return {
+        success: true,
+        videoId,
+        format: 'timestamped',
+        segments: deduped.map(s => ({
+            timestamp: formatDuration(s.start),
+            startSeconds: s.start,
+            text: s.text,
+        })),
+        segmentCount: deduped.length,
+        totalDuration: deduped.length > 0
+            ? formatDuration(deduped[deduped.length - 1].start + deduped[deduped.length - 1].duration)
+            : '0:00',
+    };
+}
+// ============================================================================
+// Get Chapters
+// ============================================================================
+async function getChapters(params) {
+    const { url } = params;
+    if (!url || typeof url !== 'string') {
+        throw new Error('url is required');
+    }
+    const videoId = extractVideoId(url);
+    if (!(await checkYtDlp())) {
+        throw new Error('yt-dlp is not installed. Install it with: pip install yt-dlp');
+    }
+    try {
+        const { stdout } = await execAsync(`${getYtDlpCommand()} --dump-json --no-download "https://www.youtube.com/watch?v=${videoId}"`, { maxBuffer: 10 * 1024 * 1024 });
+        const info = JSON.parse(stdout);
+        if (!info.chapters || info.chapters.length === 0) {
+            return {
+                success: true,
+                videoId,
+                hasChapters: false,
+                chapters: [],
+                message: 'This video does not have chapters',
+            };
+        }
+        return {
+            success: true,
+            videoId,
+            title: info.title,
+            hasChapters: true,
+            chapterCount: info.chapters.length,
+            chapters: info.chapters.map((ch, idx) => ({
+                index: idx + 1,
+                title: ch.title,
+                startTime: formatDuration(ch.start_time),
+                startSeconds: ch.start_time,
+                endTime: formatDuration(ch.end_time),
+                endSeconds: ch.end_time,
+                duration: formatDuration(ch.end_time - ch.start_time),
+            })),
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to get chapters: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+// ============================================================================
+// Download Audio
+// ============================================================================
+async function downloadAudio(params) {
+    const { url, outputPath } = params;
+    if (!url || typeof url !== 'string') {
+        throw new Error('url is required');
+    }
+    const videoId = extractVideoId(url);
+    if (!(await checkYtDlp())) {
+        throw new Error('yt-dlp is not installed. Install it with: pip install yt-dlp');
+    }
+    ensureDirectories();
+    // Determine output path
+    let finalPath;
+    if (outputPath && typeof outputPath === 'string') {
+        finalPath = outputPath;
+    }
+    else {
+        // Get video title for filename
+        try {
+            const { stdout } = await execAsync(`${getYtDlpCommand()} --get-title "https://www.youtube.com/watch?v=${videoId}"`, { maxBuffer: 1024 * 1024 });
+            const title = stdout.trim().replace(/[<>:"/\\|?*]/g, '_').slice(0, 100);
+            finalPath = path.join(DOWNLOADS_DIR, `${title}_${videoId}.mp3`);
+        }
+        catch {
+            finalPath = path.join(DOWNLOADS_DIR, `${videoId}.mp3`);
+        }
+    }
+    // Ensure output directory exists
+    const dir = path.dirname(finalPath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    try {
+        await execAsync(`${getYtDlpCommand()} -x --audio-format mp3 --audio-quality 0 -o "${finalPath.replace('.mp3', '')}.%(ext)s" "https://www.youtube.com/watch?v=${videoId}"`, { maxBuffer: 10 * 1024 * 1024 });
+        // Check if file exists
+        if (!fs.existsSync(finalPath)) {
+            // Try with the exact output name
+            const altPath = finalPath.replace('.mp3', '.mp3');
+            if (fs.existsSync(altPath)) {
+                return {
+                    success: true,
+                    videoId,
+                    format: 'mp3',
+                    path: altPath,
+                    size: fs.statSync(altPath).size,
+                };
+            }
+            // Look for any mp3 file in the directory with the video ID
+            const files = fs.readdirSync(dir);
+            const mp3File = files.find(f => f.includes(videoId) && f.endsWith('.mp3'));
+            if (mp3File) {
+                const foundPath = path.join(dir, mp3File);
+                return {
+                    success: true,
+                    videoId,
+                    format: 'mp3',
+                    path: foundPath,
+                    size: fs.statSync(foundPath).size,
+                };
+            }
+        }
+        const stats = fs.statSync(finalPath);
+        return {
+            success: true,
+            videoId,
+            format: 'mp3',
+            path: finalPath,
+            size: stats.size,
+            sizeFormatted: `${(stats.size / (1024 * 1024)).toFixed(2)} MB`,
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to download audio: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+// ============================================================================
+// Download Video
+// ============================================================================
+async function downloadVideo(params) {
+    const { url, quality = '720p', outputPath } = params;
+    if (!url || typeof url !== 'string') {
+        throw new Error('url is required');
+    }
+    const videoId = extractVideoId(url);
+    if (!(await checkYtDlp())) {
+        throw new Error('yt-dlp is not installed. Install it with: pip install yt-dlp');
+    }
+    ensureDirectories();
+    // Quality mapping
+    const qualityMap = {
+        'best': 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best',
+        '1080p': 'bestvideo[height<=1080][ext=mp4]+bestaudio[ext=m4a]/best[height<=1080][ext=mp4]',
+        '720p': 'bestvideo[height<=720][ext=mp4]+bestaudio[ext=m4a]/best[height<=720][ext=mp4]',
+        '480p': 'bestvideo[height<=480][ext=mp4]+bestaudio[ext=m4a]/best[height<=480][ext=mp4]',
+        'worst': 'worstvideo[ext=mp4]+worstaudio[ext=m4a]/worst[ext=mp4]/worst',
+    };
+    const formatStr = qualityMap[quality] || qualityMap['720p'];
+    // Determine output path
+    let finalPath;
+    if (outputPath && typeof outputPath === 'string') {
+        finalPath = outputPath;
+    }
+    else {
+        try {
+            const { stdout } = await execAsync(`${getYtDlpCommand()} --get-title "https://www.youtube.com/watch?v=${videoId}"`, { maxBuffer: 1024 * 1024 });
+            const title = stdout.trim().replace(/[<>:"/\\|?*]/g, '_').slice(0, 100);
+            finalPath = path.join(DOWNLOADS_DIR, `${title}_${videoId}.mp4`);
+        }
+        catch {
+            finalPath = path.join(DOWNLOADS_DIR, `${videoId}.mp4`);
+        }
+    }
+    // Ensure output directory exists
+    const dir = path.dirname(finalPath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    try {
+        await execAsync(`${getYtDlpCommand()} -f "${formatStr}" --merge-output-format mp4 -o "${finalPath}" "https://www.youtube.com/watch?v=${videoId}"`, { maxBuffer: 50 * 1024 * 1024, timeout: 300000 });
+        // Verify file exists
+        if (!fs.existsSync(finalPath)) {
+            // Look for any mp4 with the video ID
+            const files = fs.readdirSync(dir);
+            const mp4File = files.find(f => f.includes(videoId) && f.endsWith('.mp4'));
+            if (mp4File) {
+                finalPath = path.join(dir, mp4File);
+            }
+            else {
+                throw new Error('Download completed but file not found');
+            }
+        }
+        const stats = fs.statSync(finalPath);
+        return {
+            success: true,
+            videoId,
+            format: 'mp4',
+            quality,
+            path: finalPath,
+            size: stats.size,
+            sizeFormatted: `${(stats.size / (1024 * 1024)).toFixed(2)} MB`,
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to download video: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+// ============================================================================
+// Summarize
+// ============================================================================
+async function summarize(params) {
+    const { url, style = 'brief' } = params;
+    if (!url || typeof url !== 'string') {
+        throw new Error('url is required');
+    }
+    if (!GOOGLE_API_KEY) {
+        throw new Error('GOOGLE_API_KEY environment variable is not set (needed for summarization)');
+    }
+    const videoId = extractVideoId(url);
+    // Get transcript
+    const transcriptResult = await getTranscript({ url, format: 'text' });
+    if (!transcriptResult.success || !transcriptResult.text) {
+        throw new Error('Failed to get transcript for summarization');
+    }
+    // Get metadata for context
+    const metadataResult = await getMetadata({ url });
+    const title = metadataResult.title || 'Unknown';
+    const channel = metadataResult.channel || 'Unknown';
+    // Build prompt based on style
+    let promptStyle = '';
+    switch (style) {
+        case 'detailed':
+            promptStyle = 'Provide a detailed summary broken into sections covering the main topics discussed. Include key points under each section.';
+            break;
+        case 'bullets':
+            promptStyle = 'Provide a summary as a bulleted list of the key points and takeaways.';
+            break;
+        default: // brief
+            promptStyle = 'Provide a concise 2-3 paragraph summary of the main content and key takeaways.';
+    }
+    const prompt = `You are analyzing a YouTube video transcript.
+
+Video: "${title}" by ${channel}
+
+${promptStyle}
+
+Transcript:
+${transcriptResult.text.slice(0, 30000)}${transcriptResult.text.length > 30000 ? '\n\n[Transcript truncated...]' : ''}`;
+    // Call Gemini
+    const endpoint = `${GEMINI_BASE_URL}/models/gemini-2.0-flash:generateContent?key=${GOOGLE_API_KEY}`;
+    const response = await fetch(endpoint, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            contents: [{ parts: [{ text: prompt }] }],
+        }),
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Gemini API error: ${errorText}`);
+    }
+    const data = await response.json();
+    const summary = data.candidates?.[0]?.content?.parts?.[0]?.text || '';
+    return {
+        success: true,
+        videoId,
+        title,
+        channel,
+        style,
+        summary: summary.trim(),
+    };
+}
+// ============================================================================
+// Full Analysis (Hybrid)
+// ============================================================================
+async function analyze(params) {
+    const { url, mode = 'transcript', questions, extractCode = false, outputPath } = params;
+    if (!url || typeof url !== 'string') {
+        throw new Error('url is required');
+    }
+    if (!GOOGLE_API_KEY) {
+        throw new Error('GOOGLE_API_KEY environment variable is not set');
+    }
+    const videoId = extractVideoId(url);
+    ensureDirectories();
+    const result = {
+        success: true,
+        videoId,
+        mode,
+        url: `https://www.youtube.com/watch?v=${videoId}`,
+    };
+    // Get metadata
+    const metadata = await getMetadata({ url });
+    result.metadata = {
+        title: metadata.title,
+        channel: metadata.channel,
+        duration: metadata.duration,
+        publishedAt: metadata.publishedAt,
+    };
+    // Get chapters if available
+    const chapters = await getChapters({ url });
+    if (chapters.hasChapters) {
+        result.chapters = chapters.chapters;
+    }
+    // Get transcript
+    let transcriptText = '';
+    try {
+        const transcript = await getTranscript({ url, format: 'text' });
+        transcriptText = transcript.text || '';
+        result.transcriptLength = transcriptText.length;
+    }
+    catch (error) {
+        result.transcriptError = error instanceof Error ? error.message : String(error);
+    }
+    // Transcript-based analysis
+    if ((mode === 'transcript' || mode === 'full') && transcriptText) {
+        const questionsText = Array.isArray(questions) && questions.length > 0
+            ? `\n\nSpecific questions to answer:\n${questions.map((q, i) => `${i + 1}. ${q}`).join('\n')}`
+            : '';
+        const codeExtractionText = extractCode
+            ? '\n\nAlso identify and extract any code snippets, commands, or technical configurations mentioned.'
+            : '';
+        const analysisPrompt = `Analyze this YouTube video transcript comprehensively.
+
+Video: "${metadata.title}" by ${metadata.channel}
+Duration: ${metadata.duration}
+
+Provide:
+1. A detailed summary of the content
+2. Key points and takeaways
+3. Main topics/themes discussed
+4. Any tools, technologies, or resources mentioned
+5. Target audience and skill level${questionsText}${codeExtractionText}
+
+Transcript:
+${transcriptText.slice(0, 40000)}${transcriptText.length > 40000 ? '\n\n[Transcript truncated...]' : ''}`;
+        const response = await fetch(`${GEMINI_BASE_URL}/models/gemini-2.0-flash:generateContent?key=${GOOGLE_API_KEY}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                contents: [{ parts: [{ text: analysisPrompt }] }],
+            }),
+        });
+        if (response.ok) {
+            const data = await response.json();
+            result.transcriptAnalysis = data.candidates?.[0]?.content?.parts?.[0]?.text?.trim();
+        }
+    }
+    // Visual analysis with Gemini (if mode is visual or full)
+    if (mode === 'visual' || mode === 'full') {
+        // Download video for visual analysis
+        try {
+            const downloadResult = await downloadVideo({ url, quality: '480p' });
+            if (downloadResult.path && fs.existsSync(downloadResult.path)) {
+                // Upload video to Gemini Files API
+                const videoContent = fs.readFileSync(downloadResult.path);
+                const uploadResponse = await fetch(`https://generativelanguage.googleapis.com/upload/v1beta/files?key=${GOOGLE_API_KEY}`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'video/mp4',
+                        'X-Goog-Upload-Protocol': 'raw',
+                        'X-Goog-Upload-Command': 'upload, finalize',
+                    },
+                    body: videoContent,
+                });
+                if (uploadResponse.ok) {
+                    const uploadData = await uploadResponse.json();
+                    const fileUri = uploadData.file?.uri;
+                    if (fileUri) {
+                        // Wait for processing
+                        await new Promise(resolve => setTimeout(resolve, 5000));
+                        // Analyze with Gemini
+                        const visualPrompt = `Analyze this video comprehensively. Focus on:
+1. Visual demonstrations and what's being shown on screen
+2. Any text, code, diagrams, or UI elements visible
+3. Key visual moments and their significance
+4. Production quality and presentation style
+
+${Array.isArray(questions) && questions.length > 0 ? `\nAnswer these specific questions:\n${questions.map((q, i) => `${i + 1}. ${q}`).join('\n')}` : ''}`;
+                        const visualResponse = await fetch(`${GEMINI_BASE_URL}/models/gemini-2.0-flash:generateContent?key=${GOOGLE_API_KEY}`, {
+                            method: 'POST',
+                            headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify({
+                                contents: [{
+                                        parts: [
+                                            { fileData: { mimeType: 'video/mp4', fileUri } },
+                                            { text: visualPrompt },
+                                        ],
+                                    }],
+                            }),
+                        });
+                        if (visualResponse.ok) {
+                            const visualData = await visualResponse.json();
+                            result.visualAnalysis = visualData.candidates?.[0]?.content?.parts?.[0]?.text?.trim();
+                        }
+                    }
+                }
+                // Cleanup downloaded video (optional - keep if user might want it)
+                // fs.unlinkSync(downloadResult.path);
+                result.downloadedVideoPath = downloadResult.path;
+            }
+        }
+        catch (error) {
+            result.visualAnalysisError = error instanceof Error ? error.message : String(error);
+        }
+    }
+    // Save to file if requested
+    if (outputPath && typeof outputPath === 'string') {
+        const dir = path.dirname(outputPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(outputPath, JSON.stringify(result, null, 2));
+        result.savedTo = outputPath;
+    }
+    return result;
+}
+// ============================================================================
+// Extract Code
+// ============================================================================
+async function extractCodeFromVideo(params) {
+    const { url, language } = params;
+    if (!url || typeof url !== 'string') {
+        throw new Error('url is required');
+    }
+    if (!GOOGLE_API_KEY) {
+        throw new Error('GOOGLE_API_KEY environment variable is not set');
+    }
+    const videoId = extractVideoId(url);
+    // Get transcript
+    const transcript = await getTranscript({ url, format: 'text' });
+    const transcriptText = transcript.text || '';
+    if (!transcriptText) {
+        throw new Error('No transcript available for code extraction');
+    }
+    const langHint = language && typeof language === 'string'
+        ? `Focus especially on ${language} code.`
+        : 'Detect the programming language automatically.';
+    const prompt = `Extract all code snippets, commands, and technical configurations from this programming video transcript.
+
+${langHint}
+
+For each code snippet found:
+1. Identify what it does
+2. Extract the complete code
+3. Note any dependencies or requirements mentioned
+4. Include the approximate timestamp context if mentioned
+
+Format each code block with proper markdown syntax highlighting.
+
+Transcript:
+${transcriptText.slice(0, 30000)}`;
+    const response = await fetch(`${GEMINI_BASE_URL}/models/gemini-2.0-flash:generateContent?key=${GOOGLE_API_KEY}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            contents: [{ parts: [{ text: prompt }] }],
+        }),
+    });
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Gemini API error: ${errorText}`);
+    }
+    const data = await response.json();
+    const extraction = data.candidates?.[0]?.content?.parts?.[0]?.text || '';
+    return {
+        success: true,
+        videoId,
+        language: language || 'auto-detected',
+        extraction: extraction.trim(),
+    };
+}
+// ============================================================================
+// Backend Export
+// ============================================================================
+export const youtubeBackend = {
+    name: 'youtube',
+    description: 'YouTube video analysis: metadata, transcripts, chapters, downloads, and AI-powered analysis with Gemini.',
+    actions,
+    async execute(action, params) {
+        switch (action) {
+            // Metadata
+            case 'get_metadata':
+                return getMetadata(params);
+            // Transcript
+            case 'get_transcript':
+                return getTranscript(params);
+            // Chapters
+            case 'get_chapters':
+                return getChapters(params);
+            // Downloads
+            case 'download_audio':
+                return downloadAudio(params);
+            case 'download_video':
+                return downloadVideo(params);
+            // Analysis
+            case 'summarize':
+                return summarize(params);
+            case 'analyze':
+                return analyze(params);
+            case 'extract_code':
+                return extractCodeFromVideo(params);
+            default:
+                throw new Error('Unknown action: ' + action);
+        }
+    },
+    async healthCheck() {
+        const startTime = Date.now();
+        const issues = [];
+        // Check yt-dlp
+        const hasYtDlp = await checkYtDlp();
+        if (!hasYtDlp) {
+            issues.push('yt-dlp not installed');
+        }
+        // Check Google API key (for analysis features)
+        if (!GOOGLE_API_KEY) {
+            issues.push('GOOGLE_API_KEY not set (needed for analysis)');
+        }
+        // YouTube API key is optional
+        if (!YOUTUBE_API_KEY) {
+            // Not an error, just informational
+        }
+        if (issues.length > 0) {
+            return {
+                status: issues.includes('yt-dlp not installed') ? 'unavailable' : 'degraded',
+                latency_ms: Date.now() - startTime,
+                error: issues.join('; '),
+            };
+        }
+        return {
+            status: 'healthy',
+            latency_ms: Date.now() - startTime,
+        };
+    },
+};
+//# sourceMappingURL=youtube.js.map