ani_lib/
anikoto.rs

1use std::{
2    collections::{HashMap, HashSet},
3    sync::{Arc, Mutex},
4    time::{Duration, Instant},
5};
6
7use base64::{Engine as _, engine::general_purpose::URL_SAFE_NO_PAD};
8use regex::Regex;
9use reqwest::{Client, Response, StatusCode, header};
10use serde::{Deserialize, Serialize};
11use serde_json::{Value, json};
12use url::Url;
13
14use crate::{
15    AniError, CatalogProvider, RequestHeaders, Result, SearchOptions, SearchResult, StreamLink,
16    SubtitleTrack, TranslationType,
17    models::{sort_episodes, sort_streams},
18};
19
20const DEFAULT_ANIKOTO_API: &str = "https://anikotoapi.site";
21const DEFAULT_ANILIST_API: &str = "https://graphql.anilist.co";
22const DEFAULT_MEGAPLAY_BASE: &str = "https://megaplay.buzz";
23const DEFAULT_AGENT: &str = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36";
24const CACHE_TTL: Duration = Duration::from_secs(5 * 60);
25const CACHE_LIMIT: usize = 100;
26
27#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq, Eq)]
28#[serde(rename_all = "camelCase")]
29struct AnikotoId {
30    #[serde(default, skip_serializing_if = "Option::is_none")]
31    anilist_id: Option<String>,
32    #[serde(default, skip_serializing_if = "Option::is_none")]
33    mal_id: Option<String>,
34    #[serde(default, skip_serializing_if = "Option::is_none")]
35    anikoto_id: Option<String>,
36    #[serde(default, skip_serializing_if = "Option::is_none")]
37    title: Option<String>,
38    #[serde(default, skip_serializing_if = "Option::is_none")]
39    episodes: Option<u32>,
40}
41
42#[derive(Clone, Debug, PartialEq, Eq)]
43struct AnikotoEpisode {
44    number: String,
45    embed_id: Option<String>,
46    sub_url: Option<String>,
47    dub_url: Option<String>,
48}
49
50#[derive(Clone, Debug)]
51struct Cached<T> {
52    expires_at: Instant,
53    value: T,
54}
55
56#[derive(Clone, Debug)]
57pub struct AnikotoClientBuilder {
58    anikoto_api: String,
59    anilist_api: String,
60    megaplay_base: String,
61    user_agent: String,
62    timeout: Duration,
63}
64
65impl Default for AnikotoClientBuilder {
66    fn default() -> Self {
67        Self {
68            anikoto_api: DEFAULT_ANIKOTO_API.into(),
69            anilist_api: DEFAULT_ANILIST_API.into(),
70            megaplay_base: DEFAULT_MEGAPLAY_BASE.into(),
71            user_agent: DEFAULT_AGENT.into(),
72            timeout: Duration::from_secs(12),
73        }
74    }
75}
76
77impl AnikotoClientBuilder {
78    pub fn anikoto_api(mut self, value: impl Into<String>) -> Self {
79        self.anikoto_api = value.into();
80        self
81    }
82
83    pub fn anilist_api(mut self, value: impl Into<String>) -> Self {
84        self.anilist_api = value.into();
85        self
86    }
87
88    pub fn megaplay_base(mut self, value: impl Into<String>) -> Self {
89        self.megaplay_base = value.into();
90        self
91    }
92
93    pub fn timeout(mut self, value: Duration) -> Self {
94        self.timeout = value;
95        self
96    }
97
98    pub fn build(self) -> Result<AnikotoClient> {
99        let http = Client::builder()
100            .timeout(self.timeout)
101            .user_agent(&self.user_agent)
102            .cookie_store(true)
103            .redirect(reqwest::redirect::Policy::limited(10))
104            .build()?;
105        Ok(AnikotoClient {
106            inner: Arc::new(Inner {
107                http,
108                anikoto_api: self.anikoto_api.trim_end_matches('/').into(),
109                anilist_api: self.anilist_api,
110                megaplay_base: self.megaplay_base.trim_end_matches('/').into(),
111                user_agent: self.user_agent,
112                searches: Mutex::new(HashMap::new()),
113                series: Mutex::new(HashMap::new()),
114            }),
115        })
116    }
117}
118
119struct Inner {
120    http: Client,
121    anikoto_api: String,
122    anilist_api: String,
123    megaplay_base: String,
124    user_agent: String,
125    searches: Mutex<HashMap<String, Cached<Vec<SearchResult>>>>,
126    series: Mutex<HashMap<String, Cached<Vec<AnikotoEpisode>>>>,
127}
128
129#[derive(Clone)]
130pub struct AnikotoClient {
131    inner: Arc<Inner>,
132}
133
134impl AnikotoClient {
135    pub fn builder() -> AnikotoClientBuilder {
136        AnikotoClientBuilder::default()
137    }
138
139    pub fn new() -> Result<Self> {
140        Self::builder().build()
141    }
142
143    pub async fn search(&self, query: &str, mode: TranslationType) -> Result<Vec<SearchResult>> {
144        self.search_with_options(query, mode, SearchOptions::default())
145            .await
146    }
147
148    pub async fn search_with_options(
149        &self,
150        query: &str,
151        _mode: TranslationType,
152        options: SearchOptions,
153    ) -> Result<Vec<SearchResult>> {
154        let query = query.trim();
155        if query.is_empty() {
156            return Err(AniError::InputEmptyQuery);
157        }
158        let cache_key = format!("{}:{}", options.allow_adult, query.to_ascii_lowercase());
159        if let Some(value) = cache_get(&self.inner.searches, &cache_key) {
160            return Ok(value);
161        }
162
163        let recent = self.search_recent(query, options.allow_adult);
164        let anilist = self.search_anilist(query, options.allow_adult);
165        let (recent, anilist) = tokio::join!(recent, anilist);
166        let values = match (recent, anilist) {
167            (Ok(recent), Ok(anilist)) => merge_search_results(recent, anilist),
168            (Ok(recent), Err(_)) if !recent.is_empty() => recent,
169            (Err(_), Ok(anilist)) => anilist,
170            (Ok(recent), Err(error)) => {
171                if recent.is_empty() {
172                    return Err(error);
173                }
174                recent
175            }
176            (Err(error @ AniError::ProviderRateLimited { .. }), Err(_))
177            | (Err(_), Err(error @ AniError::ProviderRateLimited { .. })) => return Err(error),
178            (Err(first), Err(second)) => {
179                return Err(AniError::Catalog {
180                    provider: "Anikoto".into(),
181                    message: format!(
182                        "recent catalog failed ({first}); AniList search failed ({second})"
183                    ),
184                });
185            }
186        };
187        cache_put(&self.inner.searches, cache_key, values.clone());
188        Ok(values)
189    }
190
191    pub async fn episodes(&self, show_id: &str, _mode: TranslationType) -> Result<Vec<String>> {
192        let id = decode_id(show_id)?;
193        let series = match self.load_series(&id).await {
194            Ok(series) => series,
195            Err(AniError::Network(_)) if id.episodes.is_some() => Vec::new(),
196            Err(error) => return Err(error),
197        };
198        if !series.is_empty() {
199            return Ok(series.into_iter().map(|episode| episode.number).collect());
200        }
201        let count = id.episodes.unwrap_or(0);
202        if count == 0 {
203            return Err(AniError::UnavailableNoEpisodes);
204        }
205        Ok((1..=count).map(|episode| episode.to_string()).collect())
206    }
207
208    pub async fn streams(
209        &self,
210        show_id: &str,
211        episode: &str,
212        mode: TranslationType,
213    ) -> Result<Vec<StreamLink>> {
214        let id = decode_id(show_id)?;
215        let series = match self.load_series(&id).await {
216            Ok(series) => series,
217            Err(AniError::Network(_)) if id.anilist_id.is_some() || id.mal_id.is_some() => {
218                Vec::new()
219            }
220            Err(error) => return Err(error),
221        };
222        let selected = series.iter().find(|value| value.number == episode);
223        let candidates = embed_candidates(&self.inner.megaplay_base, &id, episode, mode, selected);
224        if candidates.is_empty() {
225            return Err(AniError::UnavailableNoEpisodes);
226        }
227
228        let mut failures = Vec::new();
229        for candidate in candidates {
230            match self.resolve_megaplay(&candidate).await {
231                Ok(mut streams) if !streams.is_empty() => {
232                    sort_streams(&mut streams);
233                    return Ok(streams);
234                }
235                Ok(_) => failures.push("MegaPlay returned no native streams".to_owned()),
236                Err(error @ AniError::ProviderRateLimited { .. }) => return Err(error),
237                Err(error) => failures.push(error.to_string()),
238            }
239        }
240        eprintln!("Anikoto native source resolution failures: {}", failures.join("; "));
241        Err(AniError::UnavailableNoEpisodes)
242    }
243
244    async fn search_recent(&self, query: &str, allow_adult: bool) -> Result<Vec<SearchResult>> {
245        let url = format!("{}/recent-anime?page=1&per_page=40", self.inner.anikoto_api);
246        let value = self.get_json(&url, None, None).await?;
247        let needle = query.to_ascii_lowercase();
248        Ok(parse_search_payload(&value, allow_adult)
249            .into_iter()
250            .filter(|value| value.name.to_ascii_lowercase().contains(&needle))
251            .collect())
252    }
253
254    async fn search_anilist(&self, query: &str, allow_adult: bool) -> Result<Vec<SearchResult>> {
255        let graphql = r#"query ($search: String!) { Page(page: 1, perPage: 40) { media(type: ANIME, search: $search, sort: SEARCH_MATCH) { id idMal title { romaji english native } episodes isAdult } } }"#;
256        let response = self
257            .inner
258            .http
259            .post(&self.inner.anilist_api)
260            .header(header::REFERER, "https://anilist.co/")
261            .json(&json!({"query":graphql,"variables":{"search":query}}))
262            .send()
263            .await?;
264        let value = checked_json(response, "AniList").await?;
265        Ok(parse_search_payload(&value, allow_adult))
266    }
267
268    async fn load_series(&self, id: &AnikotoId) -> Result<Vec<AnikotoEpisode>> {
269        let Some(series_id) = id.anikoto_id.as_deref() else {
270            return Ok(vec![]);
271        };
272        if let Some(value) = cache_get(&self.inner.series, series_id) {
273            return Ok(value);
274        }
275        let url = format!("{}/series/{}", self.inner.anikoto_api, series_id);
276        let value = parse_episode_payload(&self.get_json(&url, None, None).await?);
277        cache_put(&self.inner.series, series_id.to_owned(), value.clone());
278        Ok(value)
279    }
280
281    async fn resolve_megaplay(&self, embed_url: &str) -> Result<Vec<StreamLink>> {
282        validate_remote_url(embed_url)?;
283        let html = self
284            .inner
285            .http
286            .get(embed_url)
287            .header(header::REFERER, format!("{}/", self.inner.megaplay_base))
288            .header(header::ACCEPT, "text/html,application/json,text/plain,*/*")
289            .send()
290            .await?;
291        let html = checked_text(html, "MegaPlay").await?;
292        let data_id = parse_data_id(&html).ok_or_else(|| {
293            AniError::Provider("MegaPlay did not expose a playable source id".into())
294        })?;
295        let source_url = format!(
296            "{}/stream/getSources?id={data_id}",
297            self.inner.megaplay_base
298        );
299        let payload = self
300            .get_json(
301                &source_url,
302                Some(embed_url),
303                Some(&self.inner.megaplay_base),
304            )
305            .await?;
306        let (sources, subtitles) = parse_megaplay_sources(&payload);
307        if sources.is_empty() {
308            return Err(AniError::Provider(
309                "MegaPlay did not return any supported native streams".into(),
310            ));
311        }
312
313        let mut streams = Vec::new();
314        for (url, resolution) in sources {
315            let parsed = validate_remote_url(&url)?;
316            let hls = parsed.path().to_ascii_lowercase().contains(".m3u8")
317                || parsed.query().is_some_and(|query| query.contains(".m3u8"));
318            let headers = media_headers(
319                parsed.host_str().unwrap_or_default(),
320                &self.inner.user_agent,
321            );
322            let mut expanded = if hls {
323                self.expand_hls(&url, &resolution, &headers).await?
324            } else {
325                vec![stream_link(url, resolution, false, headers)]
326            };
327            for stream in &mut expanded {
328                stream.subtitles = subtitles.clone();
329            }
330            streams.extend(expanded);
331        }
332        let mut seen = HashSet::new();
333        streams.retain(|stream| seen.insert(stream.url.clone()));
334        Ok(streams)
335    }
336
337    async fn expand_hls(
338        &self,
339        url: &str,
340        fallback_resolution: &str,
341        headers: &RequestHeaders,
342    ) -> Result<Vec<StreamLink>> {
343        let mut request = self.inner.http.get(url);
344        request = apply_headers(request, headers);
345        let response = request.send().await?;
346        if !response.status().is_success() {
347            return Ok(vec![stream_link(
348                url.into(),
349                fallback_resolution.into(),
350                true,
351                headers.clone(),
352            )]);
353        }
354        let text = response.text().await?;
355        if !text.trim_start().starts_with("#EXTM3U") {
356            return Ok(vec![stream_link(
357                url.into(),
358                fallback_resolution.into(),
359                true,
360                headers.clone(),
361            )]);
362        }
363        let base = Url::parse(url)?;
364        let resolution = Regex::new(r"RESOLUTION=\d+x(\d+)").expect("static regex");
365        let mut streams = Vec::new();
366        let mut lines = text.lines();
367        while let Some(line) = lines.next() {
368            if !line.starts_with("#EXT-X-STREAM-INF:") {
369                continue;
370            }
371            let label = resolution
372                .captures(line)
373                .map(|captures| format!("{}p", &captures[1]))
374                .unwrap_or_else(|| fallback_resolution.into());
375            if let Some(path) = lines.by_ref().find(|line| {
376                let line = line.trim();
377                !line.is_empty() && !line.starts_with('#')
378            }) {
379                streams.push(stream_link(
380                    base.join(path.trim())?.to_string(),
381                    label,
382                    true,
383                    headers.clone(),
384                ));
385            }
386        }
387        if streams.is_empty() {
388            streams.push(stream_link(
389                url.into(),
390                fallback_resolution.into(),
391                true,
392                headers.clone(),
393            ));
394        }
395        Ok(streams)
396    }
397
398    async fn get_json(
399        &self,
400        url: &str,
401        referer: Option<&str>,
402        origin: Option<&str>,
403    ) -> Result<Value> {
404        let mut request = self
405            .inner
406            .http
407            .get(url)
408            .header(header::ACCEPT, "application/json,text/plain,*/*");
409        if let Some(referer) = referer {
410            request = request.header(header::REFERER, referer);
411        }
412        if let Some(origin) = origin {
413            request = request.header(header::ORIGIN, origin);
414        }
415        let provider = if url.starts_with(&self.inner.megaplay_base) {
416            "MegaPlay"
417        } else {
418            "Anikoto"
419        };
420        checked_json(request.send().await?, provider).await
421    }
422}
423
424pub fn provider_from_show_id(show_id: &str) -> CatalogProvider {
425    if show_id.starts_with("anikoto2:") {
426        CatalogProvider::Anikoto2
427    } else {
428        CatalogProvider::Anikoto
429    }
430}
431
432fn encode_id(id: &AnikotoId) -> Result<String> {
433    Ok(format!(
434        "anikoto:{}",
435        URL_SAFE_NO_PAD.encode(serde_json::to_vec(id)?)
436    ))
437}
438
439fn decode_id(value: &str) -> Result<AnikotoId> {
440    if !value.is_empty() && value.bytes().all(|byte| byte.is_ascii_digit()) {
441        return Ok(AnikotoId {
442            anikoto_id: Some(value.into()),
443            ..Default::default()
444        });
445    }
446    let payload = value
447        .strip_prefix("anikoto:")
448        .ok_or_else(|| AniError::Input("invalid Anikoto show ID".into()))?;
449    let bytes = URL_SAFE_NO_PAD
450        .decode(payload)
451        .map_err(|_| AniError::Input("invalid Anikoto show ID encoding".into()))?;
452    serde_json::from_slice(&bytes)
453        .map_err(|_| AniError::Input("invalid Anikoto show metadata".into()))
454}
455
456fn parse_search_payload(value: &Value, allow_adult: bool) -> Vec<SearchResult> {
457    let values = value
458        .pointer("/data/Page/media")
459        .or_else(|| value.get("data"))
460        .and_then(Value::as_array)
461        .or_else(|| value.as_array())
462        .cloned()
463        .unwrap_or_default();
464    values
465        .iter()
466        .filter_map(|item| {
467            if !allow_adult
468                && item
469                    .get("isAdult")
470                    .or_else(|| item.get("is_adult"))
471                    .and_then(Value::as_bool)
472                    .unwrap_or(false)
473            {
474                return None;
475            }
476            let anilist_id = string_value(item.get("ani_id").or_else(|| item.get("id")))?;
477            let title = item
478                .get("title")
479                .and_then(|title| {
480                    if let Some(title) = title.as_str() {
481                        return Some(title.to_owned());
482                    }
483                    ["english", "romaji", "native"]
484                        .iter()
485                        .find_map(|key| string_value(title.get(*key)))
486                })
487                .or_else(|| string_value(item.get("name")))
488                .unwrap_or_else(|| format!("AniList {anilist_id}"));
489            let episodes = number_value(item.get("episodes")).unwrap_or(0.0);
490            let anikoto_id = item.get("ani_id").and_then(|ani_id| {
491                let item_id = string_value(item.get("id"));
492                let ani_id = string_value(Some(ani_id));
493                (item_id != ani_id).then_some(item_id).flatten()
494            });
495            let id = encode_id(&AnikotoId {
496                anilist_id: Some(anilist_id),
497                mal_id: string_value(item.get("idMal").or_else(|| item.get("mal_id"))),
498                anikoto_id,
499                title: Some(title.clone()),
500                episodes: (episodes.is_finite() && episodes > 0.0).then_some(episodes as u32),
501            })
502            .ok()?;
503            Some(SearchResult {
504                id,
505                name: title,
506                episodes,
507                provider: CatalogProvider::Anikoto,
508            })
509        })
510        .collect()
511}
512
513fn merge_search_results(
514    recent: Vec<SearchResult>,
515    anilist: Vec<SearchResult>,
516) -> Vec<SearchResult> {
517    let mut seen = HashSet::new();
518    recent
519        .into_iter()
520        .chain(anilist)
521        .filter(|item| {
522            let id = decode_id(&item.id).ok();
523            let key = id
524                .and_then(|id| id.anilist_id)
525                .map(|id| format!("ani:{id}"))
526                .unwrap_or_else(|| format!("title:{}", normalize_title(&item.name)));
527            seen.insert(key)
528        })
529        .collect()
530}
531
532fn parse_episode_payload(value: &Value) -> Vec<AnikotoEpisode> {
533    let data = value.get("data").unwrap_or(value);
534    let mut episodes = data
535        .get("episodes")
536        .and_then(Value::as_array)
537        .into_iter()
538        .flatten()
539        .filter_map(|item| {
540            let number = string_value(
541                item.get("number")
542                    .or_else(|| item.get("episode"))
543                    .or_else(|| item.get("episode_number")),
544            )?;
545            Some(AnikotoEpisode {
546                number,
547                embed_id: string_value(item.get("episode_embed_id")),
548                sub_url: item.pointer("/embed_url/sub").and_then(value_string),
549                dub_url: item.pointer("/embed_url/dub").and_then(value_string),
550            })
551        })
552        .collect::<Vec<_>>();
553    let mut numbers = episodes
554        .iter()
555        .map(|value| value.number.clone())
556        .collect::<Vec<_>>();
557    sort_episodes(&mut numbers);
558    let positions = numbers
559        .into_iter()
560        .enumerate()
561        .map(|(index, number)| (number, index))
562        .collect::<HashMap<_, _>>();
563    episodes.sort_by_key(|episode| {
564        positions
565            .get(&episode.number)
566            .copied()
567            .unwrap_or(usize::MAX)
568    });
569    episodes
570}
571
572fn embed_candidates(
573    base: &str,
574    id: &AnikotoId,
575    episode: &str,
576    mode: TranslationType,
577    selected: Option<&AnikotoEpisode>,
578) -> Vec<String> {
579    let language = mode.to_string();
580    let mut candidates = Vec::new();
581    if let Some(selected) = selected {
582        let explicit = match mode {
583            TranslationType::Sub => selected.sub_url.as_ref(),
584            TranslationType::Dub => selected.dub_url.as_ref(),
585        };
586        if let Some(url) = explicit {
587            candidates.push(url.clone());
588        }
589        if let Some(embed_id) = &selected.embed_id {
590            candidates.push(format!("{base}/stream/s-2/{embed_id}/{language}"));
591        }
592    }
593    if let Some(anilist_id) = &id.anilist_id {
594        candidates.push(format!(
595            "{base}/stream/ani/{anilist_id}/{episode}/{language}"
596        ));
597    }
598    if let Some(mal_id) = &id.mal_id {
599        candidates.push(format!("{base}/stream/mal/{mal_id}/{episode}/{language}"));
600    }
601    let mut seen = HashSet::new();
602    candidates.retain(|candidate| seen.insert(candidate.clone()));
603    candidates
604}
605
606fn parse_data_id(html: &str) -> Option<String> {
607    Regex::new(r#"(?i)\bdata-id=["'](\d+)["']"#)
608        .expect("static regex")
609        .captures(html)
610        .map(|captures| captures[1].to_owned())
611}
612
613fn parse_megaplay_sources(value: &Value) -> (Vec<(String, String)>, Vec<SubtitleTrack>) {
614    fn collect_sources(value: &Value, values: &mut Vec<(String, String)>) {
615        match value {
616            Value::String(url) => values.push((url.clone(), "Auto".into())),
617            Value::Array(items) => items.iter().for_each(|item| collect_sources(item, values)),
618            Value::Object(object) => {
619                if let Some(url) = object
620                    .get("file")
621                    .or_else(|| object.get("url"))
622                    .or_else(|| object.get("src"))
623                    .and_then(Value::as_str)
624                {
625                    let label = object
626                        .get("label")
627                        .or_else(|| object.get("quality"))
628                        .and_then(Value::as_str)
629                        .unwrap_or("Auto");
630                    values.push((url.into(), label.into()));
631                }
632                for key in ["sources", "source", "links"] {
633                    if let Some(child) = object.get(key) {
634                        collect_sources(child, values);
635                    }
636                }
637            }
638            _ => {}
639        }
640    }
641
642    fn collect_tracks(value: &Value, tracks: &mut Vec<SubtitleTrack>) {
643        match value {
644            Value::Array(items) => items.iter().for_each(|item| collect_tracks(item, tracks)),
645            Value::Object(object) => {
646                let kind = object
647                    .get("kind")
648                    .or_else(|| object.get("type"))
649                    .and_then(Value::as_str)
650                    .unwrap_or("")
651                    .to_ascii_lowercase();
652                if !kind.is_empty()
653                    && !kind.contains("caption")
654                    && !kind.contains("subtitle")
655                    && !kind.contains("sub")
656                {
657                    return;
658                }
659                if let Some(url) = object
660                    .get("file")
661                    .or_else(|| object.get("url"))
662                    .or_else(|| object.get("src"))
663                    .and_then(Value::as_str)
664                {
665                    tracks.push(SubtitleTrack {
666                        label: object
667                            .get("label")
668                            .or_else(|| object.get("title"))
669                            .and_then(Value::as_str)
670                            .unwrap_or("Subtitle")
671                            .into(),
672                        url: url.into(),
673                        default: object
674                            .get("default")
675                            .and_then(Value::as_bool)
676                            .unwrap_or(false),
677                    });
678                }
679            }
680            _ => {}
681        }
682    }
683
684    let mut sources = Vec::new();
685    let mut tracks = Vec::new();
686    if let Some(value) = value.get("sources") {
687        collect_sources(value, &mut sources);
688    }
689    if let Some(value) = value.get("source") {
690        collect_sources(value, &mut sources);
691    }
692    for key in ["tracks", "captions", "subtitles"] {
693        if let Some(value) = value.get(key) {
694            collect_tracks(value, &mut tracks);
695        }
696    }
697    let mut seen = HashSet::new();
698    sources.retain(|(url, _)| seen.insert(url.clone()));
699    let mut seen = HashSet::new();
700    tracks.retain(|track| seen.insert(track.url.clone()));
701    (sources, tracks)
702}
703
704fn media_headers(host: &str, user_agent: &str) -> RequestHeaders {
705    if is_megaplay_media_host(host) {
706        RequestHeaders {
707            referer: Some("https://megaplay.buzz/".into()),
708            origin: Some("https://megaplay.buzz".into()),
709            extra: [("User-Agent".into(), user_agent.into())].into(),
710        }
711    } else {
712        RequestHeaders::default()
713    }
714}
715
716pub(crate) fn is_megaplay_media_host(host: &str) -> bool {
717    let host = host.trim_end_matches('.').to_ascii_lowercase();
718    [
719        "megaplay.buzz",
720        "mewstream.buzz",
721        "lostproject.club",
722        "voltara.click",
723        "kotocdn.site",
724    ]
725    .iter()
726    .any(|domain| host == *domain || host.ends_with(&format!(".{domain}")))
727}
728
729pub fn requires_hls_relay(stream: &StreamLink) -> bool {
730    stream.hls
731        && Url::parse(&stream.url)
732            .ok()
733            .and_then(|url| url.host_str().map(str::to_owned))
734            .is_some_and(|host| is_megaplay_media_host(&host))
735}
736
737fn stream_link(url: String, resolution: String, hls: bool, headers: RequestHeaders) -> StreamLink {
738    StreamLink {
739        url,
740        resolution,
741        hls,
742        provider: "MegaPlay".into(),
743        downloadable: true,
744        headers,
745        subtitles: vec![],
746    }
747}
748
749fn apply_headers(
750    mut request: reqwest::RequestBuilder,
751    headers: &RequestHeaders,
752) -> reqwest::RequestBuilder {
753    if let Some(referer) = &headers.referer {
754        request = request.header(header::REFERER, referer);
755    }
756    if let Some(origin) = &headers.origin {
757        request = request.header(header::ORIGIN, origin);
758    }
759    for (name, value) in &headers.extra {
760        request = request.header(name, value);
761    }
762    request
763}
764
765async fn checked_json(response: Response, provider: &str) -> Result<Value> {
766    let status = response.status();
767    if status == StatusCode::TOO_MANY_REQUESTS {
768        let retry_after_seconds = response
769            .headers()
770            .get(header::RETRY_AFTER)
771            .and_then(|value| value.to_str().ok())
772            .and_then(|value| value.parse().ok())
773            .unwrap_or(120);
774        return Err(AniError::ProviderRateLimited {
775            provider: provider.into(),
776            retry_after_seconds,
777        });
778    }
779    if !status.is_success() {
780        return Err(AniError::Catalog {
781            provider: provider.into(),
782            message: format!("HTTP {status}"),
783        });
784    }
785    response.json().await.map_err(Into::into)
786}
787
788async fn checked_text(response: Response, provider: &str) -> Result<String> {
789    let status = response.status();
790    if status == StatusCode::TOO_MANY_REQUESTS {
791        let retry_after_seconds = response
792            .headers()
793            .get(header::RETRY_AFTER)
794            .and_then(|value| value.to_str().ok())
795            .and_then(|value| value.parse().ok())
796            .unwrap_or(120);
797        return Err(AniError::ProviderRateLimited {
798            provider: provider.into(),
799            retry_after_seconds,
800        });
801    }
802    if !status.is_success() {
803        return Err(AniError::Catalog {
804            provider: provider.into(),
805            message: format!("HTTP {status}"),
806        });
807    }
808    response.text().await.map_err(Into::into)
809}
810
811fn validate_remote_url(value: &str) -> Result<Url> {
812    let url = Url::parse(value)?;
813    if !url.username().is_empty() || url.password().is_some() {
814        return Err(AniError::Provider("media URL contains credentials".into()));
815    }
816    let loopback = url.host_str().is_some_and(|host| {
817        host == "localhost"
818            || host
819                .parse::<std::net::IpAddr>()
820                .is_ok_and(|ip| ip.is_loopback())
821    });
822    if url.scheme() != "https" && !(url.scheme() == "http" && loopback) {
823        return Err(AniError::Provider("media URL must use HTTPS".into()));
824    }
825    Ok(url)
826}
827
828fn cache_get<T: Clone>(cache: &Mutex<HashMap<String, Cached<T>>>, key: &str) -> Option<T> {
829    let mut cache = cache.lock().ok()?;
830    cache.retain(|_, value| value.expires_at > Instant::now());
831    cache.get(key).map(|value| value.value.clone())
832}
833
834fn cache_put<T>(cache: &Mutex<HashMap<String, Cached<T>>>, key: String, value: T) {
835    if let Ok(mut cache) = cache.lock() {
836        if cache.len() >= CACHE_LIMIT
837            && let Some(key) = cache.keys().next().cloned()
838        {
839            cache.remove(&key);
840        }
841        cache.insert(
842            key,
843            Cached {
844                expires_at: Instant::now() + CACHE_TTL,
845                value,
846            },
847        );
848    }
849}
850
851fn value_string(value: &Value) -> Option<String> {
852    value
853        .as_str()
854        .map(str::trim)
855        .filter(|value| !value.is_empty())
856        .map(str::to_owned)
857}
858
859fn string_value(value: Option<&Value>) -> Option<String> {
860    match value? {
861        Value::String(value) => Some(value.trim().to_owned()).filter(|value| !value.is_empty()),
862        Value::Number(value) => Some(value.to_string()),
863        _ => None,
864    }
865}
866
867fn number_value(value: Option<&Value>) -> Option<f64> {
868    match value? {
869        Value::Number(value) => value.as_f64(),
870        Value::String(value) => value.parse().ok(),
871        _ => None,
872    }
873}
874
875fn normalize_title(value: &str) -> String {
876    value
877        .chars()
878        .filter(|character| character.is_alphanumeric())
879        .flat_map(char::to_lowercase)
880        .collect()
881}
882
883#[cfg(test)]
884mod tests {
885    use super::*;
886    use wiremock::{
887        Mock, MockServer, ResponseTemplate,
888        matchers::{method, path},
889    };
890
891    #[test]
892    fn ids_round_trip_and_detect_provider() {
893        let value = AnikotoId {
894            anilist_id: Some("123".into()),
895            mal_id: Some("456".into()),
896            anikoto_id: Some("789".into()),
897            title: Some("Example".into()),
898            episodes: Some(12),
899        };
900        let encoded = encode_id(&value).unwrap();
901        assert_eq!(decode_id(&encoded).unwrap(), value);
902        assert_eq!(provider_from_show_id(&encoded), CatalogProvider::Anikoto);
903        assert_eq!(
904            provider_from_show_id("anikoto2:metadata"),
905            CatalogProvider::Anikoto2
906        );
907        assert_eq!(provider_from_show_id("legacy"), CatalogProvider::Anikoto);
908    }
909
910    #[test]
911    fn parses_series_and_candidate_order() {
912        let episodes = parse_episode_payload(&json!({"data":{"episodes":[
913            {"number":"2","episode_embed_id":"22"},
914            {"number":1,"episode_embed_id":"11","embed_url":{"sub":"https://megaplay.buzz/explicit"}}
915        ]}}));
916        assert_eq!(episodes[0].number, "1");
917        let id = AnikotoId {
918            anilist_id: Some("1".into()),
919            mal_id: Some("2".into()),
920            ..Default::default()
921        };
922        let candidates = embed_candidates(
923            "https://megaplay.buzz",
924            &id,
925            "1",
926            TranslationType::Sub,
927            Some(&episodes[0]),
928        );
929        assert_eq!(candidates[0], "https://megaplay.buzz/explicit");
930        assert!(candidates[1].contains("/stream/s-2/11/sub"));
931        assert!(candidates[2].contains("/stream/ani/1/1/sub"));
932        assert!(candidates[3].contains("/stream/mal/2/1/sub"));
933    }
934
935    #[test]
936    fn parses_nested_sources_and_subtitles() {
937        let (sources, subtitles) = parse_megaplay_sources(&json!({
938            "sources":{"links":[{"file":"https://megap.kotocdn.site/master.m3u8","label":"1080p"}]},
939            "tracks":[{"file":"https://megap.kotocdn.site/en.vtt","label":"English","kind":"captions","default":true}]
940        }));
941        assert_eq!(sources[0].1, "1080p");
942        assert_eq!(subtitles[0].label, "English");
943        assert!(subtitles[0].default);
944    }
945
946    #[test]
947    fn host_allowlist_rejects_lookalikes() {
948        assert!(is_megaplay_media_host("megap.kotocdn.site"));
949        assert!(!is_megaplay_media_host("kotocdn.site.example.com"));
950        assert!(!is_megaplay_media_host("evilmegaplay.buzz"));
951    }
952
953    #[test]
954    fn adult_search_results_are_filtered() {
955        let payload = json!({"data":{"Page":{"media":[
956            {"id":1,"title":{"english":"Safe"},"episodes":12,"isAdult":false},
957            {"id":2,"title":{"english":"Adult"},"episodes":1,"isAdult":true}
958        ]}}});
959        assert_eq!(parse_search_payload(&payload, false).len(), 1);
960        assert_eq!(parse_search_payload(&payload, true).len(), 2);
961    }
962
963    #[tokio::test]
964    async fn search_tolerates_anilist_failure_when_catalog_succeeds() {
965        let server = MockServer::start().await;
966        Mock::given(method("GET"))
967            .and(path("/recent-anime"))
968            .respond_with(ResponseTemplate::new(200).set_body_json(
969                json!({"data":[{"id":9,"ani_id":1,"title":"Example","episodes":2}]}),
970            ))
971            .mount(&server)
972            .await;
973        Mock::given(method("POST"))
974            .and(path("/graphql"))
975            .respond_with(ResponseTemplate::new(500))
976            .mount(&server)
977            .await;
978        let client = AnikotoClient::builder()
979            .anikoto_api(server.uri())
980            .anilist_api(format!("{}/graphql", server.uri()))
981            .build()
982            .unwrap();
983        let values = client
984            .search("example", TranslationType::Sub)
985            .await
986            .unwrap();
987        assert_eq!(values.len(), 1);
988        assert_eq!(values[0].provider, CatalogProvider::Anikoto);
989        assert_eq!(
990            decode_id(&values[0].id).unwrap().anikoto_id.as_deref(),
991            Some("9")
992        );
993    }
994
995    #[tokio::test]
996    async fn megaplay_candidates_fall_back_to_the_mal_route() {
997        let server = MockServer::start().await;
998        Mock::given(method("GET"))
999            .and(path("/stream/ani/1/1/sub"))
1000            .respond_with(ResponseTemplate::new(404))
1001            .expect(1)
1002            .mount(&server)
1003            .await;
1004        Mock::given(method("GET"))
1005            .and(path("/stream/mal/2/1/sub"))
1006            .respond_with(ResponseTemplate::new(200).set_body_string("<div data-id=\"99\"></div>"))
1007            .expect(1)
1008            .mount(&server)
1009            .await;
1010        Mock::given(method("GET"))
1011            .and(path("/stream/getSources"))
1012            .respond_with(
1013                ResponseTemplate::new(200)
1014                    .set_body_json(json!({"sources":{"file":"https://voltara.click/video.mp4"}})),
1015            )
1016            .expect(1)
1017            .mount(&server)
1018            .await;
1019        let client = AnikotoClient::builder()
1020            .megaplay_base(server.uri())
1021            .build()
1022            .unwrap();
1023        let id = encode_id(&AnikotoId {
1024            anilist_id: Some("1".into()),
1025            mal_id: Some("2".into()),
1026            episodes: Some(1),
1027            ..Default::default()
1028        })
1029        .unwrap();
1030        let streams = client
1031            .streams(&id, "1", TranslationType::Sub)
1032            .await
1033            .unwrap();
1034        assert_eq!(streams[0].url, "https://voltara.click/video.mp4");
1035    }
1036
1037    #[tokio::test]
1038    async fn live_anikoto_smoke_test_is_opt_in() {
1039        if std::env::var("ANI_CLI_LIVE_ANIKOTO").as_deref() != Ok("1") {
1040            return;
1041        }
1042        let results = AnikotoClient::new()
1043            .unwrap()
1044            .search("Frieren", TranslationType::Sub)
1045            .await
1046            .unwrap();
1047        assert!(!results.is_empty());
1048    }
1049}
ani_lib/anikoto.rs

ani_lib/
anikoto.rs
