feat: merge PR averygan#25 averygan#28 averygan#29 averygan#20 averygan#14 — cookies, playlist, AAC, GIF, batch download

- averygan#25: cookies.txt support (COOKIES_FILE auto-detected, passed to all yt-dlp calls)
- averygan#28: YouTube playlist expansion via /api/playlist endpoint (flat-playlist -J)
- averygan#29: Force AAC audio codec (-S acodec:aac) for all video/audio downloads
- averygan#20: GIF export via ffmpeg 2-pass palettegen/paletteuse, 15fps, max 480px width
- averygan#14: Batch download via /api/batch/download + /api/batch/status, ThreadPoolExecutor(3), parallel Download All

Author: DeBondor

.gitignore

@@ -9,3 +9,7 @@ assets/*.webm
 .DS_Store
 .env
 .vscode/
+.env.local
+.env.production
+.env.development
+cookies.txt

app.py

@@ -9,6 +9,7 @@
 import json
 import subprocess
 import threading
+from concurrent.futures import ThreadPoolExecutor
 from typing import Any
 from urllib.parse import urlparse
 
@@ -29,14 +30,17 @@
 app = Flask(__name__)
 
 DOWNLOAD_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "downloads")
+COOKIES_FILE = os.path.join(os.path.dirname(os.path.abspath(__file__)), "cookies.txt")
 os.makedirs(DOWNLOAD_DIR, exist_ok=True)
 
 MAX_TITLE_LEN = 80
 JOB_TTL_SECONDS = 3600  # auto-purge jobs older than 1 hour
-MAX_JOBS = 500  # hard cap to prevent memory exhaustion
+MAX_JOBS = 500           # hard cap to prevent memory exhaustion
+MAX_BATCH_WORKERS = 3
 
 jobs: dict[str, dict[str, Any]] = {}
 jobs_lock = threading.Lock()
+batch_executor = ThreadPoolExecutor(max_workers=MAX_BATCH_WORKERS)
 
 # ---------------------------------------------------------------------------
 # Helpers
@@ -63,24 +67,29 @@ def _validate_url(url: str) -> str | None:
 def _sanitize_title(title: str) -> str:
     """Produce a filesystem-safe title string."""
     title = title.strip()
-    # Remove null bytes and control characters
     title = re.sub(r'[\x00-\x1f\x7f]', '', title)
     title = _SAFE_FILENAME_RE.sub('', title)
     title = _MULTI_SPACE_RE.sub(' ', title).strip()
-    # Prevent hidden files
     title = title.lstrip('.')
     return title[:MAX_TITLE_LEN].strip()
 
 
 def _validate_format_id(format_id: str | None) -> bool:
-    """Return True if format_id looks safe (alphanumeric, dashes, plus)."""
+    """Return True if format_id looks safe."""
     if format_id is None:
         return True
     return bool(_FORMAT_ID_RE.match(format_id))
 
 
+def _maybe_add_cookies(cmd: list[str]) -> list[str]:
+    """Append --cookies flag if cookies.txt exists."""
+    if os.path.isfile(COOKIES_FILE):
+        cmd += ["--cookies", COOKIES_FILE]
+    return cmd
+
+
 def _purge_stale_jobs() -> None:
-    """Remove completed/errored jobs older than JOB_TTL_SECONDS and their files."""
+    """Remove completed/errored jobs older than JOB_TTL_SECONDS."""
     now = time.time()
     stale = []
     with jobs_lock:
@@ -117,13 +126,17 @@ def run_download(job_id: str, url: str, format_choice: str, format_id: str | Non
     out_template = os.path.join(DOWNLOAD_DIR, f"{job_id}.%(ext)s")
 
     cmd = ["yt-dlp", "--no-playlist", "--no-warnings", "-o", out_template]
+    cmd = _maybe_add_cookies(cmd)
 
     if format_choice == "audio":
-        cmd += ["-x", "--audio-format", "mp3"]
+        cmd += ["-x", "--audio-format", "mp3", "-S", "acodec:aac"]
+    elif format_choice == "gif":
+        # For GIF: download best video first, convert with ffmpeg below
+        cmd += ["-f", "bestvideo+bestaudio/best", "--merge-output-format", "mp4"]
     elif format_id:
-        cmd += ["-f", f"{format_id}+bestaudio/best", "--merge-output-format", "mp4"]
+        cmd += ["-f", f"{format_id}+bestaudio/best", "--merge-output-format", "mp4", "-S", "acodec:aac"]
     else:
-        cmd += ["-f", "bestvideo+bestaudio/best", "--merge-output-format", "mp4"]
+        cmd += ["-f", "bestvideo+bestaudio/best", "--merge-output-format", "mp4", "-S", "acodec:aac"]
 
     cmd.append(url)
 
@@ -152,6 +165,23 @@ def run_download(job_id: str, url: str, format_choice: str, format_id: str | Non
             target = [f for f in files if f.endswith(".mp4")]
         chosen = target[0] if target else files[0]
 
+        # GIF conversion via ffmpeg 2-pass palettegen
+        if format_choice == "gif":
+            gif_out = os.path.splitext(chosen)[0] + ".gif"
+            ffmpeg_cmd = [
+                "ffmpeg", "-y", "-i", chosen,
+                "-vf", "fps=15,scale=w='min(480,iw)':h=-2:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse",
+                gif_out
+            ]
+            ff_res = subprocess.run(ffmpeg_cmd, capture_output=True, text=True)
+            if ff_res.returncode != 0:
+                with jobs_lock:
+                    job["status"] = "error"
+                    job["error"] = "Failed to create GIF"
+                return
+            files.append(gif_out)
+            chosen = gif_out
+
         # Remove intermediate files
         for f in files:
             if f != chosen:
@@ -205,6 +235,7 @@ def get_info() -> tuple[Response, int] | Response:
         return jsonify({"error": url_err}), 400
 
     cmd = ["yt-dlp", "--no-playlist", "--no-warnings", "-j", url]
+    cmd = _maybe_add_cookies(cmd)
     try:
         result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
         if result.returncode != 0:
@@ -213,7 +244,6 @@ def get_info() -> tuple[Response, int] | Response:
 
         info = json.loads(result.stdout)
 
-        # Build quality options — keep best format per resolution
         best_by_height: dict[int, dict] = {}
         for f in info.get("formats", []):
             height = f.get("height")
@@ -247,6 +277,50 @@ def get_info() -> tuple[Response, int] | Response:
         return jsonify({"error": "Internal server error"}), 500
 
 
+@app.route("/api/playlist", methods=["POST"])
+def get_playlist_info() -> tuple[Response, int] | Response:
+    """Expand a playlist URL into individual video URLs."""
+    data = request.get_json(silent=True)
+    if not data:
+        return jsonify({"error": "Invalid request body"}), 400
+
+    url = (data.get("url") or "").strip()
+    url_err = _validate_url(url)
+    if url_err:
+        return jsonify({"error": url_err}), 400
+
+    cmd = ["yt-dlp", "--flat-playlist", "-J", url]
+    cmd = _maybe_add_cookies(cmd)
+
+    try:
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
+        if result.returncode != 0:
+            stderr_last = result.stderr.strip().split("\n")[-1] if result.stderr else "Unknown error"
+            return jsonify({"error": stderr_last}), 400
+
+        info = json.loads(result.stdout)
+        entries = info.get("entries", [])
+        urls = []
+        for entry in entries:
+            entry_url = entry.get("url")
+            if not entry_url:
+                continue
+            if entry_url.startswith("http://") or entry_url.startswith("https://"):
+                urls.append(entry_url)
+            elif "youtube.com" in url or "youtu.be" in url:
+                urls.append(f"https://www.youtube.com/watch?v={entry_url}")
+            else:
+                urls.append(entry_url)
+        return jsonify({"urls": urls})
+    except subprocess.TimeoutExpired:
+        return jsonify({"error": "Timed out fetching playlist info"}), 400
+    except json.JSONDecodeError:
+        return jsonify({"error": "Failed to parse playlist info"}), 400
+    except Exception:
+        log.exception("Error in /api/playlist")
+        return jsonify({"error": "Internal server error"}), 500
+
+
 @app.route("/api/download", methods=["POST"])
 def start_download() -> tuple[Response, int] | Response:
     _purge_stale_jobs()
@@ -261,14 +335,14 @@ def start_download() -> tuple[Response, int] | Response:
         return jsonify({"error": url_err}), 400
 
     format_choice = data.get("format", "video")
-    if format_choice not in ("video", "audio"):
+    if format_choice not in ("video", "audio", "gif"):
         return jsonify({"error": "Invalid format"}), 400
 
     format_id = data.get("format_id")
     if not _validate_format_id(format_id):
         return jsonify({"error": "Invalid format_id"}), 400
 
-    title = (data.get("title") or "")[:200]  # cap title length from client
+    title = (data.get("title") or "")[:200]
 
     with jobs_lock:
         if len(jobs) >= MAX_JOBS:
@@ -293,9 +367,112 @@ def start_download() -> tuple[Response, int] | Response:
     return jsonify({"job_id": job_id})
 
 
+@app.route("/api/batch/download", methods=["POST"])
+def batch_download() -> tuple[Response, int] | Response:
+    """Start multiple downloads in parallel (max 20 URLs, 3 concurrent workers)."""
+    _purge_stale_jobs()
+
+    data = request.get_json(silent=True)
+    if not data:
+        return jsonify({"error": "Invalid request body"}), 400
+
+    urls = data.get("urls", [])
+    if not urls or not isinstance(urls, list):
+        return jsonify({"error": "No URLs provided"}), 400
+    if len(urls) > 20:
+        return jsonify({"error": "Maximum 20 URLs per batch"}), 400
+
+    format_choice = data.get("format", "video")
+    if format_choice not in ("video", "audio", "gif"):
+        return jsonify({"error": "Invalid format"}), 400
+
+    format_id = data.get("format_id")
+    if not _validate_format_id(format_id):
+        return jsonify({"error": "Invalid format_id"}), 400
+
+    batch_id = uuid.uuid4().hex[:10]
+    job_ids = []
+
+    for raw_url in urls:
+        url = (raw_url or "").strip()
+        if not url:
+            continue
+        if _validate_url(url):
+            continue  # skip invalid URLs silently
+        job_id = uuid.uuid4().hex[:10]
+        with jobs_lock:
+            jobs[job_id] = {
+                "status": "downloading",
+                "url": url,
+                "batch_id": batch_id,
+                "title": "",
+                "created": time.time(),
+            }
+        job_ids.append(job_id)
+        batch_executor.submit(run_download, job_id, url, format_choice, format_id)
+
+    with jobs_lock:
+        jobs[batch_id] = {
+            "status": "batch",
+            "job_ids": job_ids,
+            "total": len(job_ids),
+            "created": time.time(),
+        }
+
+    return jsonify({
+        "batch_id": batch_id,
+        "job_ids": job_ids,
+        "total": len(job_ids),
+    })
+
+
+@app.route("/api/batch/status/<batch_id>")
+def batch_status(batch_id: str) -> tuple[Response, int] | Response:
+    """Get aggregated status of all jobs in a batch."""
+    if not re.match(r'^[0-9a-f]{10}$', batch_id):
+        return jsonify({"error": "Invalid batch ID"}), 400
+
+    with jobs_lock:
+        batch = jobs.get(batch_id)
+    if not batch or batch.get("status") != "batch":
+        return jsonify({"error": "Batch not found"}), 404
+
+    job_ids = batch.get("job_ids", [])
+    results = []
+    done_count = 0
+    error_count = 0
+
+    for jid in job_ids:
+        with jobs_lock:
+            job = jobs.get(jid)
+        if not job:
+            results.append({"job_id": jid, "status": "unknown"})
+            continue
+        results.append({
+            "job_id": jid,
+            "status": job["status"],
+            "error": job.get("error"),
+            "filename": job.get("filename"),
+        })
+        if job["status"] == "done":
+            done_count += 1
+        elif job["status"] == "error":
+            error_count += 1
+
+    all_done = (done_count + error_count) >= len(job_ids)
+    return jsonify({
+        "batch_id": batch_id,
+        "total": len(job_ids),
+        "done": done_count,
+        "errors": error_count,
+        "pending": len(job_ids) - done_count - error_count,
+        "all_done": all_done,
+        "jobs": results,
+    })
+
+
 @app.route("/api/status/<job_id>")
 def check_status(job_id: str) -> tuple[Response, int] | Response:
-    # Validate job_id format (hex, 10 chars)
     if not re.match(r'^[0-9a-f]{10}$', job_id):
         return jsonify({"error": "Invalid job ID"}), 400
 
@@ -313,7 +490,6 @@ def check_status(job_id: str) -> tuple[Response, int] | Response:
 
 @app.route("/api/file/<job_id>")
 def download_file(job_id: str) -> tuple[Response, int] | Response:
-    # Validate job_id format
     if not re.match(r'^[0-9a-f]{10}$', job_id):
         return jsonify({"error": "Invalid job ID"}), 400
 
@@ -323,8 +499,6 @@ def download_file(job_id: str) -> tuple[Response, int] | Response:
         return jsonify({"error": "File not ready"}), 404
 
     filepath = job.get("file", "")
-
-    # Path traversal protection: ensure file is inside DOWNLOAD_DIR
     real_path = os.path.realpath(filepath)
     if not real_path.startswith(os.path.realpath(DOWNLOAD_DIR)):
         log.warning("Path traversal attempt blocked: %s", filepath)
@@ -338,7 +512,7 @@ def download_file(job_id: str) -> tuple[Response, int] | Response:
 
 @app.route("/api/cleanup/<job_id>", methods=["POST"])
 def cleanup_job(job_id: str) -> tuple[Response, int] | Response:
-    """Allow clients to signal they've downloaded the file so we can clean up."""
+    """Client signals file was saved — clean up server-side."""
     if not re.match(r'^[0-9a-f]{10}$', job_id):
         return jsonify({"error": "Invalid job ID"}), 400
 

docker-compose.yml

@@ -0,0 +1,8 @@
+services:
+  reclip:
+    build: .
+    ports:
+      - "8899:8899"
+    volumes:
+      - ./cookies.txt:/app/cookies.txt
+    restart: unless-stopped