314 lines
11 KiB
Rust
314 lines
11 KiB
Rust
//! Blocking access to the deployed Miruro catalog and stable episode identities.
|
|
//!
|
|
//! See `docs/miruro-api.md`. Terebi owns playback source resolution, headers,
|
|
//! subtitles and playback metadata.
|
|
use std::{io, mem::size_of, time::Duration};
|
|
|
|
use serde::{Deserialize, Serialize};
|
|
use serde_json::{Map, Value};
|
|
|
|
const BASE: &str = "https://barelystarted.miruro.tv";
|
|
const BODY_LIMIT: u64 = 2 * 1024 * 1024;
|
|
|
|
pub struct Client {
|
|
agent: ureq::Agent,
|
|
}
|
|
|
|
/// Catalog metadata and available episode metadata, not a playback guarantee.
|
|
pub struct Detail {
|
|
pub media: Value,
|
|
pub episodes: Vec<Value>,
|
|
}
|
|
|
|
/// Stable catalog identity, never a CDN address or playback-provider name.
|
|
#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, Eq)]
|
|
#[serde(deny_unknown_fields)]
|
|
pub struct Identity {
|
|
pub provider: String,
|
|
pub media_id: String,
|
|
pub episode: u32,
|
|
}
|
|
|
|
impl Identity {
|
|
pub fn new(media_id: String, episode: u32) -> io::Result<Self> {
|
|
let identity = Self {
|
|
provider: "miruro".into(),
|
|
media_id,
|
|
episode,
|
|
};
|
|
identity.validate()?;
|
|
Ok(identity)
|
|
}
|
|
|
|
pub fn validate(&self) -> io::Result<()> {
|
|
if self.provider != "miruro"
|
|
|| self.media_id.len() > 512
|
|
|| self.episode == 0
|
|
|| self.episode > i32::MAX as u32
|
|
{
|
|
return Err(invalid("Invalid Miruro episode identity"));
|
|
}
|
|
validate_segment(&self.media_id)
|
|
}
|
|
|
|
pub fn key(&self) -> String {
|
|
format!("miruro:{}:{}", self.media_id, self.episode)
|
|
}
|
|
|
|
/// The slug is non-identifying; metadata readers must resolve the canonical route.
|
|
pub fn watch_url(&self) -> io::Result<String> {
|
|
self.validate()?;
|
|
Ok(format!(
|
|
"{BASE}/watch/{}/episode?ep={}",
|
|
self.media_id, self.episode
|
|
))
|
|
}
|
|
|
|
pub fn from_key(key: &str) -> io::Result<Self> {
|
|
let (media_id, episode) = key
|
|
.strip_prefix("miruro:")
|
|
.and_then(|rest| rest.split_once(':'))
|
|
.ok_or_else(|| invalid("Invalid Miruro episode key"))?;
|
|
if episode.starts_with('0') || !episode.bytes().all(|byte| byte.is_ascii_digit()) {
|
|
return Err(invalid("Noncanonical Miruro episode key"));
|
|
}
|
|
Self::new(
|
|
media_id.into(),
|
|
episode
|
|
.parse()
|
|
.map_err(|_| invalid("Invalid Miruro episode number"))?,
|
|
)
|
|
}
|
|
}
|
|
|
|
impl Default for Client {
|
|
fn default() -> Self {
|
|
Self {
|
|
agent: ureq::Agent::config_builder()
|
|
.timeout_global(Some(Duration::from_secs(25)))
|
|
.http_status_as_error(false)
|
|
.max_redirects(0)
|
|
.build()
|
|
.new_agent(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Client {
|
|
/// Autocomplete summaries only: the deployed endpoint rejects cursor pagination.
|
|
pub fn search(&self, query: &str) -> io::Result<Vec<Value>> {
|
|
let query = query.trim();
|
|
if query.is_empty() {
|
|
return Err(io::Error::new(
|
|
io::ErrorKind::InvalidInput,
|
|
"Empty Miruro query",
|
|
));
|
|
}
|
|
let body = self.get(
|
|
"/api/search/browse",
|
|
&[("q", query), ("limit", "8"), ("type", "ANIME")],
|
|
&["application/json"],
|
|
)?;
|
|
let mut value: Value = serde_json::from_str(&body).map_err(invalid)?;
|
|
match value.get_mut("data").map(Value::take) {
|
|
Some(Value::Array(items)) => Ok(items),
|
|
_ => Err(invalid("Miruro search did not return a data array")),
|
|
}
|
|
}
|
|
|
|
/// `id` is Miruro's opaque ID; `slug` follows the deployed canonical link helper.
|
|
/// Resolves the episode promise without decoding unrelated sidebar promises.
|
|
pub fn detail(&self, id: &str, slug: &str) -> io::Result<Detail> {
|
|
validate_segment(id)?;
|
|
validate_segment(slug)?;
|
|
let body = self.get(
|
|
&format!("/info/{id}/{slug}/__data.json"),
|
|
&[],
|
|
&["application/json", "text/sveltekit-data"],
|
|
)?;
|
|
let detail = decode_detail(&body)?;
|
|
if detail.media.get("id").and_then(Value::as_str) != Some(id) {
|
|
return Err(invalid("Miruro detail ID did not match the requested ID"));
|
|
}
|
|
Ok(detail)
|
|
}
|
|
|
|
fn get(&self, path: &str, query: &[(&str, &str)], types: &[&str]) -> io::Result<String> {
|
|
let mut response = self
|
|
.agent
|
|
.get(format!("{BASE}{path}"))
|
|
.query_pairs(query.iter().copied())
|
|
.call()
|
|
.map_err(|_| io::Error::other("Miruro HTTP transport failed"))?;
|
|
let status = response.status().as_u16();
|
|
let mime = response.body().mime_type().unwrap_or("missing");
|
|
if status != 200 {
|
|
let kind = match status {
|
|
401 | 403 => io::ErrorKind::PermissionDenied,
|
|
404 => io::ErrorKind::NotFound,
|
|
_ => io::ErrorKind::Other,
|
|
};
|
|
return Err(io::Error::new(
|
|
kind,
|
|
format!("Miruro HTTP {status} ({mime}); no retry attempted"),
|
|
));
|
|
}
|
|
if !types.contains(&mime) {
|
|
return Err(invalid(format!("Unexpected Miruro Content-Type: {mime}")));
|
|
}
|
|
response
|
|
.body_mut()
|
|
.with_config()
|
|
.limit(BODY_LIMIT)
|
|
.read_to_string()
|
|
.map_err(|_| invalid("Miruro response was unreadable, timed out, or exceeded 2 MiB"))
|
|
}
|
|
}
|
|
|
|
fn invalid(message: impl std::fmt::Display) -> io::Error {
|
|
io::Error::new(io::ErrorKind::InvalidData, message.to_string())
|
|
}
|
|
|
|
fn validate_segment(segment: &str) -> io::Result<()> {
|
|
if segment.is_empty()
|
|
|| !segment
|
|
.bytes()
|
|
.all(|byte| byte.is_ascii_alphanumeric() || matches!(byte, b'-' | b'_'))
|
|
{
|
|
return Err(io::Error::new(
|
|
io::ErrorKind::InvalidInput,
|
|
"Invalid Miruro ID or slug path segment",
|
|
));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn reference(value: &Value) -> io::Result<usize> {
|
|
value
|
|
.as_u64()
|
|
.and_then(|index| usize::try_from(index).ok())
|
|
.ok_or_else(|| invalid("Invalid or unsupported devalue reference"))
|
|
}
|
|
|
|
fn field(table: &[Value], key: &str) -> io::Result<usize> {
|
|
reference(
|
|
table
|
|
.first()
|
|
.and_then(|root| root.get(key))
|
|
.ok_or_else(|| invalid(format!("Missing Miruro route field: {key}")))?,
|
|
)
|
|
}
|
|
|
|
fn decode_detail(body: &str) -> io::Result<Detail> {
|
|
let mut lines = body.lines().filter(|line| !line.trim().is_empty());
|
|
let initial: Value = serde_json::from_str(
|
|
lines
|
|
.next()
|
|
.ok_or_else(|| invalid("Empty Miruro route data"))?,
|
|
)
|
|
.map_err(invalid)?;
|
|
if initial.get("type").and_then(Value::as_str) == Some("redirect") {
|
|
return Err(io::Error::new(
|
|
io::ErrorKind::NotFound,
|
|
"Miruro detail returned a route redirect",
|
|
));
|
|
}
|
|
if initial.get("type").and_then(Value::as_str) != Some("data") {
|
|
return Err(invalid("Unexpected Miruro route envelope"));
|
|
}
|
|
let node = initial
|
|
.get("nodes")
|
|
.and_then(Value::as_array)
|
|
.and_then(|nodes| nodes.get(1))
|
|
.filter(|node| node.get("type").and_then(Value::as_str) == Some("data"))
|
|
.ok_or_else(|| invalid("Missing Miruro detail route node"))?;
|
|
let table = node
|
|
.get("data")
|
|
.and_then(Value::as_array)
|
|
.ok_or_else(|| invalid("Missing Miruro detail value table"))?;
|
|
let mut budget = BODY_LIMIT as usize;
|
|
let media = expand(table, field(table, "detail")?, 0, &mut budget)?;
|
|
let promise = table
|
|
.get(field(table, "episodes")?)
|
|
.and_then(Value::as_array)
|
|
.filter(|tag| tag.len() == 2 && tag[0].as_str() == Some("Promise"))
|
|
.ok_or_else(|| invalid("Missing Miruro episode promise"))?;
|
|
let promise_id = table
|
|
.get(reference(&promise[1])?)
|
|
.and_then(Value::as_u64)
|
|
.ok_or_else(|| invalid("Invalid Miruro episode promise ID"))?;
|
|
let mut episodes = None;
|
|
for line in lines {
|
|
let chunk: Value = serde_json::from_str(line).map_err(invalid)?;
|
|
if chunk.get("type").and_then(Value::as_str) != Some("chunk")
|
|
|| chunk.get("id").and_then(Value::as_u64) != Some(promise_id)
|
|
{
|
|
continue;
|
|
}
|
|
if episodes.is_some() || chunk.get("error").is_some() {
|
|
return Err(invalid("Miruro episode promise was duplicated or rejected"));
|
|
}
|
|
let table = chunk
|
|
.get("data")
|
|
.and_then(Value::as_array)
|
|
.ok_or_else(|| invalid("Missing Miruro episode chunk table"))?;
|
|
episodes = match expand(table, 0, 0, &mut budget)? {
|
|
Value::Array(items) => Some(items),
|
|
_ => {
|
|
return Err(invalid(
|
|
"Miruro episode promise did not resolve to an array",
|
|
));
|
|
}
|
|
};
|
|
}
|
|
Ok(Detail {
|
|
media,
|
|
episodes: episodes.ok_or_else(|| invalid("Miruro episode promise never resolved"))?,
|
|
})
|
|
}
|
|
|
|
// ponytail: JSON-shaped detail/episode tables only; reject other devalue types
|
|
// rather than silently coerce them. Add tags only if the catalog actually needs them.
|
|
fn expand(table: &[Value], index: usize, depth: usize, budget: &mut usize) -> io::Result<Value> {
|
|
if depth >= 64 {
|
|
return Err(invalid("Miruro devalue reference cycle or excessive depth"));
|
|
}
|
|
let value = table
|
|
.get(index)
|
|
.ok_or_else(|| invalid("Miruro devalue reference out of bounds"))?;
|
|
let cost = size_of::<Value>() + value.as_str().map_or(0, str::len);
|
|
*budget = budget
|
|
.checked_sub(cost)
|
|
.ok_or_else(|| invalid("Miruro decoded data exceeded its size budget"))?;
|
|
match value {
|
|
Value::Object(object) => {
|
|
let mut decoded = Map::new();
|
|
for (key, value) in object {
|
|
*budget = budget
|
|
.checked_sub(key.len())
|
|
.ok_or_else(|| invalid("Miruro decoded keys exceeded their size budget"))?;
|
|
decoded.insert(
|
|
key.clone(),
|
|
expand(table, reference(value)?, depth + 1, budget)?,
|
|
);
|
|
}
|
|
Ok(Value::Object(decoded))
|
|
}
|
|
Value::Array(array) => {
|
|
if array.first().is_some_and(Value::is_string) {
|
|
return Err(invalid("Unsupported Miruro devalue tagged type"));
|
|
}
|
|
array
|
|
.iter()
|
|
.map(|value| expand(table, reference(value)?, depth + 1, budget))
|
|
.collect::<io::Result<Vec<_>>>()
|
|
.map(Value::Array)
|
|
}
|
|
primitive => Ok(primitive.clone()),
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
#[path = "../tests/unit/miruro.rs"]
|
|
mod tests;
|