feat: add custom cookies.txt file support for Instagram and other sites

- Add cookiesFilePath preference for custom Netscape format cookies file
- Cookies file takes priority over browser cookies
- Add file picker UI in Settings > Advanced > Cookies
- Apply cookies to media info fetching, playlist detection, and downloads
- Fix filename collisions by including video ID in default template
- Improve Instagram thumbnail detection from thumbnails array
- Add translations for TR, EN, DE

Author: beratr061

src-tauri/src/commands/folder.rs

@@ -23,6 +23,22 @@ pub async fn pick_folder(app: tauri::AppHandle) -> Result<Option<String>, String
     }
 }
 
+/// Open native file picker dialog for cookies.txt file
+#[tauri::command]
+pub async fn pick_cookies_file(app: tauri::AppHandle) -> Result<Option<String>, String> {
+    let file = app
+        .dialog()
+        .file()
+        .set_title("Select Cookies File")
+        .add_filter("Cookies File", &["txt"])
+        .blocking_pick_file();
+    
+    match file {
+        Some(path) => Ok(Some(path.to_string())),
+        None => Ok(None), // User cancelled
+    }
+}
+
 /// Check if a folder is accessible (exists and writable)
 #[tauri::command]
 pub fn check_folder_accessible(path: String) -> Result<bool, String> {

src-tauri/src/commands/media_info.rs

@@ -9,21 +9,45 @@ use std::process::Stdio;
 
 use crate::models::{DownloadError, MediaInfo};
 use crate::utils::create_hidden_async_command;
+use tauri_plugin_store::StoreExt;
 
 /// Fetches media information from a URL using yt-dlp
 ///
 /// Runs `yt-dlp --simulate -J <url>` to get JSON metadata without downloading.
+/// Uses cookies from preferences if available (for Instagram, etc.)
 ///
 /// **Validates: Requirements 12.3**
 #[tauri::command]
-pub async fn fetch_media_info(url: String) -> Result<MediaInfo, String> {
+pub async fn fetch_media_info(url: String, app: tauri::AppHandle) -> Result<MediaInfo, String> {
     if url.trim().is_empty() {
         return Err(DownloadError::InvalidUrl("URL cannot be empty".to_string()).to_string());
     }
 
+    // Get cookies settings from preferences
+    let (cookies_file_path, cookies_from_browser) = get_cookies_from_preferences(&app);
+
+    // Build command arguments
+    let mut args = vec!["--simulate", "-J", "--no-playlist"];
+    
+    // Add cookies arguments if available
+    let cookies_file_arg: String;
+    let cookies_browser_arg: String;
+    
+    if let Some(ref file_path) = cookies_file_path {
+        cookies_file_arg = file_path.clone();
+        args.push("--cookies");
+        args.push(&cookies_file_arg);
+    } else if let Some(ref browser) = cookies_from_browser {
+        cookies_browser_arg = browser.clone();
+        args.push("--cookies-from-browser");
+        args.push(&cookies_browser_arg);
+    }
+    
+    args.push(&url);
+
     // Run yt-dlp with --simulate -J to get JSON metadata (hidden window)
     let output = create_hidden_async_command("yt-dlp")
-        .args(["--simulate", "-J", "--no-playlist", &url])
+        .args(&args)
         .stdout(Stdio::piped())
         .stderr(Stdio::piped())
         .output()
@@ -55,9 +79,27 @@ fn parse_media_info_json(json_str: &str) -> Result<MediaInfo, String> {
         .unwrap_or("Unknown Title")
         .to_string();
 
+    // Try multiple sources for thumbnail:
+    // 1. Direct thumbnail field
+    // 2. thumbnails array (last item is usually highest quality)
+    // 3. For Instagram: display_url field
     let thumbnail = json["thumbnail"]
         .as_str()
-        .map(|s| s.to_string());
+        .map(|s| s.to_string())
+        .or_else(|| {
+            // Try thumbnails array - get the last (highest quality) one
+            json["thumbnails"]
+                .as_array()
+                .and_then(|arr| {
+                    arr.iter()
+                        .rev()
+                        .find_map(|t| t["url"].as_str().map(|s| s.to_string()))
+                })
+        })
+        .or_else(|| {
+            // Instagram specific: display_url
+            json["display_url"].as_str().map(|s| s.to_string())
+        });
 
     let duration = json["duration"].as_f64();
 
@@ -90,6 +132,33 @@ fn parse_media_info_json(json_str: &str) -> Result<MediaInfo, String> {
     })
 }
 
+/// Gets cookies settings from preferences store
+fn get_cookies_from_preferences(app: &tauri::AppHandle) -> (Option<String>, Option<String>) {
+    let store = match app.store("preferences.json") {
+        Ok(s) => s,
+        Err(_) => return (None, None),
+    };
+
+    let prefs = match store.get("preferences") {
+        Some(v) => v,
+        None => return (None, None),
+    };
+
+    let cookies_file_path = prefs
+        .get("cookiesFilePath")
+        .and_then(|v| v.as_str())
+        .filter(|s| !s.is_empty())
+        .map(|s| s.to_string());
+
+    let cookies_from_browser = prefs
+        .get("cookiesFromBrowser")
+        .and_then(|v| v.as_str())
+        .filter(|s| !s.is_empty())
+        .map(|s| s.to_string());
+
+    (cookies_file_path, cookies_from_browser)
+}
+
 /// Parses yt-dlp stderr to extract a user-friendly error message
 fn parse_ytdlp_error(stderr: &str) -> String {
     let stderr_lower = stderr.to_lowercase();

src-tauri/src/commands/playlist.rs

@@ -4,9 +4,37 @@
 
 use serde::{Deserialize, Serialize};
 use std::process::Stdio;
+use tauri_plugin_store::StoreExt;
 
 use crate::utils::create_hidden_async_command;
 
+/// Gets cookies settings from preferences store
+fn get_cookies_from_preferences(app: &tauri::AppHandle) -> (Option<String>, Option<String>) {
+    let store = match app.store("preferences.json") {
+        Ok(s) => s,
+        Err(_) => return (None, None),
+    };
+
+    let prefs = match store.get("preferences") {
+        Some(v) => v,
+        None => return (None, None),
+    };
+
+    let cookies_file_path = prefs
+        .get("cookiesFilePath")
+        .and_then(|v| v.as_str())
+        .filter(|s| !s.is_empty())
+        .map(|s| s.to_string());
+
+    let cookies_from_browser = prefs
+        .get("cookiesFromBrowser")
+        .and_then(|v| v.as_str())
+        .filter(|s| !s.is_empty())
+        .map(|s| s.to_string());
+
+    (cookies_file_path, cookies_from_browser)
+}
+
 /// A single video entry in a playlist
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -49,7 +77,7 @@ pub struct PlaylistInfo {
 
 /// Check if a URL is a playlist
 #[tauri::command]
-pub async fn check_is_playlist(url: String) -> Result<bool, String> {
+pub async fn check_is_playlist(url: String, app: tauri::AppHandle) -> Result<bool, String> {
     if url.trim().is_empty() {
         return Ok(false);
     }
@@ -67,9 +95,30 @@ pub async fn check_is_playlist(url: String) -> Result<bool, String> {
         }
     }
 
+    // Get cookies settings from preferences
+    let (cookies_file_path, cookies_from_browser) = get_cookies_from_preferences(&app);
+
+    // Build command arguments
+    let mut args = vec!["--flat-playlist", "-J", "--no-download"];
+    
+    let cookies_file_arg: String;
+    let cookies_browser_arg: String;
+    
+    if let Some(ref file_path) = cookies_file_path {
+        cookies_file_arg = file_path.clone();
+        args.push("--cookies");
+        args.push(&cookies_file_arg);
+    } else if let Some(ref browser) = cookies_from_browser {
+        cookies_browser_arg = browser.clone();
+        args.push("--cookies-from-browser");
+        args.push(&cookies_browser_arg);
+    }
+    
+    args.push(&url);
+
     // For other sites, use yt-dlp to check
     let output = create_hidden_async_command("yt-dlp")
-        .args(["--flat-playlist", "-J", "--no-download", &url])
+        .args(&args)
         .stdout(Stdio::piped())
         .stderr(Stdio::piped())
         .output()
@@ -90,19 +139,35 @@ pub async fn check_is_playlist(url: String) -> Result<bool, String> {
 
 /// Fetch playlist information and video list
 #[tauri::command]
-pub async fn fetch_playlist_info(url: String) -> Result<PlaylistInfo, String> {
+pub async fn fetch_playlist_info(url: String, app: tauri::AppHandle) -> Result<PlaylistInfo, String> {
     if url.trim().is_empty() {
         return Err("URL cannot be empty".to_string());
     }
 
+    // Get cookies settings from preferences
+    let (cookies_file_path, cookies_from_browser) = get_cookies_from_preferences(&app);
+
+    // Build command arguments
+    let mut args = vec!["--flat-playlist", "-J", "--no-download"];
+    
+    let cookies_file_arg: String;
+    let cookies_browser_arg: String;
+    
+    if let Some(ref file_path) = cookies_file_path {
+        cookies_file_arg = file_path.clone();
+        args.push("--cookies");
+        args.push(&cookies_file_arg);
+    } else if let Some(ref browser) = cookies_from_browser {
+        cookies_browser_arg = browser.clone();
+        args.push("--cookies-from-browser");
+        args.push(&cookies_browser_arg);
+    }
+    
+    args.push(&url);
+
     // Use --flat-playlist to get playlist info without downloading video details
     let output = create_hidden_async_command("yt-dlp")
-        .args([
-            "--flat-playlist",
-            "-J",
-            "--no-download",
-            &url,
-        ])
+        .args(&args)
         .stdout(Stdio::piped())
         .stderr(Stdio::piped())
         .output()

src-tauri/src/commands/preferences.rs

@@ -36,6 +36,9 @@ pub struct Preferences {
     /// Custom filename template (e.g., "{title} - {uploader} [{quality}]")
     #[serde(default)]
     pub filename_template: Option<String>,
+    /// Path to custom cookies.txt file (Netscape format)
+    #[serde(default)]
+    pub cookies_file_path: Option<String>,
 }
 
 fn default_true() -> bool {
@@ -55,6 +58,7 @@ impl Default for Preferences {
             proxy_enabled: false,
             proxy_url: None,
             filename_template: None,
+            cookies_file_path: None,
         }
     }
 }
@@ -147,6 +151,7 @@ mod tests {
             proxy_enabled: false,
             proxy_url: None,
             filename_template: Some("{title} - {uploader}".to_string()),
+            cookies_file_path: None,
         };
 
         let json = serde_json::to_string(&prefs).unwrap();