Upload main.rs

src/main.rs

@@ -808,6 +808,176 @@ async fn stream_info(State(state): State<AppState>, Query(q): Query<StreamParams
     }))).into_response()
 }
 
+/// /send_audio — HuggingFace скачивает трек и сам загружает его в Telegram через multipart.
+/// Render к аудио не прикасается, только получает обратно file_id для кэша.
+/// Требует: BOT_TOKEN env var на HuggingFace Space.
+#[derive(Debug, Deserialize)]
+struct SendAudioParams {
+    id: u64,
+    format: Option<String>,
+    arl: Option<String>,
+    /// Telegram chat_id куда отправить аудио
+    chat_id: String,
+    /// Опциональные метаданные
+    title: Option<String>,
+    performer: Option<String>,
+    duration: Option<u64>,
+}
+
+async fn send_audio(
+    State(state): State<AppState>,
+    Query(q): Query<SendAudioParams>,
+) -> impl IntoResponse {
+    let bot_token = match std::env::var("BOT_TOKEN").ok().filter(|s| !s.is_empty()) {
+        Some(t) => t,
+        None => return json_error(StatusCode::SERVICE_UNAVAILABLE, "BOT_TOKEN not configured"),
+    };
+
+    let fmt_str = q.format.as_deref().unwrap_or("MP3_320");
+    let formats = match fmt_str {
+        "FLAC"     => vec![Format::FLAC, Format::MP3_320, Format::MP3_128],
+        "MP3_320"  => vec![Format::MP3_320, Format::MP3_128],
+        "MP3_128"  => vec![Format::MP3_128],
+        _          => vec![Format::FLAC, Format::MP3_320, Format::MP3_128],
+    };
+
+    let arl_key = q.arl.as_ref().map(|s| s.trim().to_string()).filter(|s| !s.is_empty())
+        .or_else(|| std::env::var("DEEZER_ARL").ok().filter(|s| !s.is_empty()));
+    if arl_key.is_none() {
+        return json_error(StatusCode::SERVICE_UNAVAILABLE, "arl required");
+    }
+
+    // Resolve FALLBACK_ID
+    let client = api_client_for_arl(&state, arl_key.clone()).await;
+    let target_id = {
+        let mut c = client.lock().await;
+        resolve_fallback_id(&mut c, q.id).await
+    };
+    let mut decrypt_id = target_id;
+
+    let mut cdn_url_opt: Option<String> = None;
+    let mut used_fmt = String::new();
+    let mut last_err: Option<String> = None;
+
+    // Try upstream first
+    if let Ok(text) = upstream_get_url_text(&formats, &vec![target_id]).await {
+        if let Ok(v) = serde_json::from_str::<serde_json::Value>(&text) {
+            let fstrs: Vec<String> = formats.iter().map(|f| format!("{:?}", f)).collect();
+            let fstrs_ref: Vec<&str> = fstrs.iter().map(|s| s.as_str()).collect();
+            let (u, f, _) = extract_media_url_and_format(&v, &fstrs_ref);
+            if !u.is_empty() { cdn_url_opt = Some(u); used_fmt = f; }
+        }
+    }
+
+    // Fallback: ARL
+    for attempt in 0..2u8 {
+        if cdn_url_opt.is_some() { break; }
+        if attempt >= 1 {
+            if let Some(ref arl) = arl_key { state.api_by_arl.write().await.remove(arl); }
+        }
+        let client = api_client_for_arl(&state, arl_key.clone()).await;
+        let res = {
+            let mut c = client.lock().await;
+            if attempt >= 1 {
+                if let Err(e) = c.force_renew().await { last_err = Some(format!("renew:{}", e)); continue; }
+            }
+            match timeout(Duration::from_secs(15), media_url_for_track(&mut c, target_id, &formats)).await {
+                Ok(v) => v,
+                Err(_) => Err("timeout".to_string()),
+            }
+        };
+        match res {
+            Ok((u, f, id_used)) => { cdn_url_opt = Some(u); used_fmt = f; decrypt_id = id_used; break; }
+            Err(e) => { last_err = Some(e); }
+        }
+    }
+
+    let cdn_url = match cdn_url_opt {
+        Some(u) => u,
+        None => {
+            let err = last_err.unwrap_or_else(|| "send_audio:no_url".to_string());
+            tracing::error!("send_audio {} failed: {}", q.id, err);
+            return json_error(StatusCode::NOT_FOUND, "track not found");
+        }
+    };
+
+    // Скачиваем зашифрованный файл с CDN
+    let http = reqwest::Client::builder().no_proxy().timeout(Duration::from_secs(120)).build().unwrap();
+    let resp = match http.get(&cdn_url).send().await {
+        Ok(r) if r.status().is_success() => r,
+        Ok(r) => return json_error(StatusCode::BAD_GATEWAY, format!("CDN {}", r.status())),
+        Err(e) => return json_error(StatusCode::BAD_GATEWAY, format!("CDN fetch: {}", e)),
+    };
+    let content_type = resp.headers()
+        .get(reqwest::header::CONTENT_TYPE)
+        .and_then(|v| v.to_str().ok())
+        .unwrap_or("audio/mpeg")
+        .to_string();
+    let enc = match resp.bytes().await {
+        Ok(b) => b,
+        Err(e) => return json_error(StatusCode::BAD_GATEWAY, format!("CDN read: {}", e)),
+    };
+
+    // Расшифровываем в памяти
+    let key = blowfish_key(decrypt_id);
+    let mut dec = enc.to_vec();
+    let bs = 2048usize;
+    let mut bi = 0usize;
+    let mut pos = 0usize;
+    while pos + bs <= dec.len() {
+        if bi % 3 == 0 { let _ = decrypt_stripe(&mut dec[pos..pos + bs], &key); }
+        bi += 1; pos += bs;
+    }
+
+    let ext = if used_fmt.contains("FLAC") || content_type.contains("flac") { "flac" } else { "mp3" };
+    let mime = if ext == "flac" { "audio/flac" } else { "audio/mpeg" };
+    let filename = format!("track_{}.{}", q.id, ext);
+
+    // Загружаем в Telegram через multipart
+    let tg_url = format!("https://api.telegram.org/bot{}/sendAudio", bot_token);
+    let part = reqwest::multipart::Part::bytes(dec)
+        .file_name(filename)
+        .mime_str(mime)
+        .unwrap();
+    let mut form = reqwest::multipart::Form::new()
+        .text("chat_id", q.chat_id.clone())
+        .part("audio", part);
+    if let Some(ref t) = q.title    { form = form.text("title", t.clone()); }
+    if let Some(ref p) = q.performer { form = form.text("performer", p.clone()); }
+    if let Some(d) = q.duration     { form = form.text("duration", d.to_string()); }
+
+    let tg_resp = match http.post(&tg_url).multipart(form).send().await {
+        Ok(r) => r,
+        Err(e) => return json_error(StatusCode::BAD_GATEWAY, format!("Telegram upload: {}", e)),
+    };
+
+    let tg_json: serde_json::Value = match tg_resp.json().await {
+        Ok(j) => j,
+        Err(e) => return json_error(StatusCode::BAD_GATEWAY, format!("Telegram parse: {}", e)),
+    };
+
+    if tg_json.get("ok").and_then(|v| v.as_bool()) != Some(true) {
+        let desc = tg_json.get("description").and_then(|v| v.as_str()).unwrap_or("unknown");
+        tracing::error!("Telegram sendAudio error: {}", desc);
+        return json_error(StatusCode::BAD_GATEWAY, format!("Telegram: {}", desc));
+    }
+
+    let file_id = tg_json.pointer("/result/audio/file_id")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .to_string();
+    let message_id = tg_json.pointer("/result/message_id")
+        .and_then(|v| v.as_i64())
+        .unwrap_or(0);
+
+    (StatusCode::OK, Json(json!({
+        "ok": true,
+        "file_id": file_id,
+        "message_id": message_id,
+        "format": ext,
+    }))).into_response()
+}
+
 /// /download — like /stream but downloads full track into memory and returns with Content-Length.
 /// Telegram requires Content-Length for sendAudio by URL; this endpoint ensures it.
 async fn download(
@@ -3491,6 +3661,7 @@ async fn main() {
         .route("/fetch", get(fetch))
         .route("/stream", get(stream))
         .route("/download", get(download))
+        .route("/send_audio", get(send_audio))
         .route("/stream_info", get(stream_info))
         .route("/user_data", post(user_data))
         .route("/playlists", post(playlists))