Updated the ytmusic cookies situation
This commit is contained in:
Connor Johnstone
341
src/routes/ytauth.rs
Normal file
341
src/routes/ytauth.rs
Normal file
@@ -0,0 +1,341 @@
|
||||
use std::path::PathBuf;
|
||||
use std::process::Stdio;
|
||||
|
||||
use actix_session::Session;
|
||||
use actix_web::{HttpResponse, web};
|
||||
use serde::Serialize;
|
||||
use tokio::process::Command;
|
||||
|
||||
use crate::auth;
|
||||
use crate::error::ApiError;
|
||||
use crate::state::{AppState, FirefoxLoginSession};
|
||||
|
||||
pub fn configure(cfg: &mut web::ServiceConfig) {
|
||||
cfg.service(
|
||||
web::scope("/ytauth")
|
||||
.route("/status", web::get().to(status))
|
||||
.route("/login-start", web::post().to(login_start))
|
||||
.route("/login-stop", web::post().to(login_stop))
|
||||
.route("/refresh", web::post().to(refresh))
|
||||
.route("/cookies", web::delete().to(clear_cookies)),
|
||||
);
|
||||
}
|
||||
|
||||
#[derive(Serialize)]
|
||||
struct AuthStatus {
|
||||
authenticated: bool,
|
||||
cookie_age_hours: Option<f64>,
|
||||
cookie_count: Option<i64>,
|
||||
refresh_enabled: bool,
|
||||
login_session_active: bool,
|
||||
vnc_url: Option<String>,
|
||||
ytdlp_version: Option<String>,
|
||||
ytdlp_latest: Option<String>,
|
||||
ytdlp_update_available: bool,
|
||||
}
|
||||
|
||||
/// GET /api/ytauth/status — check YouTube auth state.
|
||||
async fn status(state: web::Data<AppState>, session: Session) -> Result<HttpResponse, ApiError> {
|
||||
auth::require_auth(&session)?;
|
||||
|
||||
let config = state.config.read().await;
|
||||
let profile_dir = shanty_config::data_dir().join("firefox-profile");
|
||||
|
||||
// Check login session
|
||||
let login = state.firefox_login.lock().await;
|
||||
let login_active = login.is_some();
|
||||
let vnc_url = login.as_ref().map(|s| s.vnc_url.clone());
|
||||
drop(login);
|
||||
|
||||
// Run status check via Python script
|
||||
let (authenticated, cookie_age, cookie_count) =
|
||||
if let Ok(result) = run_cookie_manager(&["status", &profile_dir.to_string_lossy()]).await {
|
||||
if let Ok(v) = serde_json::from_str::<serde_json::Value>(&result) {
|
||||
(
|
||||
v.get("authenticated")
|
||||
.and_then(|v| v.as_bool())
|
||||
.unwrap_or(false),
|
||||
v.get("cookie_age_hours").and_then(|v| v.as_f64()),
|
||||
v.get("cookie_count").and_then(|v| v.as_i64()),
|
||||
)
|
||||
} else {
|
||||
(false, None, None)
|
||||
}
|
||||
} else {
|
||||
(false, None, None)
|
||||
};
|
||||
|
||||
// Check yt-dlp version (local + latest from PyPI)
|
||||
let (ytdlp_version, ytdlp_latest, ytdlp_update_available) = check_ytdlp_version().await;
|
||||
|
||||
Ok(HttpResponse::Ok().json(AuthStatus {
|
||||
authenticated,
|
||||
cookie_age_hours: cookie_age,
|
||||
cookie_count,
|
||||
refresh_enabled: config.download.cookie_refresh_enabled,
|
||||
login_session_active: login_active,
|
||||
vnc_url,
|
||||
ytdlp_version,
|
||||
ytdlp_latest,
|
||||
ytdlp_update_available,
|
||||
}))
|
||||
}
|
||||
|
||||
/// POST /api/ytauth/login-start — launch Firefox + noVNC for interactive login.
|
||||
async fn login_start(
|
||||
state: web::Data<AppState>,
|
||||
session: Session,
|
||||
) -> Result<HttpResponse, ApiError> {
|
||||
auth::require_admin(&session)?;
|
||||
|
||||
let mut login = state.firefox_login.lock().await;
|
||||
if login.is_some() {
|
||||
return Err(ApiError::BadRequest("login session already active".into()));
|
||||
}
|
||||
|
||||
let config = state.config.read().await;
|
||||
let profile_dir = shanty_config::data_dir().join("firefox-profile");
|
||||
let vnc_port = config.download.vnc_port;
|
||||
drop(config);
|
||||
|
||||
let result = run_cookie_manager(&[
|
||||
"login-start",
|
||||
&profile_dir.to_string_lossy(),
|
||||
&vnc_port.to_string(),
|
||||
])
|
||||
.await
|
||||
.map_err(|e| ApiError::Internal(format!("failed to start login: {e}")))?;
|
||||
|
||||
let v: serde_json::Value = serde_json::from_str(&result)
|
||||
.map_err(|e| ApiError::Internal(format!("bad response from cookie_manager: {e}")))?;
|
||||
|
||||
if v.get("status").and_then(|s| s.as_str()) == Some("error") {
|
||||
let err = v
|
||||
.get("error")
|
||||
.and_then(|e| e.as_str())
|
||||
.unwrap_or("unknown error");
|
||||
return Err(ApiError::Internal(format!("login start failed: {err}")));
|
||||
}
|
||||
|
||||
let vnc_url = v
|
||||
.get("vnc_url")
|
||||
.and_then(|u| u.as_str())
|
||||
.unwrap_or("")
|
||||
.to_string();
|
||||
|
||||
*login = Some(FirefoxLoginSession {
|
||||
vnc_url: vnc_url.clone(),
|
||||
});
|
||||
|
||||
Ok(HttpResponse::Ok().json(serde_json::json!({
|
||||
"status": "running",
|
||||
"vnc_url": vnc_url,
|
||||
})))
|
||||
}
|
||||
|
||||
/// POST /api/ytauth/login-stop — stop Firefox, export cookies, enable refresh.
|
||||
async fn login_stop(
|
||||
state: web::Data<AppState>,
|
||||
session: Session,
|
||||
) -> Result<HttpResponse, ApiError> {
|
||||
auth::require_admin(&session)?;
|
||||
|
||||
let mut login = state.firefox_login.lock().await;
|
||||
if login.is_none() {
|
||||
return Err(ApiError::BadRequest("no active login session".into()));
|
||||
}
|
||||
|
||||
let profile_dir = shanty_config::data_dir().join("firefox-profile");
|
||||
let cookies_path = shanty_config::data_dir().join("cookies.txt");
|
||||
|
||||
let result = run_cookie_manager(&[
|
||||
"login-stop",
|
||||
"--profile-dir",
|
||||
&profile_dir.to_string_lossy(),
|
||||
"--cookies-output",
|
||||
&cookies_path.to_string_lossy(),
|
||||
])
|
||||
.await
|
||||
.map_err(|e| ApiError::Internal(format!("failed to stop login: {e}")))?;
|
||||
|
||||
*login = None;
|
||||
|
||||
let v: serde_json::Value = serde_json::from_str(&result).unwrap_or_default();
|
||||
|
||||
// Update config to use the cookies and enable refresh
|
||||
let mut config = state.config.write().await;
|
||||
config.download.cookies_path = Some(cookies_path.clone());
|
||||
config.download.cookie_refresh_enabled = true;
|
||||
config
|
||||
.save(state.config_path.as_deref())
|
||||
.map_err(ApiError::Internal)?;
|
||||
|
||||
Ok(HttpResponse::Ok().json(serde_json::json!({
|
||||
"status": "stopped",
|
||||
"cookies_exported": v.get("cookies_count").is_some(),
|
||||
"cookies_path": cookies_path.to_string_lossy(),
|
||||
})))
|
||||
}
|
||||
|
||||
/// POST /api/ytauth/refresh — trigger immediate headless cookie refresh.
|
||||
async fn refresh(state: web::Data<AppState>, session: Session) -> Result<HttpResponse, ApiError> {
|
||||
auth::require_admin(&session)?;
|
||||
|
||||
let profile_dir = shanty_config::data_dir().join("firefox-profile");
|
||||
let cookies_path = shanty_config::data_dir().join("cookies.txt");
|
||||
|
||||
if !profile_dir.exists() {
|
||||
return Err(ApiError::BadRequest(
|
||||
"no Firefox profile found — log in first".into(),
|
||||
));
|
||||
}
|
||||
|
||||
let result = run_cookie_manager(&[
|
||||
"refresh",
|
||||
&profile_dir.to_string_lossy(),
|
||||
&cookies_path.to_string_lossy(),
|
||||
])
|
||||
.await
|
||||
.map_err(|e| ApiError::Internal(format!("refresh failed: {e}")))?;
|
||||
|
||||
let v: serde_json::Value = serde_json::from_str(&result).unwrap_or_default();
|
||||
|
||||
if v.get("status").and_then(|s| s.as_str()) == Some("error") {
|
||||
let err = v.get("error").and_then(|e| e.as_str()).unwrap_or("unknown");
|
||||
return Err(ApiError::Internal(format!("refresh failed: {err}")));
|
||||
}
|
||||
|
||||
// Ensure config points to cookies
|
||||
let mut config = state.config.write().await;
|
||||
if config.download.cookies_path.is_none() {
|
||||
config.download.cookies_path = Some(cookies_path);
|
||||
config
|
||||
.save(state.config_path.as_deref())
|
||||
.map_err(ApiError::Internal)?;
|
||||
}
|
||||
|
||||
Ok(HttpResponse::Ok().json(v))
|
||||
}
|
||||
|
||||
/// DELETE /api/ytauth/cookies — clear cookies and Firefox profile.
|
||||
async fn clear_cookies(
|
||||
state: web::Data<AppState>,
|
||||
session: Session,
|
||||
) -> Result<HttpResponse, ApiError> {
|
||||
auth::require_admin(&session)?;
|
||||
|
||||
let profile_dir = shanty_config::data_dir().join("firefox-profile");
|
||||
let cookies_path = shanty_config::data_dir().join("cookies.txt");
|
||||
|
||||
// Remove cookies file
|
||||
if cookies_path.exists() {
|
||||
std::fs::remove_file(&cookies_path).ok();
|
||||
}
|
||||
|
||||
// Remove Firefox profile
|
||||
if profile_dir.exists() {
|
||||
std::fs::remove_dir_all(&profile_dir).ok();
|
||||
}
|
||||
|
||||
// Update config
|
||||
let mut config = state.config.write().await;
|
||||
config.download.cookies_path = None;
|
||||
config.download.cookie_refresh_enabled = false;
|
||||
config
|
||||
.save(state.config_path.as_deref())
|
||||
.map_err(ApiError::Internal)?;
|
||||
|
||||
Ok(HttpResponse::Ok().json(serde_json::json!({"status": "cleared"})))
|
||||
}
|
||||
|
||||
// --- Helper ---
|
||||
|
||||
/// Find the cookie_manager.py script (same search logic as ytmusic_search.py).
|
||||
fn find_cookie_manager_script() -> Result<PathBuf, ApiError> {
|
||||
let candidates = [
|
||||
// Next to the binary
|
||||
std::env::current_exe()
|
||||
.ok()
|
||||
.and_then(|p| p.parent().map(|d| d.join("cookie_manager.py"))),
|
||||
// Standard install locations
|
||||
Some(PathBuf::from("/usr/share/shanty/cookie_manager.py")),
|
||||
Some(PathBuf::from("/usr/local/share/shanty/cookie_manager.py")),
|
||||
// Development: crate root
|
||||
Some(PathBuf::from("shanty-dl/scripts/cookie_manager.py")),
|
||||
];
|
||||
|
||||
for candidate in candidates.into_iter().flatten() {
|
||||
if candidate.exists() {
|
||||
return Ok(candidate);
|
||||
}
|
||||
}
|
||||
|
||||
Err(ApiError::Internal("cookie_manager.py not found".into()))
|
||||
}
|
||||
|
||||
/// Run cookie_manager.py with the given arguments and return stdout.
|
||||
async fn run_cookie_manager(args: &[&str]) -> Result<String, String> {
|
||||
let script = find_cookie_manager_script().map_err(|e| e.to_string())?;
|
||||
|
||||
let output = Command::new("python3")
|
||||
.arg(&script)
|
||||
.args(args)
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::piped())
|
||||
.output()
|
||||
.await
|
||||
.map_err(|e| format!("failed to run cookie_manager.py: {e}"))?;
|
||||
|
||||
if !output.status.success() {
|
||||
let stderr = String::from_utf8_lossy(&output.stderr);
|
||||
return Err(format!("cookie_manager.py failed: {stderr}"));
|
||||
}
|
||||
|
||||
Ok(String::from_utf8_lossy(&output.stdout).to_string())
|
||||
}
|
||||
|
||||
/// Check installed yt-dlp version and compare to latest on PyPI.
|
||||
async fn check_ytdlp_version() -> (Option<String>, Option<String>, bool) {
|
||||
// Get installed version
|
||||
let installed = Command::new("yt-dlp")
|
||||
.arg("--version")
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::null())
|
||||
.output()
|
||||
.await
|
||||
.ok()
|
||||
.map(|o| String::from_utf8_lossy(&o.stdout).trim().to_string());
|
||||
|
||||
// Get latest version from PyPI
|
||||
let latest = async {
|
||||
let client = reqwest::Client::builder()
|
||||
.timeout(std::time::Duration::from_secs(5))
|
||||
.build()
|
||||
.ok()?;
|
||||
let resp: serde_json::Value = client
|
||||
.get("https://pypi.org/pypi/yt-dlp/json")
|
||||
.send()
|
||||
.await
|
||||
.ok()?
|
||||
.json()
|
||||
.await
|
||||
.ok()?;
|
||||
resp.get("info")?.get("version")?.as_str().map(String::from)
|
||||
}
|
||||
.await;
|
||||
|
||||
// Normalize version strings for comparison: "2026.03.17" and "2026.3.17" should match.
|
||||
let normalize = |v: &str| -> String {
|
||||
v.split('.')
|
||||
.map(|part| part.trim_start_matches('0'))
|
||||
.map(|p| if p.is_empty() { "0" } else { p })
|
||||
.collect::<Vec<_>>()
|
||||
.join(".")
|
||||
};
|
||||
let update_available = match (&installed, &latest) {
|
||||
(Some(i), Some(l)) => normalize(i) != normalize(l),
|
||||
_ => false,
|
||||
};
|
||||
|
||||
(installed, latest, update_available)
|
||||
}
|
||||
Reference in New Issue
Block a user