├── .gitignore
├── src
    ├── youtubei
    │   ├── mod.rs
    │   ├── resolve_url.rs
    │   └── browse.rs
    ├── api
    │   ├── mod.rs
    │   ├── types.rs
    │   ├── error.rs
    │   └── handlers.rs
    ├── youtube
    │   ├── mod.rs
    │   ├── playlist_items.rs
    │   ├── subscriptions.rs
    │   ├── videos.rs
    │   └── channels.rs
    ├── main.rs
    ├── errors.rs
    └── models.rs
├── static
    ├── screenshot_1.png
    ├── screenshot_2.png
    ├── screenshot_3.png
    ├── screenshot_4.png
    └── index.html
├── Cargo.toml
├── README.md
├── Dockerfile
└── LICENSE


/.gitignore:
--------------------------------------------------------------------------------
1 | /target
2 | .env
3 | docker-compose.yml


--------------------------------------------------------------------------------
/src/youtubei/mod.rs:
--------------------------------------------------------------------------------
1 | pub mod browse;
2 | pub mod resolve_url;


--------------------------------------------------------------------------------
/src/api/mod.rs:
--------------------------------------------------------------------------------
1 | mod handlers;
2 | mod types;
3 | mod error;
4 | 
5 | pub use handlers::create_router;


--------------------------------------------------------------------------------
/static/screenshot_1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ddd/youtube-lookup/HEAD/static/screenshot_1.png


--------------------------------------------------------------------------------
/static/screenshot_2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ddd/youtube-lookup/HEAD/static/screenshot_2.png


--------------------------------------------------------------------------------
/static/screenshot_3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ddd/youtube-lookup/HEAD/static/screenshot_3.png


--------------------------------------------------------------------------------
/static/screenshot_4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/ddd/youtube-lookup/HEAD/static/screenshot_4.png


--------------------------------------------------------------------------------
/src/youtube/mod.rs:
--------------------------------------------------------------------------------
1 | pub mod channels;
2 | pub mod videos;
3 | pub mod subscriptions;
4 | pub mod playlist_items;


--------------------------------------------------------------------------------
/src/main.rs:
--------------------------------------------------------------------------------
 1 | mod youtubei;
 2 | mod youtube;
 3 | mod models;
 4 | mod errors;
 5 | mod api;
 6 | 
 7 | #[tokio::main]
 8 | async fn main() {
 9 |     let app = api::create_router();
10 | 
11 |     let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await.unwrap();
12 |     println!("Server starting on http://0.0.0.0:3000");
13 | 
14 |     axum::serve(listener, app).await.unwrap();
15 | }


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "youtube-lookup"
 3 | version = "0.1.0"
 4 | edition = "2021"
 5 | 
 6 | [dependencies]
 7 | tracing = "0.1.40"
 8 | tracing-subscriber = { version = "0.3.18", features = ["json"] }
 9 | tracing-appender = "0.2.3"
10 | serde = { version = "1.0", features = ["derive"] }
11 | serde_json = "1.0.132"
12 | tokio = { version = "1.41.0", features = ["full"] }
13 | async-channel = "2.3.1"
14 | thiserror = "2.0.9"
15 | hyper = "1.5.0"
16 | hyper-tls = "0.6.0"
17 | hyper-util = { version = "0.1.9", features = ["full"] }
18 | native-tls = "0.2.12"
19 | rand = "0.8.5"
20 | http-body-util = "0.1.2"
21 | prost = "0.13.4"
22 | reqwest = { version = "0.12.9", features = ["json", "native-tls"] }
23 | tempfile = "3.14.0"
24 | parking_lot = "0.12.3"
25 | chrono = "0.4.39"
26 | axum = "0.7.9"
27 | dotenvy = "0.15"


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | 
 2 | # youtube-lookup
 3 | 
 4 | ![Windows of Ken](./static/screenshot_2.png)
 5 | 
 6 | ## Description
 7 | 
 8 | youtube-lookup is a Rust tool to lookup a channel by the **custom url**, **handle**, **username**, **vanity** and **channel ID** and provide as much metadata as possible
 9 | 
10 | **It supports:**
11 | - channel/conditional redirect detection
12 | - subscriptions
13 | - blocked countries list
14 | 
15 | ... and so much more!
16 | 
17 | 
18 | ## Installation (docker)
19 | 
20 | 1. Update `.env` with your YouTube Data API key
21 | 
22 | ```
23 | $ echo "API_KEY=your_youtube_api_key_here" > .env
24 | ```
25 | 
26 | 2. Build the docker container
27 | 
28 | ```
29 | $ sudo docker build -t youtube-lookup .
30 | ```
31 | 
32 | 3. Run docker container
33 | 
34 | ```
35 | $ sudo docker run --env-file .env -p 3000:3000 youtube-lookup
36 | ```
37 | 
38 | The frontend & API should be running on `0.0.0.0:3000`
39 | 
40 | ## More Screenshots
41 | 
42 | ![Jason Urgo](./static/screenshot_3.png)
43 | 
44 | ![1](./static/screenshot_1.png)
45 | 
46 | ![Future Proof](./static/screenshot_4.png)


--------------------------------------------------------------------------------
/src/errors.rs:
--------------------------------------------------------------------------------
 1 | use thiserror::Error;
 2 | use hyper::StatusCode;
 3 | use std::error::Error;
 4 | 
 5 | #[derive(Error, Debug)]
 6 | pub enum YouTubeError {
 7 |     #[error("Account is closed")]
 8 |     AccountClosed,
 9 |     #[error("Account is terminated")]
10 |     AccountTerminated,
11 |     #[error("Subscriptions are private")]
12 |     SubscriptionsPrivate,
13 |     #[error("Not found")]
14 |     NotFound,
15 |     #[error("Ratelimited")]
16 |     Ratelimited,
17 |     #[error("Unauthorized")]
18 |     Unauthorized,
19 |     #[error("Forbidden")]
20 |     Forbidden,
21 |     #[error("Internal server error")]
22 |     InternalServerError,
23 |     #[error("Unknown Status Code")]
24 |     UnknownStatusCode(StatusCode),
25 |     #[error("Parse error")]
26 |     ParseError(String),
27 |     #[error("HTTP error: {0}")]
28 |     HttpError(#[from] hyper::Error),
29 |     #[error("Legacy HTTP error: {0}")]
30 |     LegacyHttpError(#[from] hyper_util::client::legacy::Error),
31 |     #[error("Protobuf error: {0}")]
32 |     ProtobufError(#[from] prost::DecodeError),
33 |     #[error("Other error: {0}")]
34 |     Other(Box<dyn Error + Send + Sync>),
35 | }


--------------------------------------------------------------------------------
/src/api/types.rs:
--------------------------------------------------------------------------------
 1 | use serde::{Deserialize, Serialize};
 2 | use reqwest::Client;
 3 | use crate::models::{Video, Subscription, Channel};
 4 | 
 5 | pub struct AppState {
 6 |     pub client: Client,
 7 | }
 8 | 
 9 | #[derive(Debug, Deserialize)]
10 | #[serde(rename_all = "SCREAMING_SNAKE_CASE")]
11 | pub enum LookupType {
12 |     CustomUrl,
13 |     Vanity,
14 |     Username,
15 |     Handle,
16 |     ChannelId,
17 | }
18 | 
19 | #[derive(Debug, Deserialize)]
20 | pub struct ChannelLookupRequest {
21 |     pub r#type: LookupType,
22 |     pub id: String,
23 | }
24 | 
25 | #[derive(Debug, Serialize)]
26 | pub struct ChannelLookupResponse {
27 |     pub channel: Channel,
28 |     pub redirect_url: Option<String>,
29 | }
30 | 
31 | #[derive(Debug, Deserialize)]
32 | pub struct PaginatedRequest {
33 |     pub id: String,
34 |     pub page_token: Option<String>,
35 | }
36 | 
37 | #[derive(Debug, Serialize)]
38 | pub struct PlaylistItemsResponse {
39 |     pub items: Vec<Video>,
40 |     pub page_token: Option<String>,
41 | }
42 | 
43 | #[derive(Debug, Serialize)]
44 | pub struct SubscriptionsResponse {
45 |     pub items: Vec<Subscription>,
46 |     pub page_token: Option<String>,
47 | }


--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
 1 | # Use the official Rust image as the base image for building
 2 | FROM rust:1.75-slim-bullseye AS builder
 3 | 
 4 | # Set working directory
 5 | WORKDIR /app
 6 | 
 7 | # Install system dependencies
 8 | RUN apt-get update && \
 9 |     apt-get install -y \
10 |     pkg-config \
11 |     libssl-dev \
12 |     && rm -rf /var/lib/apt/lists/*
13 | 
14 | # Copy the entire project
15 | COPY . .
16 | 
17 | # Build the application in release mode
18 | RUN cargo build --release
19 | 
20 | # Create a minimal runtime image
21 | FROM debian:bullseye-slim
22 | 
23 | # Install runtime dependencies
24 | RUN apt-get update && \
25 |     apt-get install -y \
26 |     ca-certificates \
27 |     libssl1.1 \
28 |     && rm -rf /var/lib/apt/lists/*
29 | 
30 | # Set working directory
31 | WORKDIR /app
32 | 
33 | # Copy the built binary from the builder stage
34 | COPY --from=builder /app/target/release/youtube-lookup .
35 | 
36 | # Copy the static HTML file 
37 | # Adjust the path if your HTML file is in a different location
38 | COPY --from=builder /app/static/index.html ./static/index.html
39 | 
40 | # Expose the port the app runs on
41 | EXPOSE 3000
42 | 
43 | # Set the startup command
44 | CMD ["./youtube-lookup"]
45 | 


--------------------------------------------------------------------------------
/src/models.rs:
--------------------------------------------------------------------------------
 1 | use serde::Serialize;
 2 | 
 3 | #[derive(PartialEq)]
 4 | #[derive(Debug, Clone, Serialize)]
 5 | #[serde(rename_all = "lowercase")]
 6 | pub enum VerificationStatus {
 7 |     None,
 8 |     Verified,
 9 |     OAC
10 | }
11 | 
12 | #[derive(Debug, Clone, Serialize)]
13 | pub struct Channel {
14 |     pub user_id: String,
15 |     pub display_name: Option<String>,
16 |     pub description: Option<String>,
17 |     pub handle: Option<String>,
18 |     pub profile_picture: Option<String>,
19 |     pub banner: Option<String>,
20 |     pub created_at: i64,
21 |     pub country: Option<String>,
22 |     pub view_count: i64,
23 |     pub subscriber_count: i64,
24 |     pub video_count: i64,
25 |     pub made_for_kids: bool,
26 |     pub keywords: Option<Vec<String>>,
27 |     pub trailer: Option<String>,
28 |     pub analytics_account_id: Option<String>,
29 | 
30 |     // the following require innertube
31 |     pub conditional_redirect: Option<String>,
32 |     pub no_index: Option<bool>,
33 |     pub verification: Option<VerificationStatus>,
34 |     pub blocked_countries: Option<Vec<String>>,
35 | }
36 | 
37 | #[derive(Debug, Clone, Serialize)]
38 | pub struct Video {
39 |     pub video_id: String,
40 |     pub title: String,
41 |     pub description: String,
42 |     pub livestream: bool,
43 |     pub views: Option<i64>,
44 |     pub likes: Option<i64>,
45 |     pub comments: Option<i64>,
46 |     pub created_at: i64,
47 | }
48 | 
49 | #[derive(Debug, Clone, Serialize)]
50 | pub struct Subscription {
51 |     pub channel_id: String,
52 |     pub title: String,
53 |     pub created_at: i64,
54 |     pub profile_picture: Option<String>,
55 | }


--------------------------------------------------------------------------------
/src/api/error.rs:
--------------------------------------------------------------------------------
 1 | use axum::{
 2 |     response::{IntoResponse, Response},
 3 |     Json,
 4 |     http::StatusCode,
 5 | };
 6 | use crate::errors::YouTubeError;
 7 | use serde_json::json;
 8 | 
 9 | // Add this new struct for API errors
10 | #[derive(Debug)]
11 | pub enum ApiError {
12 |     YouTubeError(YouTubeError),
13 |     InvalidRequest(String),
14 |     NotFound(String),
15 | }
16 | 
17 | // Implement From conversion
18 | impl From<YouTubeError> for ApiError {
19 |     fn from(err: YouTubeError) -> Self {
20 |         ApiError::YouTubeError(err)
21 |     }
22 | }
23 | 
24 | // Implement IntoResponse for ApiError instead of YouTubeError
25 | impl IntoResponse for ApiError {
26 |     fn into_response(self) -> Response {
27 |         match self {
28 |             ApiError::YouTubeError(err) => {
29 |                 let (status, error_code, message) = match err {
30 |                     YouTubeError::NotFound => (StatusCode::NOT_FOUND, "not_found", "Not found"),
31 |                     YouTubeError::Ratelimited => (StatusCode::TOO_MANY_REQUESTS, "rate_limited", "Rate limited"),
32 |                     YouTubeError::Unauthorized => (StatusCode::UNAUTHORIZED, "unauthorized", "Unauthorized"),
33 |                     YouTubeError::Forbidden => (StatusCode::FORBIDDEN, "forbidden", "Forbidden"),
34 |                     YouTubeError::InternalServerError => (StatusCode::INTERNAL_SERVER_ERROR, "internal_server_error", "Internal server error"),
35 |                     YouTubeError::AccountClosed => (StatusCode::GONE, "account_closed", "Account is closed"),
36 |                     YouTubeError::AccountTerminated => (StatusCode::GONE, "account_terminated", "Account is terminated"),
37 |                     YouTubeError::SubscriptionsPrivate => (StatusCode::FORBIDDEN, "subscriptions_private", "Subscriptions are private"),
38 |                     _ => (StatusCode::INTERNAL_SERVER_ERROR, "unknown_error", "Unknown error occurred"),
39 |                 };
40 | 
41 |                 (status, Json(json!({
42 |                     "error": error_code,
43 |                     "message": message
44 |                 }))).into_response()
45 |             },
46 |             ApiError::InvalidRequest(msg) => {
47 |                 (StatusCode::BAD_REQUEST, Json(json!({
48 |                     "error": "invalid_request",
49 |                     "message": msg
50 |                 }))).into_response()
51 |             },
52 |             ApiError::NotFound(msg) => {
53 |                 (StatusCode::NOT_FOUND, Json(json!({
54 |                     "error": "not_found",
55 |                     "message": msg
56 |                 }))).into_response()
57 |             }
58 |         }
59 |     }
60 | }


--------------------------------------------------------------------------------
/src/youtubei/resolve_url.rs:
--------------------------------------------------------------------------------
  1 | use serde::{Serialize, Deserialize};
  2 | use crate::errors::YouTubeError;
  3 | 
  4 | #[derive(Debug, Serialize)]
  5 | struct InnertubeClient {
  6 |     #[serde(rename = "clientName")]
  7 |     client_name: String,
  8 |     #[serde(rename = "clientVersion")]
  9 |     client_version: String,
 10 | }
 11 | 
 12 | #[derive(Debug, Serialize)]
 13 | struct InnertubeContext {
 14 |     client: InnertubeClient,
 15 | }
 16 | 
 17 | #[derive(Debug, Serialize)]
 18 | struct ResolveUrlRequest {
 19 |     context: InnertubeContext,
 20 |     url: String,
 21 | }
 22 | 
 23 | #[derive(Debug, Deserialize)]
 24 | struct BrowseEndpoint {
 25 |     #[serde(rename = "browseId")]
 26 |     browse_id: String,
 27 | }
 28 | 
 29 | #[derive(Debug, Deserialize)]
 30 | struct UrlEndpoint {
 31 |     url: String,
 32 | }
 33 | 
 34 | #[derive(Debug, Deserialize)]
 35 | #[serde(untagged)]
 36 | enum EndpointType {
 37 |     Browse {
 38 |         #[serde(rename = "browseEndpoint")]
 39 |         browse_endpoint: BrowseEndpoint,
 40 |     },
 41 |     Url {
 42 |         #[serde(rename = "urlEndpoint")]
 43 |         url_endpoint: UrlEndpoint,
 44 |     },
 45 | }
 46 | 
 47 | #[derive(Debug, Deserialize)]
 48 | struct Response {
 49 |     endpoint: EndpointType,
 50 | }
 51 | 
 52 | #[derive(Debug)]
 53 | pub enum ResolveUrlResult {
 54 |     BrowseEndpoint {
 55 |         browse_id: String,
 56 |     },
 57 |     UrlEndpoint {
 58 |         url: String,
 59 |     },
 60 | }
 61 | 
 62 | pub async fn resolve_url(
 63 |     client: &reqwest::Client,
 64 |     url: String,
 65 | ) -> Result<Option<ResolveUrlResult>, YouTubeError> {
 66 |     let request = ResolveUrlRequest {
 67 |         context: InnertubeContext {
 68 |             client: InnertubeClient {
 69 |                 client_name: "WEB".to_string(),
 70 |                 client_version: "2.20240101".to_string(),
 71 |             },
 72 |         },
 73 |         url,
 74 |     };
 75 | 
 76 |     let resp = client
 77 |         .post("https://www.youtube.com/youtubei/v1/navigation/resolve_url")
 78 |         .header("Host", "youtubei.googleapis.com")
 79 |         .header("X-Goog-Fieldmask", "endpoint(urlEndpoint.url,browseEndpoint.browseId)")
 80 |         .json(&request)
 81 |         .send()
 82 |         .await
 83 |         .map_err(|e| YouTubeError::Other(Box::new(e)))?;
 84 | 
 85 |     match resp.status() {
 86 |         reqwest::StatusCode::OK => (),
 87 |         reqwest::StatusCode::NOT_FOUND => return Err(YouTubeError::NotFound),
 88 |         reqwest::StatusCode::UNAUTHORIZED => return Err(YouTubeError::Unauthorized),
 89 |         status => {
 90 |             let body_str = resp
 91 |                 .text()
 92 |                 .await
 93 |                 .map_err(|e| YouTubeError::ParseError(e.to_string()))?;
 94 |             eprintln!("Unknown status code {}: {}", status.as_u16(), body_str);
 95 |             return Err(YouTubeError::UnknownStatusCode(status.into()));
 96 |         }
 97 |     }
 98 | 
 99 |     let response: Response = resp
100 |         .json()
101 |         .await
102 |         .map_err(|e| YouTubeError::ParseError(e.to_string()))?;
103 | 
104 |     match response.endpoint {
105 |         EndpointType::Browse { browse_endpoint } => Ok(Some(ResolveUrlResult::BrowseEndpoint {
106 |             browse_id: browse_endpoint.browse_id,
107 |         })),
108 |         EndpointType::Url { url_endpoint } => Ok(Some(ResolveUrlResult::UrlEndpoint {
109 |             url: url_endpoint.url,
110 |         })),
111 |     }
112 | }
113 | 
114 | #[cfg(test)]
115 | mod tests {
116 |     use super::*;
117 |     use reqwest::Client;
118 | 
119 |     #[tokio::test]
120 |     async fn test_resolve_browse_endpoint() {
121 |         let client = Client::new();
122 |         let result = resolve_url(
123 |             &client,
124 |             "youtube.com/@YouTube".to_string(),
125 |         ).await;
126 | 
127 |         match result {
128 |             Ok(Some(ResolveUrlResult::BrowseEndpoint { browse_id })) => {
129 |                 assert_eq!(browse_id, "UCBR8-60-B28hp2BmDPdntcQ");
130 |             }
131 |             _ => panic!("Expected BrowseEndpoint result"),
132 |         }
133 |     }
134 | 
135 |     #[tokio::test]
136 |     async fn test_resolve_url_endpoint() {
137 |         let client = Client::new();
138 |         let result = resolve_url(
139 |             &client,
140 |             "youtube.com/NikPMusic".to_string(),
141 |         ).await;
142 | 
143 |         match result {
144 |             Ok(Some(ResolveUrlResult::UrlEndpoint { url })) => {
145 |                 assert_eq!(url, "http://www.youtube.com/channel/UCtI6KR_Y7memgBmEW0p8POw");
146 |             }
147 |             _ => panic!("Expected UrlEndpoint result"),
148 |         }
149 |     }
150 | }


--------------------------------------------------------------------------------
/src/youtube/playlist_items.rs:
--------------------------------------------------------------------------------
  1 | use reqwest::Client;
  2 | use serde::Deserialize;
  3 | use chrono::DateTime;
  4 | use crate::models::Video;
  5 | use crate::errors::YouTubeError;
  6 | 
  7 | #[derive(Debug, Deserialize)]
  8 | struct ApiResponse {
  9 |     #[serde(rename = "nextPageToken")]
 10 |     next_page_token: Option<String>,
 11 |     items: Option<Vec<ApiPlaylistItem>>
 12 | }
 13 | 
 14 | #[derive(Debug, Deserialize)]
 15 | struct ApiPlaylistItem {
 16 |     snippet: Option<ItemSnippet>,
 17 | }
 18 | 
 19 | #[derive(Debug, Deserialize)]
 20 | struct ItemSnippet {
 21 |     #[serde(rename = "publishedAt")]
 22 |     published_at: Option<String>,
 23 |     title: Option<String>,
 24 |     description: Option<String>,
 25 |     #[serde(rename = "resourceId")]
 26 |     resource_id: Option<ResourceId>,
 27 | }
 28 | 
 29 | #[derive(Debug, Deserialize)]
 30 | struct ResourceId {
 31 |     #[serde(rename = "videoId")]
 32 |     video_id: Option<String>,
 33 | }
 34 | 
 35 | #[derive(Debug, Deserialize)]
 36 | struct ErrorResponse {
 37 |     error: Error,
 38 | }
 39 | 
 40 | #[derive(Debug, Deserialize)]
 41 | struct Error {
 42 |     message: String,
 43 | }
 44 | 
 45 | pub async fn get_playlist_items(
 46 |     client: &Client,
 47 |     playlist_id: &str,
 48 |     api_key: &str,
 49 |     page_token: Option<&str>,
 50 |     max_results: u32,
 51 | ) -> Result<(Vec<Video>, Option<String>), YouTubeError> {
 52 |     let mut url = format!(
 53 |         "https://youtube.googleapis.com/youtube/v3/playlistItems?playlistId={}&part=snippet&maxResults={}",
 54 |         playlist_id,
 55 |         max_results
 56 |     );
 57 | 
 58 |     if let Some(token) = page_token {
 59 |         url.push_str(&format!("&pageToken={}", token));
 60 |     }
 61 | 
 62 |     let mut request = client
 63 |         .get(&url)
 64 |         .header("Host", "youtube.googleapis.com")
 65 |         .header("X-Goog-Fieldmask", "nextPageToken,items(snippet(publishedAt,title,description,resourceId.videoId))");
 66 | 
 67 |     request = request.header("X-Goog-Api-Key", api_key);
 68 | 
 69 |     let resp = request
 70 |         .send()
 71 |         .await
 72 |         .map_err(|e| YouTubeError::Other(Box::new(e)))?;
 73 | 
 74 |     match resp.status() {
 75 |         reqwest::StatusCode::TOO_MANY_REQUESTS => return Err(YouTubeError::Ratelimited),
 76 |         reqwest::StatusCode::FORBIDDEN => {
 77 |             let error_response: ErrorResponse = resp
 78 |                 .json()
 79 |                 .await
 80 |                 .map_err(|e| YouTubeError::ParseError(e.to_string()))?;
 81 |             
 82 |             if error_response.error.message.starts_with("The request cannot be completed because you have exceeded your") {
 83 |                 return Err(YouTubeError::Ratelimited);
 84 |             }
 85 |             return Err(YouTubeError::Forbidden);
 86 |         },
 87 |         reqwest::StatusCode::NOT_FOUND => return Err(YouTubeError::NotFound),
 88 |         reqwest::StatusCode::UNAUTHORIZED => return Err(YouTubeError::Unauthorized),
 89 |         reqwest::StatusCode::INTERNAL_SERVER_ERROR | reqwest::StatusCode::SERVICE_UNAVAILABLE => {
 90 |             return Err(YouTubeError::InternalServerError);
 91 |         },
 92 |         reqwest::StatusCode::OK => (), // Continue processing
 93 |         status => {
 94 |             let body = resp
 95 |                 .text()
 96 |                 .await
 97 |                 .map_err(|e| YouTubeError::ParseError(e.to_string()))?;
 98 |             eprintln!("Unknown status code {}: {}", status.as_u16(), body);
 99 |             return Err(YouTubeError::UnknownStatusCode(status));
100 |         }
101 |     }
102 | 
103 |     let api_response: ApiResponse = resp
104 |         .json()
105 |         .await
106 |         .map_err(|e| YouTubeError::ParseError(e.to_string()))?;
107 | 
108 |     let videos = api_response.items
109 |         .unwrap_or_default()
110 |         .into_iter()
111 |         .filter_map(|item| {
112 |             let snippet = item.snippet?;
113 |             let video_id = snippet.resource_id?.video_id?;
114 |             let title = snippet.title?;
115 |             let description = snippet.description.unwrap_or_default();
116 |             let created_at = snippet.published_at?;
117 |             
118 |             let timestamp = DateTime::parse_from_rfc3339(&created_at)
119 |                 .ok()?
120 |                 .timestamp();
121 | 
122 |             Some(Video {
123 |                 video_id,
124 |                 title,
125 |                 description,
126 |                 created_at: timestamp,
127 |                 livestream: false,
128 |                 views: None,
129 |                 likes: None,
130 |                 comments: None
131 |             })
132 |         })
133 |         .collect();
134 | 
135 |     Ok((videos, api_response.next_page_token))
136 | }
137 | 
138 | #[cfg(test)]
139 | mod tests {
140 |     use super::*;
141 |     use std::env;
142 |     
143 |     fn get_api_key() -> String {
144 |         dotenvy::dotenv().ok();
145 |         env::var("API_KEY").expect("API_KEY must be set")
146 |     }
147 | 
148 |     #[tokio::test]
149 |     async fn test_get_playlist_items() {
150 |         let client = Client::new();
151 |         let result = get_playlist_items(
152 |             &client,
153 |             "UUwBkSWEuckW8AHZ62XcSLYw",
154 |             &get_api_key(),
155 |             None,
156 |             5,
157 |         ).await;
158 | 
159 |         match result {
160 |             Ok((videos, next_page_token)) => {
161 |                 assert_eq!(videos.len(), 5);
162 |                 assert!(next_page_token.is_some());
163 | 
164 |                 let first_video = &videos[0];
165 |                 assert_eq!(first_video.video_id, "gfKpRpwHckY");
166 |                 assert_eq!(first_video.title, "First Video!!!");
167 |                 assert_eq!(first_video.description, "");
168 |                 // 2023-07-08T13:29:24Z as timestamp
169 |                 assert_eq!(first_video.created_at, 1688822964);
170 |             }
171 |             Err(e) => panic!("Expected successful response, got error: {:?}", e),
172 |         }
173 |     }
174 | }


--------------------------------------------------------------------------------
/src/youtube/subscriptions.rs:
--------------------------------------------------------------------------------
  1 | use reqwest::Client;
  2 | use serde::Deserialize;
  3 | use chrono::DateTime;
  4 | use crate::models::Subscription;
  5 | use crate::errors::YouTubeError;
  6 | 
  7 | #[derive(Debug, Deserialize)]
  8 | struct ApiResponse {
  9 |     #[serde(rename = "nextPageToken")]
 10 |     next_page_token: Option<String>,
 11 |     items: Option<Vec<ApiSubscription>>
 12 | }
 13 | 
 14 | #[derive(Debug, Deserialize)]
 15 | struct ApiSubscription {
 16 |     snippet: Option<SubscriptionSnippet>,
 17 | }
 18 | 
 19 | #[derive(Debug, Deserialize)]
 20 | struct ResourceId {
 21 |     #[serde(rename = "channelId")]
 22 |     channel_id: Option<String>
 23 | }
 24 | 
 25 | #[derive(Debug, Deserialize)]
 26 | struct SubscriptionSnippet {
 27 |     #[serde(rename = "publishedAt")]
 28 |     published_at: Option<String>,
 29 |     title: Option<String>,
 30 |     #[serde(rename = "resourceId")]
 31 |     resource_id: ResourceId,
 32 |     thumbnails: Option<Thumbnails>,
 33 | }
 34 | 
 35 | #[derive(Debug, Deserialize)]
 36 | struct Thumbnails {
 37 |     default: Option<Thumbnail>
 38 | }
 39 | 
 40 | #[derive(Debug, Deserialize)]
 41 | struct Thumbnail {
 42 |     url: Option<String>
 43 | }
 44 | 
 45 | #[derive(Debug, Deserialize)]
 46 | struct ErrorResponse {
 47 |     error: Error,
 48 | }
 49 | 
 50 | #[derive(Debug, Deserialize)]
 51 | struct Error {
 52 |     message: String,
 53 | }
 54 | 
 55 | pub async fn get_subscriptions(
 56 |     client: &Client,
 57 |     channel_id: &str,
 58 |     api_key: &str,
 59 |     page_token: Option<&str>,
 60 |     max_results: u32,
 61 | ) -> Result<(Vec<Subscription>, Option<String>), YouTubeError> {
 62 |     let mut url = format!(
 63 |         "https://youtube.googleapis.com/youtube/v3/subscriptions?channelId={}&part=snippet&order=alphabetical&maxResults={}",
 64 |         channel_id,
 65 |         max_results
 66 |     );
 67 | 
 68 |     if let Some(token) = page_token {
 69 |         url.push_str(&format!("&pageToken={}", token));
 70 |     }
 71 | 
 72 |     let mut request = client
 73 |         .get(&url)
 74 |         .header("Host", "youtube.googleapis.com")
 75 |         .header("X-Goog-Fieldmask", "nextPageToken,items(snippet(publishedAt,title,resourceId.channelId,thumbnails.default.url))");
 76 | 
 77 |     request = request.header("X-Goog-Api-Key", api_key);
 78 | 
 79 |     let resp = request
 80 |         .send()
 81 |         .await
 82 |         .map_err(|e| YouTubeError::Other(Box::new(e)))?;
 83 | 
 84 |     match resp.status() {
 85 |         reqwest::StatusCode::TOO_MANY_REQUESTS => return Err(YouTubeError::Ratelimited),
 86 |         reqwest::StatusCode::FORBIDDEN => {
 87 |             let error_response: ErrorResponse = resp
 88 |                 .json()
 89 |                 .await
 90 |                 .map_err(|e| YouTubeError::ParseError(e.to_string()))?;
 91 |             
 92 |             match error_response.error.message.as_str() {
 93 |                 "Subscriptions could not be retrieved because the subscriber's account is closed." => {
 94 |                     return Err(YouTubeError::AccountClosed)
 95 |                 },
 96 |                 "Subscriptions could not be retrieved because the subscriber's account is suspended." => {
 97 |                     return Err(YouTubeError::AccountTerminated)
 98 |                 },
 99 |                 "The requester is not allowed to access the requested subscriptions." => {
100 |                     return Err(YouTubeError::SubscriptionsPrivate)
101 |                 },
102 |                 msg if msg.starts_with("The request cannot be completed because you have exceeded your") => {
103 |                     return Err(YouTubeError::Ratelimited)
104 |                 },
105 |                 _ => {
106 |                     eprintln!("Unknown forbidden error message: {}", error_response.error.message);
107 |                     return Err(YouTubeError::Forbidden)
108 |                 }
109 |             }
110 |         },
111 |         reqwest::StatusCode::NOT_FOUND => return Err(YouTubeError::NotFound),
112 |         reqwest::StatusCode::UNAUTHORIZED => return Err(YouTubeError::Unauthorized),
113 |         reqwest::StatusCode::INTERNAL_SERVER_ERROR | reqwest::StatusCode::SERVICE_UNAVAILABLE => {
114 |             return Err(YouTubeError::InternalServerError);
115 |         },
116 |         reqwest::StatusCode::OK => (), // Continue processing
117 |         status => {
118 |             let body = resp
119 |                 .text()
120 |                 .await
121 |                 .map_err(|e| YouTubeError::ParseError(e.to_string()))?;
122 |             eprintln!("Unknown status code {}: {}", status.as_u16(), body);
123 |             return Err(YouTubeError::UnknownStatusCode(status));
124 |         }
125 |     }
126 | 
127 |     let api_response: ApiResponse = resp
128 |         .json()
129 |         .await
130 |         .map_err(|e| YouTubeError::ParseError(e.to_string()))?;
131 | 
132 |     let subscriptions = api_response.items
133 |         .unwrap_or_default()
134 |         .into_iter()
135 |         .filter_map(|item| {
136 |             let snippet = item.snippet?;
137 |             let channel_id = snippet.resource_id.channel_id?;
138 |             let title = snippet.title?;
139 |             let created_at = snippet.published_at?;
140 |             
141 |             let timestamp = DateTime::parse_from_rfc3339(&created_at)
142 |                 .ok()?
143 |                 .timestamp();
144 | 
145 |             let profile_picture = snippet
146 |                 .thumbnails
147 |                 .and_then(|t| t.default)
148 |                 .and_then(|d| d.url)
149 |                 .map(|avatar_url| {
150 |                     avatar_url
151 |                         .strip_prefix("https://yt3.ggpht.com/")
152 |                         .unwrap_or(&avatar_url)
153 |                         .split('=')
154 |                         .next()
155 |                         .unwrap_or(&avatar_url)
156 |                         .to_string()
157 |                 });
158 | 
159 |             Some(Subscription {
160 |                 channel_id,
161 |                 title,
162 |                 created_at: timestamp,
163 |                 profile_picture,
164 |             })
165 |         })
166 |         .collect();
167 | 
168 |     Ok((subscriptions, api_response.next_page_token))
169 | }
170 | 
171 | #[cfg(test)]
172 | mod tests {
173 |     use super::*;
174 |     use std::env;
175 |     
176 |     fn get_api_key() -> String {
177 |         dotenvy::dotenv().ok();
178 |         env::var("API_KEY").expect("API_KEY must be set")
179 |     }
180 | 
181 |     #[tokio::test]
182 |     async fn test_get_subscriptions() {
183 |         let client = Client::new();
184 |         let result = get_subscriptions(
185 |             &client,
186 |             "UCewMTclBJZPaNEfbf-qYMGA",
187 |             &get_api_key(),
188 |             None,
189 |             5,
190 |         ).await;
191 | 
192 |         match result {
193 |             Ok((subscriptions, next_page_token)) => {
194 |                 assert_eq!(subscriptions.len(), 5);
195 |                 assert_eq!(next_page_token, Some("CAUQAA".to_string()));
196 | 
197 |                 let sub = &subscriptions[0];
198 |                 assert_eq!(sub.channel_id, "UCewMTclBJZPaNEfbf-qYMGA");
199 |                 assert_eq!(sub.title, "unstopble gameing");
200 |                 // 2024-03-04T10:27:40.003572Z as timestamp
201 |                 assert_eq!(sub.created_at, 1709548060);
202 |             }
203 |             Err(e) => panic!("Expected successful response, got error: {:?}", e),
204 |         }
205 |     }
206 | }


--------------------------------------------------------------------------------
/src/youtube/videos.rs:
--------------------------------------------------------------------------------
  1 | use reqwest::Client;
  2 | use serde::Deserialize;
  3 | use crate::models::Video;
  4 | use crate::errors::YouTubeError;
  5 | 
  6 | #[derive(Debug, Deserialize)]
  7 | struct ApiResponse {
  8 |     items: Option<Vec<ApiVideo>>
  9 | }
 10 | 
 11 | #[derive(Debug, Deserialize)]
 12 | struct ApiVideo {
 13 |     id: String,
 14 |     statistics: Option<Statistics>,
 15 |     #[serde(rename = "liveStreamingDetails")]
 16 |     live_streaming_details: Option<LiveStreamingDetails>
 17 | }
 18 | 
 19 | #[derive(Debug, Deserialize)]
 20 | struct Statistics {
 21 |     #[serde(rename = "viewCount")]
 22 |     view_count: Option<String>,
 23 |     #[serde(rename = "likeCount")]
 24 |     like_count: Option<String>,
 25 |     #[serde(rename = "commentCount")]
 26 |     comment_count: Option<String>
 27 | }
 28 | 
 29 | #[derive(Debug, Deserialize)]
 30 | struct LiveStreamingDetails {
 31 |     #[serde(rename = "actualStartTime")]
 32 |     actual_start_time: Option<String>,
 33 |     #[serde(rename = "concurrentViewers")]
 34 |     concurrent_viewers: Option<String>
 35 | }
 36 | 
 37 | #[derive(Debug, Deserialize)]
 38 | struct ErrorResponse {
 39 |     error: Error,
 40 | }
 41 | 
 42 | #[derive(Debug, Deserialize)]
 43 | struct Error {
 44 |     message: String,
 45 | }
 46 | 
 47 | pub async fn populate_video_stats(
 48 |     client: &Client,
 49 |     videos: &mut Vec<Video>,
 50 |     api_key: &str,
 51 | ) -> Result<(), YouTubeError> {
 52 |     // If no videos, return early
 53 |     if videos.is_empty() {
 54 |         return Ok(());
 55 |     }
 56 | 
 57 |     // Collect video IDs into owned strings
 58 |     let video_ids: Vec<String> = videos.iter().map(|v| v.video_id.clone()).collect();
 59 | 
 60 |     // Create chunks of 50 videos (YouTube API limit)
 61 |     for chunk in video_ids.chunks(50) {
 62 |         let ids = chunk.join(",");
 63 |         let url = format!(
 64 |             "https://youtube.googleapis.com/youtube/v3/videos?id={}&part=liveStreamingDetails,statistics",
 65 |             ids
 66 |         );
 67 | 
 68 |         let request = client
 69 |             .get(&url)
 70 |             .header("Host", "youtube.googleapis.com")
 71 |             .header("X-Goog-Api-Key", api_key)
 72 |             .header("X-Goog-Fieldmask", "items(id,statistics(viewCount,likeCount,commentCount),liveStreamingDetails(actualStartTime,concurrentViewers))");
 73 | 
 74 |         let resp = request
 75 |             .send()
 76 |             .await
 77 |             .map_err(|e| YouTubeError::Other(Box::new(e)))?;
 78 | 
 79 |         match resp.status() {
 80 |             reqwest::StatusCode::TOO_MANY_REQUESTS => return Err(YouTubeError::Ratelimited),
 81 |             reqwest::StatusCode::FORBIDDEN => {
 82 |                 let error_response: ErrorResponse = resp
 83 |                     .json()
 84 |                     .await
 85 |                     .map_err(|e| YouTubeError::ParseError(e.to_string()))?;
 86 |                 
 87 |                 if error_response.error.message.starts_with("The request cannot be completed because you have exceeded your") {
 88 |                     return Err(YouTubeError::Ratelimited);
 89 |                 }
 90 |                 return Err(YouTubeError::Forbidden);
 91 |             },
 92 |             reqwest::StatusCode::NOT_FOUND => return Err(YouTubeError::NotFound),
 93 |             reqwest::StatusCode::UNAUTHORIZED => return Err(YouTubeError::Unauthorized),
 94 |             reqwest::StatusCode::INTERNAL_SERVER_ERROR | reqwest::StatusCode::SERVICE_UNAVAILABLE => {
 95 |                 return Err(YouTubeError::InternalServerError);
 96 |             },
 97 |             reqwest::StatusCode::OK => (), // Continue processing
 98 |             status => {
 99 |                 let body = resp
100 |                     .text()
101 |                     .await
102 |                     .map_err(|e| YouTubeError::ParseError(e.to_string()))?;
103 |                 eprintln!("Unknown status code {}: {}", status.as_u16(), body);
104 |                 return Err(YouTubeError::UnknownStatusCode(status));
105 |             }
106 |         }
107 | 
108 |         let api_response: ApiResponse = resp
109 |             .json()
110 |             .await
111 |             .map_err(|e| YouTubeError::ParseError(e.to_string()))?;
112 | 
113 |         // Create a map of video stats
114 |         let stats_map: std::collections::HashMap<String, (bool, Option<i64>, Option<i64>, Option<i64>)> = 
115 |             api_response.items
116 |                 .unwrap_or_default()
117 |                 .into_iter()
118 |                 .map(|api_video| {
119 |                     let is_livestream = api_video.live_streaming_details.is_some();
120 |                     
121 |                     let views = api_video.statistics
122 |                         .as_ref()
123 |                         .and_then(|s| s.view_count.as_ref())
124 |                         .and_then(|v| v.parse::<i64>().ok());
125 |                         
126 |                     let likes = api_video.statistics
127 |                         .as_ref()
128 |                         .and_then(|s| s.like_count.as_ref())
129 |                         .and_then(|v| v.parse::<i64>().ok());
130 |                         
131 |                     let comments = api_video.statistics
132 |                         .as_ref()
133 |                         .and_then(|s| s.comment_count.as_ref())
134 |                         .and_then(|v| v.parse::<i64>().ok());
135 | 
136 |                     (api_video.id, (is_livestream, views, likes, comments))
137 |                 })
138 |                 .collect();
139 | 
140 |         // Update the video objects with the stats
141 |         for video in videos.iter_mut() {
142 |             if let Some((is_livestream, views, likes, comments)) = stats_map.get(&video.video_id) {
143 |                 video.livestream = *is_livestream;
144 |                 video.views = *views;
145 |                 video.likes = *likes;
146 |                 video.comments = *comments;
147 |             }
148 |         }
149 |     }
150 | 
151 |     Ok(())
152 | }
153 | 
154 | #[cfg(test)]
155 | mod tests {
156 |     use super::*;
157 |     use std::env;
158 |     
159 |     fn get_api_key() -> String {
160 |         dotenvy::dotenv().ok();
161 |         env::var("API_KEY").expect("API_KEY must be set")
162 |     }
163 | 
164 |     #[tokio::test]
165 |     async fn test_populate_video_stats() {
166 |         let client = Client::new();
167 |         let mut videos = vec![
168 |             Video {
169 |                 video_id: "jfKfPfyJRdk".to_string(),
170 |                 title: "lofi hip hop radio 📚 - beats to relax/study to".to_string(),
171 |                 description: "".to_string(),
172 |                 livestream: false,
173 |                 views: None,
174 |                 likes: None,
175 |                 comments: None,
176 |                 created_at: 1657641570
177 |             },
178 |             Video {
179 |                 video_id: "SM66GDRyIVY".to_string(),
180 |                 title: "Turning Red | Official Trailer".to_string(),
181 |                 description: "".to_string(),
182 |                 livestream: false,
183 |                 views: None,
184 |                 likes: None,
185 |                 comments: None,
186 |                 created_at: 1643673600
187 |             }
188 |         ];
189 | 
190 |         let result = populate_video_stats(&client, &mut videos, &get_api_key()).await;
191 |         assert!(result.is_ok());
192 | 
193 |         let first_video = &videos[0];
194 |         assert!(first_video.livestream);
195 |         assert!(first_video.views.is_some());
196 |         assert!(first_video.likes.is_some());
197 |         
198 |         let second_video = &videos[1];
199 |         assert!(!second_video.livestream);
200 |         assert!(second_video.views.is_some());
201 |         assert!(second_video.likes.is_some());
202 |         assert!(second_video.comments.is_some());
203 |     }
204 | }


--------------------------------------------------------------------------------
/src/youtube/channels.rs:
--------------------------------------------------------------------------------
  1 | use reqwest::Client;
  2 | use serde::Deserialize;
  3 | use chrono::DateTime;
  4 | use crate::models::Channel;
  5 | use crate::errors::YouTubeError;
  6 | 
  7 | #[derive(Debug)]
  8 | pub enum LookupType {
  9 |     Username(String),
 10 |     Handle(String),
 11 |     ChannelID(String)
 12 | }
 13 | 
 14 | #[derive(Debug, Deserialize)]
 15 | struct ApiResponse {
 16 |     items: Option<Vec<ApiChannel>>
 17 | }
 18 | 
 19 | #[derive(Debug, Deserialize)]
 20 | struct ApiChannel {
 21 |     id: String,
 22 |     snippet: Option<ChannelSnippet>,
 23 |     statistics: Option<ChannelStatistics>,
 24 |     status: Option<ChannelStatus>,
 25 |     #[serde(rename = "brandingSettings")]
 26 |     branding_settings: Option<BrandingSettings>
 27 | }
 28 | 
 29 | #[derive(Debug, Deserialize)]
 30 | struct ChannelSnippet {
 31 |     title: Option<String>,
 32 |     description: Option<String>,
 33 |     #[serde(rename = "customUrl")]
 34 |     custom_url: Option<String>,
 35 |     #[serde(rename = "publishedAt")]
 36 |     published_at: Option<String>,
 37 |     thumbnails: Option<Thumbnails>,
 38 |     country: Option<String>
 39 | }
 40 | 
 41 | #[derive(Debug, Deserialize)]
 42 | struct Thumbnails {
 43 |     default: Option<Thumbnail>
 44 | }
 45 | 
 46 | #[derive(Debug, Deserialize)]
 47 | struct Thumbnail {
 48 |     url: Option<String>
 49 | }
 50 | 
 51 | #[derive(Debug, Deserialize)]
 52 | struct ChannelStatistics {
 53 |     #[serde(rename = "viewCount")]
 54 |     view_count: Option<String>,
 55 |     #[serde(rename = "subscriberCount")]
 56 |     subscriber_count: Option<String>,
 57 |     #[serde(rename = "videoCount")]
 58 |     video_count: Option<String>
 59 | }
 60 | 
 61 | #[derive(Debug, Deserialize)]
 62 | struct ChannelStatus {
 63 |     #[serde(rename = "madeForKids")]
 64 |     made_for_kids: Option<bool>
 65 | }
 66 | 
 67 | #[derive(Debug, Deserialize)]
 68 | struct BrandingSettings {
 69 |     channel: Option<ChannelBranding>,
 70 |     image: Option<ChannelImage>
 71 | }
 72 | 
 73 | #[derive(Debug, Deserialize)]
 74 | struct ChannelBranding {
 75 |     keywords: Option<String>,
 76 |     #[serde(rename = "trackingAnalyticsAccountId")]
 77 |     tracking_analytics_account_id: Option<String>,
 78 |     #[serde(rename = "unsubscribedTrailer")]
 79 |     unsubscribed_trailer: Option<String>
 80 | }
 81 | 
 82 | #[derive(Debug, Deserialize)]
 83 | struct ChannelImage {
 84 |     #[serde(rename = "bannerExternalUrl")]
 85 |     banner_external_url: Option<String>
 86 | }
 87 | 
 88 | #[derive(Debug, Deserialize)]
 89 | struct ErrorResponse {
 90 |     error: Error,
 91 | }
 92 | 
 93 | #[derive(Debug, Deserialize)]
 94 | struct Error {
 95 |     message: String,
 96 | }
 97 | 
 98 | pub async fn get_channel(
 99 |     client: &Client,
100 |     lookup_type: LookupType,
101 |     api_key: &str,
102 | ) -> Result<Channel, YouTubeError> {
103 |     let url = match &lookup_type {
104 |         LookupType::Username(username) => format!(
105 |             "https://youtube.googleapis.com/youtube/v3/channels?part=brandingSettings,id,snippet,statistics,status,localizations,topicDetails&forUsername={}",
106 |             username
107 |         ),
108 |         LookupType::Handle(handle) => format!(
109 |             "https://youtube.googleapis.com/youtube/v3/channels?part=brandingSettings,id,snippet,statistics,status,localizations,topicDetails&forHandle={}",
110 |             handle
111 |         ),
112 |         LookupType::ChannelID(channel_id) => format!(
113 |             "https://youtube.googleapis.com/youtube/v3/channels?part=brandingSettings,id,snippet,statistics,status,localizations,topicDetails&id={}",
114 |             channel_id
115 |         ),
116 |     };
117 | 
118 |     let mut request = client
119 |         .get(&url)
120 |         .header("Host", "youtube.googleapis.com")
121 |         .header("X-Goog-Fieldmask", "items(id,snippet(title,description,customUrl,publishedAt,country,thumbnails.default.url),statistics(subscriberCount,viewCount,videoCount),topicDetails.topicIds,brandingSettings(channel(keywords,unsubscribedTrailer,trackingAnalyticsAccountId),image.bannerExternalUrl),status.madeForKids)");
122 | 
123 |     request = request.header("X-Goog-Api-Key", api_key);
124 | 
125 |     let resp = request
126 |         .send()
127 |         .await
128 |         .map_err(|e| YouTubeError::Other(Box::new(e)))?;
129 | 
130 |     match resp.status() {
131 |         reqwest::StatusCode::TOO_MANY_REQUESTS => return Err(YouTubeError::Ratelimited),
132 |         reqwest::StatusCode::FORBIDDEN => {
133 |             let error_response: ErrorResponse = resp
134 |                 .json()
135 |                 .await
136 |                 .map_err(|e| YouTubeError::ParseError(e.to_string()))?;
137 |             
138 |             if error_response.error.message.starts_with("The request cannot be completed because you have exceeded your") {
139 |                 return Err(YouTubeError::Ratelimited);
140 |             }
141 |             return Err(YouTubeError::Forbidden);
142 |         },
143 |         reqwest::StatusCode::NOT_FOUND => return Err(YouTubeError::NotFound),
144 |         reqwest::StatusCode::UNAUTHORIZED => return Err(YouTubeError::Unauthorized),
145 |         reqwest::StatusCode::INTERNAL_SERVER_ERROR | reqwest::StatusCode::SERVICE_UNAVAILABLE => {
146 |             return Err(YouTubeError::InternalServerError);
147 |         },
148 |         reqwest::StatusCode::OK => (), // Continue processing
149 |         status => {
150 |             let body = resp
151 |                 .text()
152 |                 .await
153 |                 .map_err(|e| YouTubeError::ParseError(e.to_string()))?;
154 |             eprintln!("Unknown status code {}: {}", status.as_u16(), body);
155 |             return Err(YouTubeError::UnknownStatusCode(status));
156 |         }
157 |     }
158 | 
159 |     let api_response: ApiResponse = resp
160 |         .json()
161 |         .await
162 |         .map_err(|e| YouTubeError::ParseError(e.to_string()))?;
163 | 
164 |     let channel = api_response.items
165 |         .and_then(|mut items| items.pop())
166 |         .ok_or(YouTubeError::NotFound)?;
167 | 
168 |     let profile_picture = channel.snippet
169 |         .as_ref()
170 |         .and_then(|s| s.thumbnails.as_ref())
171 |         .and_then(|t| t.default.as_ref())
172 |         .and_then(|d| d.url.as_ref())
173 |         .map(|avatar_url| {
174 |             avatar_url
175 |                 .strip_prefix("https://yt3.ggpht.com/")
176 |                 .unwrap_or(avatar_url)
177 |                 .split('=')
178 |                 .next()
179 |                 .unwrap_or(avatar_url)
180 |                 .to_string()
181 |         });
182 | 
183 |     let banner = channel.branding_settings
184 |         .as_ref()
185 |         .and_then(|b| b.image.as_ref())
186 |         .and_then(|i| i.banner_external_url.as_ref())
187 |         .map(|banner_url| {
188 |             // Try stripping both possible domains
189 |             let stripped_url = banner_url
190 |                 .strip_prefix("https://yt3.googleusercontent.com/")
191 |                 .or_else(|| banner_url.strip_prefix("https://lh3.googleusercontent.com/"))
192 |                 .unwrap_or(banner_url);
193 |             
194 |             // Get everything before the first '=' if it exists
195 |             stripped_url
196 |                 .split('=')
197 |                 .next()
198 |                 .unwrap_or(stripped_url)
199 |                 .to_string()
200 |         });
201 | 
202 |     let handle = channel.snippet
203 |         .as_ref()
204 |         .and_then(|s| s.custom_url.as_ref())
205 |         .and_then(|h| {
206 |             if h.starts_with('@') {
207 |                 Some(h.trim_start_matches('@').to_string())
208 |             } else {
209 |                 None
210 |             }
211 |         });
212 | 
213 |     Ok(Channel {
214 |         user_id: channel.id,
215 |         display_name: channel.snippet.as_ref().and_then(|s| s.title.clone()),
216 |         description: channel.snippet.as_ref().and_then(|s| s.description.clone()),
217 |         handle,
218 |         profile_picture,
219 |         banner,
220 |         created_at: channel.snippet
221 |             .as_ref()
222 |             .and_then(|s| s.published_at.as_ref())
223 |             .and_then(|dt| DateTime::parse_from_rfc3339(dt).ok())
224 |             .map(|dt| dt.timestamp())
225 |             .unwrap_or_default(),
226 |         country: channel.snippet.as_ref().and_then(|s| s.country.clone()),
227 |         view_count: channel.statistics
228 |             .as_ref()
229 |             .and_then(|s| s.view_count.as_ref())
230 |             .and_then(|v| v.parse::<i64>().ok())
231 |             .unwrap_or_default(),
232 |         subscriber_count: channel.statistics
233 |             .as_ref()
234 |             .and_then(|s| s.subscriber_count.as_ref())
235 |             .and_then(|v| v.parse::<i64>().ok())
236 |             .unwrap_or_default(),
237 |         video_count: channel.statistics
238 |             .as_ref()
239 |             .and_then(|s| s.video_count.as_ref())
240 |             .and_then(|v| v.parse::<i64>().ok())
241 |             .unwrap_or_default(),
242 |         made_for_kids: channel.status
243 |             .and_then(|s| s.made_for_kids)
244 |             .unwrap_or_default(),
245 |         keywords: channel.branding_settings
246 |             .as_ref()
247 |             .and_then(|b| b.channel.as_ref())
248 |             .and_then(|c| c.keywords.as_ref())
249 |             .map(|k| {
250 |                 let mut tags = Vec::new();
251 |                 let mut current_tag = String::new();
252 |                 let mut in_quotes = false;
253 |                 
254 |                 for c in k.chars() {
255 |                     match c {
256 |                         '"' => {
257 |                             in_quotes = !in_quotes;
258 |                         },
259 |                         ' ' if !in_quotes => {
260 |                             if !current_tag.is_empty() {
261 |                                 tags.push(current_tag.trim().to_string());
262 |                                 current_tag.clear();
263 |                             }
264 |                         },
265 |                         '\\' => (), // Skip escape characters
266 |                         _ => current_tag.push(c),
267 |                     }
268 |                 }
269 |                 
270 |                 if !current_tag.is_empty() {
271 |                     tags.push(current_tag.trim().to_string());
272 |                 }
273 |                 
274 |                 tags.into_iter().filter(|s| !s.is_empty()).collect::<Vec<_>>()
275 |             }),
276 |         trailer: channel.branding_settings
277 |             .as_ref()
278 |             .and_then(|b| b.channel.as_ref())
279 |             .and_then(|c| c.unsubscribed_trailer.clone()),
280 |         analytics_account_id: channel.branding_settings
281 |             .as_ref()
282 |             .and_then(|b| b.channel.as_ref())
283 |             .and_then(|c| c.tracking_analytics_account_id.clone()),
284 |         blocked_countries: None,
285 |         conditional_redirect: None,
286 |         no_index: None,
287 |         verification: None
288 |     })
289 | }
290 | 
291 | #[cfg(test)]
292 | mod tests {
293 |     use super::*;
294 |     use std::env;
295 |     
296 |     fn get_api_key() -> String {
297 |         dotenvy::dotenv().ok();
298 |         env::var("API_KEY").expect("API_KEY must be set")
299 |     }
300 | 
301 |     #[tokio::test]
302 |     async fn test_get_channel_by_id() {
303 |         let client = Client::new();
304 |         let result = get_channel(
305 |             &client,
306 |             LookupType::ChannelID("UCBR8-60-B28hp2BmDPdntcQ".to_string()),
307 |             &get_api_key(),
308 |         ).await;
309 | 
310 |         assert!(result.is_ok());
311 |     }
312 | 
313 |     #[tokio::test]
314 |     async fn test_get_channel_by_username() {
315 |         let client = Client::new();
316 |         let result = get_channel(
317 |             &client,
318 |             LookupType::Username("YouTube".to_string()),
319 |             &get_api_key(),
320 |         ).await;
321 | 
322 |         assert!(result.is_ok());
323 |     }
324 | 
325 |     #[tokio::test]
326 |     async fn test_get_channel_by_handle() {
327 |         let client = Client::new();
328 |         let result = get_channel(
329 |             &client,
330 |             LookupType::Handle("TeamYouTube".to_string()),
331 |             &get_api_key(),
332 |         ).await;
333 | 
334 |         assert!(result.is_ok());
335 |     }
336 | }


--------------------------------------------------------------------------------
/src/api/handlers.rs:
--------------------------------------------------------------------------------
  1 | use axum::{
  2 |     routing::{get, post},
  3 |     Router,
  4 |     Json,
  5 |     response::Html,
  6 |     extract::State,
  7 | };
  8 | use std::env;
  9 | use std::sync::Arc;
 10 | use crate::youtube::{channels::{get_channel, LookupType as YTLookupType}, playlist_items::get_playlist_items, subscriptions::get_subscriptions, videos::populate_video_stats};
 11 | use crate::youtubei::{resolve_url::{resolve_url, ResolveUrlResult}, browse::enrich_channel_data};
 12 | use super::types::{AppState, ChannelLookupRequest, ChannelLookupResponse, LookupType, PaginatedRequest, PlaylistItemsResponse, SubscriptionsResponse};
 13 | use super::error::ApiError;
 14 | use crate::errors::YouTubeError;
 15 | 
 16 | const MAX_RESULTS: u32 = 50;
 17 | 
 18 | #[cfg(test)]
 19 | fn get_api_key() -> String {
 20 |     dotenvy::dotenv().ok();
 21 |     env::var("API_KEY").expect("API_KEY must be set")
 22 | }
 23 | 
 24 | #[cfg(not(test))]
 25 | fn get_api_key() -> String {
 26 |     env::var("API_KEY").expect("API_KEY must be set")
 27 | }
 28 | 
 29 | async fn check_channel_status(client: &reqwest::Client, channel_id: &str) -> Result<Json<ChannelLookupResponse>, ApiError> {
 30 |     let api_key = get_api_key();
 31 |     match get_subscriptions(client, channel_id, &api_key, None, 1).await {
 32 |         Err(YouTubeError::AccountTerminated) => {
 33 |             Err(ApiError::NotFound("This channel has been terminated".to_string()))
 34 |         }
 35 |         Err(YouTubeError::AccountClosed) => {
 36 |             Err(ApiError::NotFound("This channel has been deleted".to_string()))
 37 |         }
 38 |         _ => Err(ApiError::NotFound("Channel not found".to_string()))
 39 |     }
 40 | }
 41 | 
 42 | async fn channel_handler(
 43 |     State(state): State<Arc<AppState>>,
 44 |     payload: Result<Json<ChannelLookupRequest>, axum::extract::rejection::JsonRejection>,
 45 | ) -> Result<Json<ChannelLookupResponse>, ApiError> {
 46 |     let Json(payload) = payload.map_err(|e| ApiError::InvalidRequest(e.to_string()))?;
 47 | 
 48 |     let (channel, redirect_url) = match payload.r#type {
 49 |         LookupType::CustomUrl => {
 50 |             // First get channel from +URL
 51 |             let plus_url = format!("youtube.com/+{}", payload.id);
 52 |             let plus_resolve_result = match resolve_url(&state.client, plus_url).await {
 53 |                 Ok(Some(result)) => result,
 54 |                 Ok(None) => return Err(ApiError::NotFound("Custom URL not found".to_string())),
 55 |                 Err(YouTubeError::NotFound) => return Err(ApiError::NotFound("Custom URL not found".to_string())),
 56 |                 Err(e) => return Err(ApiError::YouTubeError(e)),
 57 |             };
 58 | 
 59 |             println!("check: {:?}", plus_resolve_result);
 60 | 
 61 |             let browse_id = match plus_resolve_result {
 62 |                 ResolveUrlResult::BrowseEndpoint { browse_id } => browse_id,
 63 |                 ResolveUrlResult::UrlEndpoint { .. } => {
 64 |                     return Err(ApiError::InvalidRequest("Invalid custom URL - unexpected URL endpoint".to_string()))
 65 |                 }
 66 |             };
 67 | 
 68 |             let api_key = get_api_key();
 69 |             let mut channel = get_channel(
 70 |                 &state.client,
 71 |                 YTLookupType::ChannelID(browse_id),
 72 |                 &api_key,
 73 |             ).await?;
 74 | 
 75 |             // Try to enrich but continue if it fails
 76 |             if let Err(e) = enrich_channel_data(&state.client, &mut channel).await {
 77 |                 eprintln!("Failed to enrich channel data for {}: {:?}", channel.user_id, e);
 78 |             }
 79 | 
 80 |             // Then check non-plus URL for redirect
 81 |             let url = format!("youtube.com/{}", payload.id.to_uppercase());
 82 |             let resolve_result = resolve_url(&state.client, url)
 83 |                 .await
 84 |                 .map_err(|e| ApiError::YouTubeError(e))?;
 85 | 
 86 |             let redirect_url = match resolve_result {
 87 |                 Some(ResolveUrlResult::UrlEndpoint { url }) => Some(url),
 88 |                 _ => None,
 89 |             };
 90 | 
 91 |             (channel, redirect_url)
 92 |         }
 93 |         LookupType::Vanity => {
 94 |             // Get the main vanity URL channel first
 95 |             let url = format!("youtube.com/{}", payload.id.to_uppercase());
 96 |             let resolve_result = resolve_url(&state.client, url)
 97 |                 .await
 98 |                 .map_err(|e| ApiError::YouTubeError(e))?;
 99 | 
100 |             let main_channel_id = match resolve_result {
101 |                 Some(ResolveUrlResult::BrowseEndpoint { browse_id }) => browse_id,
102 |                 _ => return Err(ApiError::NotFound("Invalid vanity URL".to_string())),
103 |             };
104 | 
105 |             // Check +URL, but only error if it points to the same channel
106 |             let plus_url = format!("youtube.com/+{}", payload.id);
107 |             if let Ok(Some(ResolveUrlResult::BrowseEndpoint { browse_id })) = resolve_url(&state.client, plus_url).await {
108 |                 if browse_id == main_channel_id {
109 |                     return Err(ApiError::NotFound("Not a vanity URL".to_string()));
110 |                 }
111 |             }
112 | 
113 |             // Check /user/, but only error if it points to the same channel
114 |             let user_url = format!("youtube.com/user/{}", payload.id);
115 |             if let Ok(Some(ResolveUrlResult::BrowseEndpoint { browse_id })) = resolve_url(&state.client, user_url).await {
116 |                 if browse_id == main_channel_id {
117 |                     return Err(ApiError::NotFound("Not a vanity URL".to_string()));
118 |                 }
119 |             }
120 | 
121 |             // If we get here, it's a valid vanity URL - return the channel
122 |             let api_key = get_api_key();
123 |             let mut channel = get_channel(
124 |                 &state.client,
125 |                 YTLookupType::ChannelID(main_channel_id),
126 |                 &api_key,
127 |             ).await?;
128 | 
129 |             // Try to enrich but continue if it fails
130 |             if let Err(e) = enrich_channel_data(&state.client, &mut channel).await {
131 |                 eprintln!("Failed to enrich channel data for {}: {:?}", channel.user_id, e);
132 |             }
133 | 
134 |             (channel, None)
135 |         }
136 |         LookupType::Username => {
137 |             let api_key = get_api_key();
138 |             let mut channel = get_channel(
139 |                 &state.client,
140 |                 YTLookupType::Username(payload.id.clone()),
141 |                 &api_key,
142 |             ).await?;
143 | 
144 |             // Try to enrich but continue if it fails
145 |             if let Err(e) = enrich_channel_data(&state.client, &mut channel).await {
146 |                 eprintln!("Failed to enrich channel data for {}: {:?}", channel.user_id, e);
147 |             }
148 | 
149 |             let mut redirect_url = None;
150 |             if let Some(handle) = channel.handle.clone() {
151 |                 let url = format!("youtube.com/@{}", handle);
152 |                 let resolve_result = resolve_url(&state.client, url)
153 |                     .await
154 |                     .map_err(|e| ApiError::YouTubeError(e))?;
155 | 
156 |                 redirect_url = match resolve_result {
157 |                     Some(ResolveUrlResult::UrlEndpoint { url }) => Some(url),
158 |                     _ => None,
159 |                 };
160 |             }
161 | 
162 |             (channel, redirect_url)
163 |         }
164 |         LookupType::Handle => {
165 |             let api_key = get_api_key();
166 |             let mut channel = get_channel(
167 |                 &state.client,
168 |                 YTLookupType::Handle(payload.id.clone()),
169 |                 &api_key,
170 |             ).await?;
171 | 
172 |             // Try to enrich but continue if it fails
173 |             if let Err(e) = enrich_channel_data(&state.client, &mut channel).await {
174 |                 eprintln!("Failed to enrich channel data for {}: {:?}", channel.user_id, e);
175 |             }
176 | 
177 |             let mut redirect_url = None;
178 |             if let Some(handle) = channel.handle.clone() {
179 |                 let url = format!("youtube.com/@{}", handle);
180 |                 let resolve_result = resolve_url(&state.client, url)
181 |                     .await
182 |                     .map_err(|e| ApiError::YouTubeError(e))?;
183 | 
184 |                 redirect_url = match resolve_result {
185 |                     Some(ResolveUrlResult::UrlEndpoint { url }) => Some(url),
186 |                     _ => None,
187 |                 };
188 |             }
189 | 
190 |             (channel, redirect_url)
191 |         }
192 |         LookupType::ChannelId => {
193 |             let api_key = get_api_key();
194 |             let channel_result = get_channel(
195 |                 &state.client,
196 |                 YTLookupType::ChannelID(payload.id.clone()),
197 |                 &api_key,
198 |             ).await;
199 | 
200 |             let mut channel = match channel_result {
201 |                 Ok(channel) => channel,
202 |                 Err(YouTubeError::NotFound) => {
203 |                     return check_channel_status(&state.client, &payload.id).await;
204 |                 }
205 |                 Err(e) => return Err(ApiError::YouTubeError(e)),
206 |             };
207 | 
208 |             if let Err(e) = enrich_channel_data(&state.client, &mut channel).await {
209 |                 eprintln!("Failed to enrich channel data for {}: {:?}", channel.user_id, e);
210 |             }
211 | 
212 |             let mut redirect_url = None;
213 |             if let Some(handle) = channel.handle.clone() {
214 |                 let url = format!("youtube.com/@{}", handle);
215 |                 let resolve_result = resolve_url(&state.client, url)
216 |                     .await
217 |                     .map_err(|e| ApiError::YouTubeError(e))?;
218 | 
219 |                 redirect_url = match resolve_result {
220 |                     Some(ResolveUrlResult::UrlEndpoint { url }) => Some(url),
221 |                     _ => None,
222 |                 };
223 |             }
224 | 
225 |             (channel, redirect_url)
226 |         }
227 |     };
228 | 
229 |     Ok(Json(ChannelLookupResponse {
230 |         channel,
231 |         redirect_url,
232 |     }))
233 | }
234 | 
235 | async fn videos_handler(
236 |     State(state): State<Arc<AppState>>,
237 |     payload: Result<Json<PaginatedRequest>, axum::extract::rejection::JsonRejection>,
238 | ) -> Result<Json<PlaylistItemsResponse>, ApiError> {
239 |     let Json(payload) = payload.map_err(|e| ApiError::InvalidRequest(e.to_string()))?;
240 | 
241 |     let api_key = get_api_key();
242 |     
243 |     // First get playlist items
244 |     let (mut items, page_token) = get_playlist_items(
245 |         &state.client,
246 |         &payload.id,
247 |         &api_key,
248 |         payload.page_token.as_deref(),
249 |         MAX_RESULTS,
250 |     ).await?;
251 | 
252 |     // Then populate with video stats
253 |     populate_video_stats(
254 |         &state.client,
255 |         &mut items,
256 |         &api_key,
257 |     ).await?;
258 | 
259 |     Ok(Json(PlaylistItemsResponse {
260 |         items,
261 |         page_token,
262 |     }))
263 | }
264 | 
265 | async fn subscriptions_handler(
266 |     State(state): State<Arc<AppState>>,
267 |     payload: Result<Json<PaginatedRequest>, axum::extract::rejection::JsonRejection>,
268 | ) -> Result<Json<SubscriptionsResponse>, ApiError> {
269 |     let Json(payload) = payload.map_err(|e| ApiError::InvalidRequest(e.to_string()))?;
270 | 
271 |     let api_key = get_api_key();
272 |     let (items, page_token) = get_subscriptions(
273 |         &state.client,
274 |         &payload.id,
275 |         &api_key,
276 |         payload.page_token.as_deref(),
277 |         MAX_RESULTS,
278 |     ).await?;
279 | 
280 |     Ok(Json(SubscriptionsResponse {
281 |         items,
282 |         page_token,
283 |     }))
284 | }
285 | 
286 | async fn index_handler() -> Html<String> {
287 |     let html_content = include_str!("../../static/index.html");
288 |     Html(html_content.to_string())
289 | }
290 | 
291 | pub fn create_router() -> Router {
292 |     let client = reqwest::Client::new();
293 |     let state = Arc::new(AppState { client });
294 | 
295 |     Router::new()
296 |         .route("/", get(index_handler))  // Add this line for serving the HTML
297 |         .route("/api/videos", post(videos_handler))
298 |         .route("/api/subscriptions", post(subscriptions_handler))
299 |         .route("/api/channel", post(channel_handler))
300 |         .with_state(state)
301 | }


--------------------------------------------------------------------------------
/src/youtubei/browse.rs:
--------------------------------------------------------------------------------
  1 | use serde::{Serialize, Deserialize};
  2 | use reqwest::Client;
  3 | use std::collections::HashSet;
  4 | use crate::models::Channel;
  5 | use crate::models::VerificationStatus;
  6 | use crate::errors::YouTubeError;
  7 | 
  8 | const ALL_COUNTRIES: &[&str] = &[
  9 |     "AD", "AE", "AF", "AG", "AI", "AL", "AM", "AO", "AQ", "AR", "AS", "AT", "AU", "AW", "AX", "AZ",
 10 |     "BA", "BB", "BD", "BE", "BF", "BG", "BH", "BI", "BJ", "BL", "BM", "BN", "BO", "BQ", "BR", "BS",
 11 |     "BT", "BV", "BW", "BY", "BZ", "CA", "CC", "CD", "CF", "CG", "CH", "CI", "CK", "CL", "CM", "CN",
 12 |     "CO", "CR", "CU", "CV", "CW", "CX", "CY", "CZ", "DE", "DJ", "DK", "DM", "DO", "DZ", "EC", "EE",
 13 |     "EG", "EH", "ER", "ES", "ET", "FI", "FJ", "FK", "FM", "FO", "FR", "GA", "GB", "GD", "GE", "GF",
 14 |     "GG", "GH", "GI", "GL", "GM", "GN", "GP", "GQ", "GR", "GS", "GT", "GU", "GW", "GY", "HK", "HM",
 15 |     "HN", "HR", "HT", "HU", "ID", "IE", "IL", "IM", "IN", "IO", "IQ", "IR", "IS", "IT", "JE", "JM",
 16 |     "JO", "JP", "KE", "KG", "KH", "KI", "KM", "KN", "KP", "KR", "KW", "KY", "KZ", "LA", "LB", "LC",
 17 |     "LI", "LK", "LR", "LS", "LT", "LU", "LV", "LY", "MA", "MC", "MD", "ME", "MF", "MG", "MH", "MK",
 18 |     "ML", "MM", "MN", "MO", "MP", "MQ", "MR", "MS", "MT", "MU", "MV", "MW", "MX", "MY", "MZ", "NA",
 19 |     "NC", "NE", "NF", "NG", "NI", "NL", "NO", "NP", "NR", "NU", "NZ", "OM", "PA", "PE", "PF", "PG",
 20 |     "PH", "PK", "PL", "PM", "PN", "PR", "PS", "PT", "PW", "PY", "QA", "RE", "RO", "RS", "RU", "RW",
 21 |     "SA", "SB", "SC", "SD", "SE", "SG", "SH", "SI", "SJ", "SK", "SL", "SM", "SN", "SO", "SR", "SS",
 22 |     "ST", "SV", "SX", "SY", "SZ", "TC", "TD", "TF", "TG", "TH", "TJ", "TK", "TL", "TM", "TN", "TO",
 23 |     "TR", "TT", "TV", "TW", "TZ", "UA", "UG", "UM", "US", "UY", "UZ", "VA", "VC", "VE", "VG", "VI",
 24 |     "VN", "VU", "WF", "WS", "YE", "YT", "ZA", "ZM", "ZW"
 25 | ];
 26 | 
 27 | #[derive(Debug, Deserialize, Clone, Serialize)]
 28 | struct InnertubeClient {
 29 |     #[serde(rename = "clientName")]
 30 |     client_name: String,
 31 |     #[serde(rename = "clientVersion")]
 32 |     client_version: String,
 33 | }
 34 | 
 35 | #[derive(Debug, Deserialize, Clone, Serialize)]
 36 | struct InnertubeContext {
 37 |     client: InnertubeClient,
 38 | }
 39 | 
 40 | #[derive(Debug, Deserialize, Clone, Serialize)]
 41 | struct BrowseRequest {
 42 |     context: InnertubeContext,
 43 |     #[serde(rename = "browseId")]
 44 |     browse_id: String,
 45 | }
 46 | 
 47 | #[derive(Debug, Deserialize, Clone)]
 48 | struct ImageSource {
 49 |     #[serde(rename = "clientResource")]
 50 |     client_resource: ClientResource,
 51 | }
 52 | 
 53 | #[derive(Debug, Deserialize, Clone)]
 54 | struct ClientResource {
 55 |     #[serde(rename = "imageName")]
 56 |     image_name: String,
 57 | }
 58 | 
 59 | #[derive(Debug, Deserialize, Clone)]
 60 | struct Image {
 61 |     sources: Vec<ImageSource>,
 62 | }
 63 | 
 64 | #[derive(Debug, Deserialize, Clone)]
 65 | struct ImageType {
 66 |     image: Image,
 67 | }
 68 | 
 69 | #[derive(Debug, Deserialize, Clone)]
 70 | struct ElementType {
 71 |     #[serde(rename = "imageType")]
 72 |     image_type: ImageType,
 73 | }
 74 | 
 75 | #[derive(Debug, Deserialize, Clone)]
 76 | struct Element {
 77 |     r#type: ElementType,
 78 | }
 79 | 
 80 | #[derive(Debug, Deserialize, Clone)]
 81 | struct AttachmentRun {
 82 |     element: Element,
 83 | }
 84 | 
 85 | #[derive(Debug, Deserialize, Clone)]
 86 | struct Text {
 87 |     #[serde(rename = "attachmentRuns")]
 88 |     attachment_runs: Option<Vec<AttachmentRun>>,
 89 | }
 90 | 
 91 | #[derive(Debug, Deserialize, Clone)]
 92 | struct DynamicTextViewModel {
 93 |     text: Text,
 94 | }
 95 | 
 96 | #[derive(Debug, Deserialize, Clone)]
 97 | struct Title {
 98 |     #[serde(rename = "dynamicTextViewModel")]
 99 |     dynamic_text_view_model: DynamicTextViewModel,
100 | }
101 | 
102 | #[derive(Debug, Deserialize, Clone)]
103 | struct PageHeaderViewModel {
104 |     title: Title,
105 | }
106 | 
107 | #[derive(Debug, Deserialize, Clone)]
108 | struct Content {
109 |     #[serde(rename = "pageHeaderViewModel")]
110 |     page_header_view_model: PageHeaderViewModel,
111 | }
112 | 
113 | #[derive(Debug, Deserialize, Clone)]
114 | struct PageHeaderRenderer {
115 |     content: Content,
116 | }
117 | 
118 | #[derive(Debug, Deserialize, Clone)]
119 | struct Header {
120 |     #[serde(rename = "pageHeaderRenderer")]
121 |     page_header_renderer: PageHeaderRenderer,
122 | }
123 | 
124 | #[derive(Debug, Deserialize, Clone)]
125 | struct BrowseEndpoint {
126 |     #[serde(rename = "browseId")]
127 |     browse_id: String,
128 | }
129 | 
130 | #[derive(Debug, Deserialize, Clone)]
131 | struct Endpoint {
132 |     #[serde(rename = "browseEndpoint")]
133 |     browse_endpoint: BrowseEndpoint,
134 | }
135 | 
136 | #[derive(Debug, Deserialize, Clone)]
137 | struct NavigateAction {
138 |     endpoint: Endpoint,
139 | }
140 | 
141 | #[derive(Debug, Deserialize, Clone)]
142 | struct OnResponseReceivedAction {
143 |     #[serde(rename = "navigateAction")]
144 |     navigate_action: NavigateAction,
145 | }
146 | 
147 | #[derive(Debug, Deserialize, Clone)]
148 | struct MicroformatDataRenderer {
149 |     noindex: Option<bool>,
150 |     #[serde(rename = "availableCountries")]
151 |     available_countries: Option<Vec<String>>
152 | }
153 | 
154 | #[derive(Debug, Deserialize, Clone)]
155 | struct Microformat {
156 |     #[serde(rename = "microformatDataRenderer")]
157 |     microformat_data_renderer: MicroformatDataRenderer,
158 | }
159 | 
160 | #[derive(Debug, Deserialize, Clone)]
161 | struct ChannelMetadataRenderer {
162 |     #[serde(rename = "ownerUrls")]
163 |     owner_urls: Option<Vec<String>>,
164 | }
165 | 
166 | #[derive(Debug, Deserialize, Clone)]
167 | struct Metadata {
168 |     #[serde(rename = "channelMetadataRenderer")]
169 |     channel_metadata_renderer: ChannelMetadataRenderer,
170 | }
171 | 
172 | #[derive(Debug, Deserialize, Clone)]
173 | struct BrowseResponse {
174 |     header: Option<Header>,
175 |     #[serde(rename = "onResponseReceivedActions")]
176 |     on_response_received_actions: Option<Vec<OnResponseReceivedAction>>,
177 |     microformat: Option<Microformat>,
178 |     metadata: Option<Metadata>,
179 | }
180 | 
181 | pub async fn enrich_channel_data(
182 |     client: &Client,
183 |     channel: &mut Channel,
184 | ) -> Result<(), YouTubeError> {
185 |     let request = BrowseRequest {
186 |         context: InnertubeContext {
187 |             client: InnertubeClient {
188 |                 client_name: "WEB".to_string(),
189 |                 client_version: "2.20250108.06.00".to_string(),
190 |             },
191 |         },
192 |         browse_id: channel.user_id.clone(),
193 |     };
194 | 
195 |     let resp = client
196 |         .post("https://www.youtube.com/youtubei/v1/browse?prettyPrint=false")
197 |         .header("Host", "www.youtube.com")
198 |         .header("Content-Type", "application/json")
199 |         .header("X-Goog-Fieldmask", "onResponseReceivedActions.navigateAction.endpoint.browseEndpoint.browseId,header.pageHeaderRenderer.content.pageHeaderViewModel.title.dynamicTextViewModel.text.attachmentRuns.element.type.imageType.image.sources.clientResource.imageName,metadata.channelMetadataRenderer.ownerUrls,microformat.microformatDataRenderer(noindex,availableCountries)")
200 |         .json(&request)
201 |         .send()
202 |         .await
203 |         .map_err(|e| YouTubeError::Other(Box::new(e)))?;
204 | 
205 |     match resp.status() {
206 |         reqwest::StatusCode::OK => {
207 |             let response: BrowseResponse = resp
208 |                 .json()
209 |                 .await
210 |                 .map_err(|e| YouTubeError::ParseError(e.to_string()))?;
211 | 
212 |             // Handle conditional redirect
213 |             if let Some(actions) = response.on_response_received_actions {
214 |                 if let Some(action) = actions.first() {
215 |                     let redirect_id = action.navigate_action.endpoint.browse_endpoint.browse_id.clone();
216 |                     if redirect_id != channel.user_id {
217 |                         channel.conditional_redirect = Some(redirect_id);
218 |                         return Ok(());
219 |                     }
220 |                 }
221 |             }
222 | 
223 |             // Parse verification status from badge
224 |             if let Some(header) = response.header {
225 |                 let badge = header
226 |                     .page_header_renderer
227 |                     .content
228 |                     .page_header_view_model
229 |                     .title
230 |                     .dynamic_text_view_model
231 |                     .text
232 |                     .attachment_runs
233 |                     .and_then(|runs| runs.first().cloned())
234 |                     .map(|run| run.element.r#type.image_type.image.sources[0].client_resource.image_name.clone());
235 | 
236 |                 channel.verification = Some(match badge.as_deref() {
237 |                     Some("AUDIO_BADGE") => VerificationStatus::OAC,
238 |                     Some("CHECK_CIRCLE_FILLED") => VerificationStatus::Verified,
239 |                     _ => VerificationStatus::None,
240 |                 });
241 |             }
242 | 
243 |             // Parse microformat data
244 |             if let Some(microformat) = response.microformat {
245 |                 channel.no_index = microformat.microformat_data_renderer.noindex;
246 |                 
247 |                 // Handle available countries
248 |                 if let Some(available) = microformat.microformat_data_renderer.available_countries {
249 |                     let available: HashSet<_> = available.iter().cloned().collect();
250 |                     let all: HashSet<_> = ALL_COUNTRIES.iter().map(|&s| s.to_string()).collect();
251 |                     
252 |                     // Countries that are not in the available list are blocked
253 |                     let blocked: Vec<_> = all.difference(&available).cloned().collect();
254 |                     channel.blocked_countries = if blocked.is_empty() { None } else { Some(blocked) };
255 |                 }
256 |             }
257 | 
258 |             if let Some(metadata) = &response.metadata {
259 |                 if let Some(owner_urls) = &metadata.channel_metadata_renderer.owner_urls {
260 |                     for url in owner_urls {
261 |                         if let Some(handle) = url.strip_prefix("http://www.youtube.com/@") {
262 |                             channel.handle = Some(handle.to_string());
263 |                             break;
264 |                         }
265 |                     }
266 |                 }
267 |             }
268 | 
269 |             Ok(())
270 |         }
271 |         status => {
272 |             eprintln!("Unexpected status code: {}", status);
273 |             Err(YouTubeError::UnknownStatusCode(status))
274 |         }
275 |     }
276 | }
277 | 
278 | #[cfg(test)]
279 | mod tests {
280 |     use super::*;
281 |     use reqwest::Client;
282 |     use crate::models::Channel;
283 |     
284 |     #[tokio::test]
285 |     async fn test_channel_with_blocked_us() {
286 |         let client = Client::new();
287 |         let mut channel = Channel {
288 |             user_id: "UC7A4ikI7Q4Efju5WNRdIqyg".to_string(),
289 |             display_name: None,
290 |             description: None,
291 |             handle: None,
292 |             profile_picture: None,
293 |             banner: None,
294 |             created_at: 0,
295 |             country: None,
296 |             view_count: 0,
297 |             subscriber_count: 0,
298 |             video_count: 0,
299 |             made_for_kids: false,
300 |             keywords: None,
301 |             trailer: None,
302 |             analytics_account_id: None,
303 |             conditional_redirect: None,
304 |             no_index: None,
305 |             verification: None,
306 |             blocked_countries: None,
307 |         };
308 | 
309 |         let result = enrich_channel_data(&client, &mut channel).await;
310 |         assert!(result.is_ok());
311 |         
312 |         assert_eq!(channel.verification, Some(VerificationStatus::None));
313 |         assert_eq!(channel.conditional_redirect, None);
314 |         assert_eq!(channel.no_index, Some(false));
315 |         
316 |         // Check that US is in blocked countries
317 |         if let Some(blocked) = channel.blocked_countries {
318 |             assert!(blocked.contains(&"US".to_string()));
319 |         } else {
320 |             panic!("Blocked countries should be populated");
321 |         }
322 |     }
323 | 
324 |     #[tokio::test]
325 |     async fn test_verified_channel() {
326 |         let client = Client::new();
327 |         let mut channel = Channel {
328 |             user_id: "UCewMTclBJZPaNEfbf-qYMGA".to_string(),
329 |             display_name: None,
330 |             description: None,
331 |             handle: None,
332 |             profile_picture: None,
333 |             banner: None,
334 |             created_at: 0,
335 |             country: None,
336 |             view_count: 0,
337 |             subscriber_count: 0,
338 |             video_count: 0,
339 |             made_for_kids: false,
340 |             keywords: None,
341 |             trailer: None,
342 |             analytics_account_id: None,
343 |             conditional_redirect: None,
344 |             no_index: None,
345 |             verification: None,
346 |             blocked_countries: None,
347 |         };
348 | 
349 |         let result = enrich_channel_data(&client, &mut channel).await;
350 |         assert!(result.is_ok());
351 |         
352 |         assert_eq!(channel.verification, Some(VerificationStatus::Verified));
353 |         assert_eq!(channel.conditional_redirect, None);
354 |         assert_eq!(channel.no_index, Some(false));
355 |     }
356 | 
357 |     #[tokio::test]
358 |     async fn test_artist_channel() {
359 |         let client = Client::new();
360 |         let mut channel = Channel {
361 |             user_id: "UCsRM0YB_dabtEPGPTKo-gcw".to_string(),
362 |             display_name: None,
363 |             description: None,
364 |             handle: None,
365 |             profile_picture: None,
366 |             banner: None,
367 |             created_at: 0,
368 |             country: None,
369 |             view_count: 0,
370 |             subscriber_count: 0,
371 |             video_count: 0,
372 |             made_for_kids: false,
373 |             keywords: None,
374 |             trailer: None,
375 |             analytics_account_id: None,
376 |             conditional_redirect: None,
377 |             no_index: None,
378 |             verification: None,
379 |             blocked_countries: None,
380 |         };
381 | 
382 |         let result = enrich_channel_data(&client, &mut channel).await;
383 |         assert!(result.is_ok());
384 |         
385 |         assert_eq!(channel.verification, Some(VerificationStatus::OAC));
386 |         assert_eq!(channel.conditional_redirect, None);
387 |         assert_eq!(channel.no_index, Some(false));
388 |     }
389 | 
390 |     #[tokio::test]
391 |     async fn test_channel_with_redirect() {
392 |         let client = Client::new();
393 |         let mut channel = Channel {
394 |             user_id: "UC80zzW0g4xuUwW6IffjhcDQ".to_string(),
395 |             display_name: None,
396 |             description: None,
397 |             handle: None,
398 |             profile_picture: None,
399 |             banner: None,
400 |             created_at: 0,
401 |             country: None,
402 |             view_count: 0,
403 |             subscriber_count: 0,
404 |             video_count: 0,
405 |             made_for_kids: false,
406 |             keywords: None,
407 |             trailer: None,
408 |             analytics_account_id: None,
409 |             conditional_redirect: None,
410 |             no_index: None,
411 |             verification: None,
412 |             blocked_countries: None,
413 |         };
414 | 
415 |         let result = enrich_channel_data(&client, &mut channel).await;
416 |         assert!(result.is_ok());
417 |         
418 |         assert!(channel.conditional_redirect.is_some());
419 |     }
420 | 
421 |     #[tokio::test]
422 |     async fn test_channel_with_noindex() {
423 |         let client = Client::new();
424 |         let mut channel = Channel {
425 |             user_id: "UC-8U_MhAZnBXKZvI5kMllLA".to_string(),
426 |             display_name: None,
427 |             description: None,
428 |             handle: None,
429 |             profile_picture: None,
430 |             banner: None,
431 |             created_at: 0,
432 |             country: None,
433 |             view_count: 0,
434 |             subscriber_count: 0,
435 |             video_count: 0,
436 |             made_for_kids: false,
437 |             keywords: None,
438 |             trailer: None,
439 |             analytics_account_id: None,
440 |             conditional_redirect: None,
441 |             no_index: None,
442 |             verification: None,
443 |             blocked_countries: None,
444 |         };
445 | 
446 |         let result = enrich_channel_data(&client, &mut channel).await;
447 |         assert!(result.is_ok());
448 |         
449 |         assert_eq!(channel.no_index, Some(true));
450 |     }
451 | }


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
  1 |                     GNU AFFERO GENERAL PUBLIC LICENSE
  2 |                        Version 3, 19 November 2007
  3 | 
  4 |  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
  5 |  Everyone is permitted to copy and distribute verbatim copies
  6 |  of this license document, but changing it is not allowed.
  7 | 
  8 |                             Preamble
  9 | 
 10 |   The GNU Affero General Public License is a free, copyleft license for
 11 | software and other kinds of works, specifically designed to ensure
 12 | cooperation with the community in the case of network server software.
 13 | 
 14 |   The licenses for most software and other practical works are designed
 15 | to take away your freedom to share and change the works.  By contrast,
 16 | our General Public Licenses are intended to guarantee your freedom to
 17 | share and change all versions of a program--to make sure it remains free
 18 | software for all its users.
 19 | 
 20 |   When we speak of free software, we are referring to freedom, not
 21 | price.  Our General Public Licenses are designed to make sure that you
 22 | have the freedom to distribute copies of free software (and charge for
 23 | them if you wish), that you receive source code or can get it if you
 24 | want it, that you can change the software or use pieces of it in new
 25 | free programs, and that you know you can do these things.
 26 | 
 27 |   Developers that use our General Public Licenses protect your rights
 28 | with two steps: (1) assert copyright on the software, and (2) offer
 29 | you this License which gives you legal permission to copy, distribute
 30 | and/or modify the software.
 31 | 
 32 |   A secondary benefit of defending all users' freedom is that
 33 | improvements made in alternate versions of the program, if they
 34 | receive widespread use, become available for other developers to
 35 | incorporate.  Many developers of free software are heartened and
 36 | encouraged by the resulting cooperation.  However, in the case of
 37 | software used on network servers, this result may fail to come about.
 38 | The GNU General Public License permits making a modified version and
 39 | letting the public access it on a server without ever releasing its
 40 | source code to the public.
 41 | 
 42 |   The GNU Affero General Public License is designed specifically to
 43 | ensure that, in such cases, the modified source code becomes available
 44 | to the community.  It requires the operator of a network server to
 45 | provide the source code of the modified version running there to the
 46 | users of that server.  Therefore, public use of a modified version, on
 47 | a publicly accessible server, gives the public access to the source
 48 | code of the modified version.
 49 | 
 50 |   An older license, called the Affero General Public License and
 51 | published by Affero, was designed to accomplish similar goals.  This is
 52 | a different license, not a version of the Affero GPL, but Affero has
 53 | released a new version of the Affero GPL which permits relicensing under
 54 | this license.
 55 | 
 56 |   The precise terms and conditions for copying, distribution and
 57 | modification follow.
 58 | 
 59 |                        TERMS AND CONDITIONS
 60 | 
 61 |   0. Definitions.
 62 | 
 63 |   "This License" refers to version 3 of the GNU Affero General Public License.
 64 | 
 65 |   "Copyright" also means copyright-like laws that apply to other kinds of
 66 | works, such as semiconductor masks.
 67 | 
 68 |   "The Program" refers to any copyrightable work licensed under this
 69 | License.  Each licensee is addressed as "you".  "Licensees" and
 70 | "recipients" may be individuals or organizations.
 71 | 
 72 |   To "modify" a work means to copy from or adapt all or part of the work
 73 | in a fashion requiring copyright permission, other than the making of an
 74 | exact copy.  The resulting work is called a "modified version" of the
 75 | earlier work or a work "based on" the earlier work.
 76 | 
 77 |   A "covered work" means either the unmodified Program or a work based
 78 | on the Program.
 79 | 
 80 |   To "propagate" a work means to do anything with it that, without
 81 | permission, would make you directly or secondarily liable for
 82 | infringement under applicable copyright law, except executing it on a
 83 | computer or modifying a private copy.  Propagation includes copying,
 84 | distribution (with or without modification), making available to the
 85 | public, and in some countries other activities as well.
 86 | 
 87 |   To "convey" a work means any kind of propagation that enables other
 88 | parties to make or receive copies.  Mere interaction with a user through
 89 | a computer network, with no transfer of a copy, is not conveying.
 90 | 
 91 |   An interactive user interface displays "Appropriate Legal Notices"
 92 | to the extent that it includes a convenient and prominently visible
 93 | feature that (1) displays an appropriate copyright notice, and (2)
 94 | tells the user that there is no warranty for the work (except to the
 95 | extent that warranties are provided), that licensees may convey the
 96 | work under this License, and how to view a copy of this License.  If
 97 | the interface presents a list of user commands or options, such as a
 98 | menu, a prominent item in the list meets this criterion.
 99 | 
100 |   1. Source Code.
101 | 
102 |   The "source code" for a work means the preferred form of the work
103 | for making modifications to it.  "Object code" means any non-source
104 | form of a work.
105 | 
106 |   A "Standard Interface" means an interface that either is an official
107 | standard defined by a recognized standards body, or, in the case of
108 | interfaces specified for a particular programming language, one that
109 | is widely used among developers working in that language.
110 | 
111 |   The "System Libraries" of an executable work include anything, other
112 | than the work as a whole, that (a) is included in the normal form of
113 | packaging a Major Component, but which is not part of that Major
114 | Component, and (b) serves only to enable use of the work with that
115 | Major Component, or to implement a Standard Interface for which an
116 | implementation is available to the public in source code form.  A
117 | "Major Component", in this context, means a major essential component
118 | (kernel, window system, and so on) of the specific operating system
119 | (if any) on which the executable work runs, or a compiler used to
120 | produce the work, or an object code interpreter used to run it.
121 | 
122 |   The "Corresponding Source" for a work in object code form means all
123 | the source code needed to generate, install, and (for an executable
124 | work) run the object code and to modify the work, including scripts to
125 | control those activities.  However, it does not include the work's
126 | System Libraries, or general-purpose tools or generally available free
127 | programs which are used unmodified in performing those activities but
128 | which are not part of the work.  For example, Corresponding Source
129 | includes interface definition files associated with source files for
130 | the work, and the source code for shared libraries and dynamically
131 | linked subprograms that the work is specifically designed to require,
132 | such as by intimate data communication or control flow between those
133 | subprograms and other parts of the work.
134 | 
135 |   The Corresponding Source need not include anything that users
136 | can regenerate automatically from other parts of the Corresponding
137 | Source.
138 | 
139 |   The Corresponding Source for a work in source code form is that
140 | same work.
141 | 
142 |   2. Basic Permissions.
143 | 
144 |   All rights granted under this License are granted for the term of
145 | copyright on the Program, and are irrevocable provided the stated
146 | conditions are met.  This License explicitly affirms your unlimited
147 | permission to run the unmodified Program.  The output from running a
148 | covered work is covered by this License only if the output, given its
149 | content, constitutes a covered work.  This License acknowledges your
150 | rights of fair use or other equivalent, as provided by copyright law.
151 | 
152 |   You may make, run and propagate covered works that you do not
153 | convey, without conditions so long as your license otherwise remains
154 | in force.  You may convey covered works to others for the sole purpose
155 | of having them make modifications exclusively for you, or provide you
156 | with facilities for running those works, provided that you comply with
157 | the terms of this License in conveying all material for which you do
158 | not control copyright.  Those thus making or running the covered works
159 | for you must do so exclusively on your behalf, under your direction
160 | and control, on terms that prohibit them from making any copies of
161 | your copyrighted material outside their relationship with you.
162 | 
163 |   Conveying under any other circumstances is permitted solely under
164 | the conditions stated below.  Sublicensing is not allowed; section 10
165 | makes it unnecessary.
166 | 
167 |   3. Protecting Users' Legal Rights From Anti-Circumvention Law.
168 | 
169 |   No covered work shall be deemed part of an effective technological
170 | measure under any applicable law fulfilling obligations under article
171 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or
172 | similar laws prohibiting or restricting circumvention of such
173 | measures.
174 | 
175 |   When you convey a covered work, you waive any legal power to forbid
176 | circumvention of technological measures to the extent such circumvention
177 | is effected by exercising rights under this License with respect to
178 | the covered work, and you disclaim any intention to limit operation or
179 | modification of the work as a means of enforcing, against the work's
180 | users, your or third parties' legal rights to forbid circumvention of
181 | technological measures.
182 | 
183 |   4. Conveying Verbatim Copies.
184 | 
185 |   You may convey verbatim copies of the Program's source code as you
186 | receive it, in any medium, provided that you conspicuously and
187 | appropriately publish on each copy an appropriate copyright notice;
188 | keep intact all notices stating that this License and any
189 | non-permissive terms added in accord with section 7 apply to the code;
190 | keep intact all notices of the absence of any warranty; and give all
191 | recipients a copy of this License along with the Program.
192 | 
193 |   You may charge any price or no price for each copy that you convey,
194 | and you may offer support or warranty protection for a fee.
195 | 
196 |   5. Conveying Modified Source Versions.
197 | 
198 |   You may convey a work based on the Program, or the modifications to
199 | produce it from the Program, in the form of source code under the
200 | terms of section 4, provided that you also meet all of these conditions:
201 | 
202 |     a) The work must carry prominent notices stating that you modified
203 |     it, and giving a relevant date.
204 | 
205 |     b) The work must carry prominent notices stating that it is
206 |     released under this License and any conditions added under section
207 |     7.  This requirement modifies the requirement in section 4 to
208 |     "keep intact all notices".
209 | 
210 |     c) You must license the entire work, as a whole, under this
211 |     License to anyone who comes into possession of a copy.  This
212 |     License will therefore apply, along with any applicable section 7
213 |     additional terms, to the whole of the work, and all its parts,
214 |     regardless of how they are packaged.  This License gives no
215 |     permission to license the work in any other way, but it does not
216 |     invalidate such permission if you have separately received it.
217 | 
218 |     d) If the work has interactive user interfaces, each must display
219 |     Appropriate Legal Notices; however, if the Program has interactive
220 |     interfaces that do not display Appropriate Legal Notices, your
221 |     work need not make them do so.
222 | 
223 |   A compilation of a covered work with other separate and independent
224 | works, which are not by their nature extensions of the covered work,
225 | and which are not combined with it such as to form a larger program,
226 | in or on a volume of a storage or distribution medium, is called an
227 | "aggregate" if the compilation and its resulting copyright are not
228 | used to limit the access or legal rights of the compilation's users
229 | beyond what the individual works permit.  Inclusion of a covered work
230 | in an aggregate does not cause this License to apply to the other
231 | parts of the aggregate.
232 | 
233 |   6. Conveying Non-Source Forms.
234 | 
235 |   You may convey a covered work in object code form under the terms
236 | of sections 4 and 5, provided that you also convey the
237 | machine-readable Corresponding Source under the terms of this License,
238 | in one of these ways:
239 | 
240 |     a) Convey the object code in, or embodied in, a physical product
241 |     (including a physical distribution medium), accompanied by the
242 |     Corresponding Source fixed on a durable physical medium
243 |     customarily used for software interchange.
244 | 
245 |     b) Convey the object code in, or embodied in, a physical product
246 |     (including a physical distribution medium), accompanied by a
247 |     written offer, valid for at least three years and valid for as
248 |     long as you offer spare parts or customer support for that product
249 |     model, to give anyone who possesses the object code either (1) a
250 |     copy of the Corresponding Source for all the software in the
251 |     product that is covered by this License, on a durable physical
252 |     medium customarily used for software interchange, for a price no
253 |     more than your reasonable cost of physically performing this
254 |     conveying of source, or (2) access to copy the
255 |     Corresponding Source from a network server at no charge.
256 | 
257 |     c) Convey individual copies of the object code with a copy of the
258 |     written offer to provide the Corresponding Source.  This
259 |     alternative is allowed only occasionally and noncommercially, and
260 |     only if you received the object code with such an offer, in accord
261 |     with subsection 6b.
262 | 
263 |     d) Convey the object code by offering access from a designated
264 |     place (gratis or for a charge), and offer equivalent access to the
265 |     Corresponding Source in the same way through the same place at no
266 |     further charge.  You need not require recipients to copy the
267 |     Corresponding Source along with the object code.  If the place to
268 |     copy the object code is a network server, the Corresponding Source
269 |     may be on a different server (operated by you or a third party)
270 |     that supports equivalent copying facilities, provided you maintain
271 |     clear directions next to the object code saying where to find the
272 |     Corresponding Source.  Regardless of what server hosts the
273 |     Corresponding Source, you remain obligated to ensure that it is
274 |     available for as long as needed to satisfy these requirements.
275 | 
276 |     e) Convey the object code using peer-to-peer transmission, provided
277 |     you inform other peers where the object code and Corresponding
278 |     Source of the work are being offered to the general public at no
279 |     charge under subsection 6d.
280 | 
281 |   A separable portion of the object code, whose source code is excluded
282 | from the Corresponding Source as a System Library, need not be
283 | included in conveying the object code work.
284 | 
285 |   A "User Product" is either (1) a "consumer product", which means any
286 | tangible personal property which is normally used for personal, family,
287 | or household purposes, or (2) anything designed or sold for incorporation
288 | into a dwelling.  In determining whether a product is a consumer product,
289 | doubtful cases shall be resolved in favor of coverage.  For a particular
290 | product received by a particular user, "normally used" refers to a
291 | typical or common use of that class of product, regardless of the status
292 | of the particular user or of the way in which the particular user
293 | actually uses, or expects or is expected to use, the product.  A product
294 | is a consumer product regardless of whether the product has substantial
295 | commercial, industrial or non-consumer uses, unless such uses represent
296 | the only significant mode of use of the product.
297 | 
298 |   "Installation Information" for a User Product means any methods,
299 | procedures, authorization keys, or other information required to install
300 | and execute modified versions of a covered work in that User Product from
301 | a modified version of its Corresponding Source.  The information must
302 | suffice to ensure that the continued functioning of the modified object
303 | code is in no case prevented or interfered with solely because
304 | modification has been made.
305 | 
306 |   If you convey an object code work under this section in, or with, or
307 | specifically for use in, a User Product, and the conveying occurs as
308 | part of a transaction in which the right of possession and use of the
309 | User Product is transferred to the recipient in perpetuity or for a
310 | fixed term (regardless of how the transaction is characterized), the
311 | Corresponding Source conveyed under this section must be accompanied
312 | by the Installation Information.  But this requirement does not apply
313 | if neither you nor any third party retains the ability to install
314 | modified object code on the User Product (for example, the work has
315 | been installed in ROM).
316 | 
317 |   The requirement to provide Installation Information does not include a
318 | requirement to continue to provide support service, warranty, or updates
319 | for a work that has been modified or installed by the recipient, or for
320 | the User Product in which it has been modified or installed.  Access to a
321 | network may be denied when the modification itself materially and
322 | adversely affects the operation of the network or violates the rules and
323 | protocols for communication across the network.
324 | 
325 |   Corresponding Source conveyed, and Installation Information provided,
326 | in accord with this section must be in a format that is publicly
327 | documented (and with an implementation available to the public in
328 | source code form), and must require no special password or key for
329 | unpacking, reading or copying.
330 | 
331 |   7. Additional Terms.
332 | 
333 |   "Additional permissions" are terms that supplement the terms of this
334 | License by making exceptions from one or more of its conditions.
335 | Additional permissions that are applicable to the entire Program shall
336 | be treated as though they were included in this License, to the extent
337 | that they are valid under applicable law.  If additional permissions
338 | apply only to part of the Program, that part may be used separately
339 | under those permissions, but the entire Program remains governed by
340 | this License without regard to the additional permissions.
341 | 
342 |   When you convey a copy of a covered work, you may at your option
343 | remove any additional permissions from that copy, or from any part of
344 | it.  (Additional permissions may be written to require their own
345 | removal in certain cases when you modify the work.)  You may place
346 | additional permissions on material, added by you to a covered work,
347 | for which you have or can give appropriate copyright permission.
348 | 
349 |   Notwithstanding any other provision of this License, for material you
350 | add to a covered work, you may (if authorized by the copyright holders of
351 | that material) supplement the terms of this License with terms:
352 | 
353 |     a) Disclaiming warranty or limiting liability differently from the
354 |     terms of sections 15 and 16 of this License; or
355 | 
356 |     b) Requiring preservation of specified reasonable legal notices or
357 |     author attributions in that material or in the Appropriate Legal
358 |     Notices displayed by works containing it; or
359 | 
360 |     c) Prohibiting misrepresentation of the origin of that material, or
361 |     requiring that modified versions of such material be marked in
362 |     reasonable ways as different from the original version; or
363 | 
364 |     d) Limiting the use for publicity purposes of names of licensors or
365 |     authors of the material; or
366 | 
367 |     e) Declining to grant rights under trademark law for use of some
368 |     trade names, trademarks, or service marks; or
369 | 
370 |     f) Requiring indemnification of licensors and authors of that
371 |     material by anyone who conveys the material (or modified versions of
372 |     it) with contractual assumptions of liability to the recipient, for
373 |     any liability that these contractual assumptions directly impose on
374 |     those licensors and authors.
375 | 
376 |   All other non-permissive additional terms are considered "further
377 | restrictions" within the meaning of section 10.  If the Program as you
378 | received it, or any part of it, contains a notice stating that it is
379 | governed by this License along with a term that is a further
380 | restriction, you may remove that term.  If a license document contains
381 | a further restriction but permits relicensing or conveying under this
382 | License, you may add to a covered work material governed by the terms
383 | of that license document, provided that the further restriction does
384 | not survive such relicensing or conveying.
385 | 
386 |   If you add terms to a covered work in accord with this section, you
387 | must place, in the relevant source files, a statement of the
388 | additional terms that apply to those files, or a notice indicating
389 | where to find the applicable terms.
390 | 
391 |   Additional terms, permissive or non-permissive, may be stated in the
392 | form of a separately written license, or stated as exceptions;
393 | the above requirements apply either way.
394 | 
395 |   8. Termination.
396 | 
397 |   You may not propagate or modify a covered work except as expressly
398 | provided under this License.  Any attempt otherwise to propagate or
399 | modify it is void, and will automatically terminate your rights under
400 | this License (including any patent licenses granted under the third
401 | paragraph of section 11).
402 | 
403 |   However, if you cease all violation of this License, then your
404 | license from a particular copyright holder is reinstated (a)
405 | provisionally, unless and until the copyright holder explicitly and
406 | finally terminates your license, and (b) permanently, if the copyright
407 | holder fails to notify you of the violation by some reasonable means
408 | prior to 60 days after the cessation.
409 | 
410 |   Moreover, your license from a particular copyright holder is
411 | reinstated permanently if the copyright holder notifies you of the
412 | violation by some reasonable means, this is the first time you have
413 | received notice of violation of this License (for any work) from that
414 | copyright holder, and you cure the violation prior to 30 days after
415 | your receipt of the notice.
416 | 
417 |   Termination of your rights under this section does not terminate the
418 | licenses of parties who have received copies or rights from you under
419 | this License.  If your rights have been terminated and not permanently
420 | reinstated, you do not qualify to receive new licenses for the same
421 | material under section 10.
422 | 
423 |   9. Acceptance Not Required for Having Copies.
424 | 
425 |   You are not required to accept this License in order to receive or
426 | run a copy of the Program.  Ancillary propagation of a covered work
427 | occurring solely as a consequence of using peer-to-peer transmission
428 | to receive a copy likewise does not require acceptance.  However,
429 | nothing other than this License grants you permission to propagate or
430 | modify any covered work.  These actions infringe copyright if you do
431 | not accept this License.  Therefore, by modifying or propagating a
432 | covered work, you indicate your acceptance of this License to do so.
433 | 
434 |   10. Automatic Licensing of Downstream Recipients.
435 | 
436 |   Each time you convey a covered work, the recipient automatically
437 | receives a license from the original licensors, to run, modify and
438 | propagate that work, subject to this License.  You are not responsible
439 | for enforcing compliance by third parties with this License.
440 | 
441 |   An "entity transaction" is a transaction transferring control of an
442 | organization, or substantially all assets of one, or subdividing an
443 | organization, or merging organizations.  If propagation of a covered
444 | work results from an entity transaction, each party to that
445 | transaction who receives a copy of the work also receives whatever
446 | licenses to the work the party's predecessor in interest had or could
447 | give under the previous paragraph, plus a right to possession of the
448 | Corresponding Source of the work from the predecessor in interest, if
449 | the predecessor has it or can get it with reasonable efforts.
450 | 
451 |   You may not impose any further restrictions on the exercise of the
452 | rights granted or affirmed under this License.  For example, you may
453 | not impose a license fee, royalty, or other charge for exercise of
454 | rights granted under this License, and you may not initiate litigation
455 | (including a cross-claim or counterclaim in a lawsuit) alleging that
456 | any patent claim is infringed by making, using, selling, offering for
457 | sale, or importing the Program or any portion of it.
458 | 
459 |   11. Patents.
460 | 
461 |   A "contributor" is a copyright holder who authorizes use under this
462 | License of the Program or a work on which the Program is based.  The
463 | work thus licensed is called the contributor's "contributor version".
464 | 
465 |   A contributor's "essential patent claims" are all patent claims
466 | owned or controlled by the contributor, whether already acquired or
467 | hereafter acquired, that would be infringed by some manner, permitted
468 | by this License, of making, using, or selling its contributor version,
469 | but do not include claims that would be infringed only as a
470 | consequence of further modification of the contributor version.  For
471 | purposes of this definition, "control" includes the right to grant
472 | patent sublicenses in a manner consistent with the requirements of
473 | this License.
474 | 
475 |   Each contributor grants you a non-exclusive, worldwide, royalty-free
476 | patent license under the contributor's essential patent claims, to
477 | make, use, sell, offer for sale, import and otherwise run, modify and
478 | propagate the contents of its contributor version.
479 | 
480 |   In the following three paragraphs, a "patent license" is any express
481 | agreement or commitment, however denominated, not to enforce a patent
482 | (such as an express permission to practice a patent or covenant not to
483 | sue for patent infringement).  To "grant" such a patent license to a
484 | party means to make such an agreement or commitment not to enforce a
485 | patent against the party.
486 | 
487 |   If you convey a covered work, knowingly relying on a patent license,
488 | and the Corresponding Source of the work is not available for anyone
489 | to copy, free of charge and under the terms of this License, through a
490 | publicly available network server or other readily accessible means,
491 | then you must either (1) cause the Corresponding Source to be so
492 | available, or (2) arrange to deprive yourself of the benefit of the
493 | patent license for this particular work, or (3) arrange, in a manner
494 | consistent with the requirements of this License, to extend the patent
495 | license to downstream recipients.  "Knowingly relying" means you have
496 | actual knowledge that, but for the patent license, your conveying the
497 | covered work in a country, or your recipient's use of the covered work
498 | in a country, would infringe one or more identifiable patents in that
499 | country that you have reason to believe are valid.
500 | 
501 |   If, pursuant to or in connection with a single transaction or
502 | arrangement, you convey, or propagate by procuring conveyance of, a
503 | covered work, and grant a patent license to some of the parties
504 | receiving the covered work authorizing them to use, propagate, modify
505 | or convey a specific copy of the covered work, then the patent license
506 | you grant is automatically extended to all recipients of the covered
507 | work and works based on it.
508 | 
509 |   A patent license is "discriminatory" if it does not include within
510 | the scope of its coverage, prohibits the exercise of, or is
511 | conditioned on the non-exercise of one or more of the rights that are
512 | specifically granted under this License.  You may not convey a covered
513 | work if you are a party to an arrangement with a third party that is
514 | in the business of distributing software, under which you make payment
515 | to the third party based on the extent of your activity of conveying
516 | the work, and under which the third party grants, to any of the
517 | parties who would receive the covered work from you, a discriminatory
518 | patent license (a) in connection with copies of the covered work
519 | conveyed by you (or copies made from those copies), or (b) primarily
520 | for and in connection with specific products or compilations that
521 | contain the covered work, unless you entered into that arrangement,
522 | or that patent license was granted, prior to 28 March 2007.
523 | 
524 |   Nothing in this License shall be construed as excluding or limiting
525 | any implied license or other defenses to infringement that may
526 | otherwise be available to you under applicable patent law.
527 | 
528 |   12. No Surrender of Others' Freedom.
529 | 
530 |   If conditions are imposed on you (whether by court order, agreement or
531 | otherwise) that contradict the conditions of this License, they do not
532 | excuse you from the conditions of this License.  If you cannot convey a
533 | covered work so as to satisfy simultaneously your obligations under this
534 | License and any other pertinent obligations, then as a consequence you may
535 | not convey it at all.  For example, if you agree to terms that obligate you
536 | to collect a royalty for further conveying from those to whom you convey
537 | the Program, the only way you could satisfy both those terms and this
538 | License would be to refrain entirely from conveying the Program.
539 | 
540 |   13. Remote Network Interaction; Use with the GNU General Public License.
541 | 
542 |   Notwithstanding any other provision of this License, if you modify the
543 | Program, your modified version must prominently offer all users
544 | interacting with it remotely through a computer network (if your version
545 | supports such interaction) an opportunity to receive the Corresponding
546 | Source of your version by providing access to the Corresponding Source
547 | from a network server at no charge, through some standard or customary
548 | means of facilitating copying of software.  This Corresponding Source
549 | shall include the Corresponding Source for any work covered by version 3
550 | of the GNU General Public License that is incorporated pursuant to the
551 | following paragraph.
552 | 
553 |   Notwithstanding any other provision of this License, you have
554 | permission to link or combine any covered work with a work licensed
555 | under version 3 of the GNU General Public License into a single
556 | combined work, and to convey the resulting work.  The terms of this
557 | License will continue to apply to the part which is the covered work,
558 | but the work with which it is combined will remain governed by version
559 | 3 of the GNU General Public License.
560 | 
561 |   14. Revised Versions of this License.
562 | 
563 |   The Free Software Foundation may publish revised and/or new versions of
564 | the GNU Affero General Public License from time to time.  Such new versions
565 | will be similar in spirit to the present version, but may differ in detail to
566 | address new problems or concerns.
567 | 
568 |   Each version is given a distinguishing version number.  If the
569 | Program specifies that a certain numbered version of the GNU Affero General
570 | Public License "or any later version" applies to it, you have the
571 | option of following the terms and conditions either of that numbered
572 | version or of any later version published by the Free Software
573 | Foundation.  If the Program does not specify a version number of the
574 | GNU Affero General Public License, you may choose any version ever published
575 | by the Free Software Foundation.
576 | 
577 |   If the Program specifies that a proxy can decide which future
578 | versions of the GNU Affero General Public License can be used, that proxy's
579 | public statement of acceptance of a version permanently authorizes you
580 | to choose that version for the Program.
581 | 
582 |   Later license versions may give you additional or different
583 | permissions.  However, no additional obligations are imposed on any
584 | author or copyright holder as a result of your choosing to follow a
585 | later version.
586 | 
587 |   15. Disclaimer of Warranty.
588 | 
589 |   THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
590 | APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
591 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
592 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
593 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
594 | PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
595 | IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
596 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
597 | 
598 |   16. Limitation of Liability.
599 | 
600 |   IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
601 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
602 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
603 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
604 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
605 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
606 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
607 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
608 | SUCH DAMAGES.
609 | 
610 |   17. Interpretation of Sections 15 and 16.
611 | 
612 |   If the disclaimer of warranty and limitation of liability provided
613 | above cannot be given local legal effect according to their terms,
614 | reviewing courts shall apply local law that most closely approximates
615 | an absolute waiver of all civil liability in connection with the
616 | Program, unless a warranty or assumption of liability accompanies a
617 | copy of the Program in return for a fee.
618 | 
619 |                      END OF TERMS AND CONDITIONS
620 | 
621 |             How to Apply These Terms to Your New Programs
622 | 
623 |   If you develop a new program, and you want it to be of the greatest
624 | possible use to the public, the best way to achieve this is to make it
625 | free software which everyone can redistribute and change under these terms.
626 | 
627 |   To do so, attach the following notices to the program.  It is safest
628 | to attach them to the start of each source file to most effectively
629 | state the exclusion of warranty; and each file should have at least
630 | the "copyright" line and a pointer to where the full notice is found.
631 | 
632 |     <one line to give the program's name and a brief idea of what it does.>
633 |     Copyright (C) <year>  <name of author>
634 | 
635 |     This program is free software: you can redistribute it and/or modify
636 |     it under the terms of the GNU Affero General Public License as published
637 |     by the Free Software Foundation, either version 3 of the License, or
638 |     (at your option) any later version.
639 | 
640 |     This program is distributed in the hope that it will be useful,
641 |     but WITHOUT ANY WARRANTY; without even the implied warranty of
642 |     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
643 |     GNU Affero General Public License for more details.
644 | 
645 |     You should have received a copy of the GNU Affero General Public License
646 |     along with this program.  If not, see <https://www.gnu.org/licenses/>.
647 | 
648 | Also add information on how to contact you by electronic and paper mail.
649 | 
650 |   If your software can interact with users remotely through a computer
651 | network, you should also make sure that it provides a way for users to
652 | get its source.  For example, if your program is a web application, its
653 | interface could display a "Source" link that leads users to an archive
654 | of the code.  There are many ways you could offer source, and different
655 | solutions will be better for different programs; see section 13 for the
656 | specific requirements.
657 | 
658 |   You should also get your employer (if you work as a programmer) or school,
659 | if any, to sign a "copyright disclaimer" for the program, if necessary.
660 | For more information on this, and how to apply and follow the GNU AGPL, see
661 | <https://www.gnu.org/licenses/>.
662 | 


--------------------------------------------------------------------------------
/static/index.html:
--------------------------------------------------------------------------------
   1 | <!DOCTYPE html>
   2 | <html lang="en">
   3 | <head>
   4 |     <meta charset="UTF-8">
   5 |     <meta name="viewport" content="width=device-width, initial-scale=1.0">
   6 |     <title>YouTube Channel Lookup</title>
   7 |     
   8 |     <!-- React and ReactDOM -->
   9 |     <script src="https://cdnjs.cloudflare.com/ajax/libs/react/18.2.0/umd/react.production.min.js"></script>
  10 |     <script src="https://cdnjs.cloudflare.com/ajax/libs/react-dom/18.2.0/umd/react-dom.production.min.js"></script>
  11 |     
  12 |     <!-- Babel for JSX -->
  13 |     <script src="https://cdnjs.cloudflare.com/ajax/libs/babel-standalone/7.23.5/babel.min.js"></script>
  14 | 
  15 |     <link href="https://fonts.googleapis.com/css2?family=Geist:wght@100..900&family=Inter:ital,opsz,wght@0,14..32,100..900;1,14..32,100..900&family=Roboto:ital,wght@0,100..900;1,100..900&display=swap" rel="stylesheet">
  16 | 
  17 |     <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/inter-ui/3.19.3/inter.css" />
  18 |     <style>
  19 |         
  20 |         /* Icon styles */
  21 |         .icon-button {
  22 |             background: none;
  23 |             border: none;
  24 |             color: #94a3b8;
  25 |             padding: 4px;
  26 |             border-radius: 4px;
  27 |             cursor: pointer;
  28 |             transition: color 0.2s;
  29 |             display: inline-flex;
  30 |             align-items: center;
  31 |         }
  32 | 
  33 |         .icon-button:hover {
  34 |             color: #e2e8f0;
  35 |             background: #334155;
  36 |         }
  37 | 
  38 |         .meta-with-button {
  39 |             display: flex;
  40 |             align-items: center;
  41 |             gap: 0.5rem;
  42 |         }
  43 | 
  44 |         /* Base styles */
  45 |         body {
  46 |             background-color: #0f0f0f;
  47 |             margin: 0;
  48 |             padding: 0;
  49 |             font-family: 'Geist', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
  50 |             color: #ffffff;
  51 |             -webkit-font-smoothing: antialiased;
  52 |             -moz-osx-font-smoothing: grayscale;
  53 |         }
  54 | 
  55 |         /* Card styles */
  56 |         .card {
  57 |             background: #181818;
  58 |             border-radius: 8px;
  59 |             box-shadow: 0 4px 6px rgba(0, 0, 0, 0.2);
  60 |             margin-bottom: 1rem;
  61 |             padding: 1.5rem;
  62 |             border: 1px solid #303030;
  63 |         }
  64 | 
  65 |         /* Form styles */
  66 |         .lookup-form {
  67 |             display: flex;
  68 |             gap: 1px;
  69 |             background-color: #303030;
  70 |             padding: 1px;
  71 |             border-radius: 6px;
  72 |         }
  73 | 
  74 |         select, input {
  75 |             font-family: 'Geist', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
  76 |             padding: 0.75rem 1rem;
  77 |             border: none;
  78 |             background-color: #121212;
  79 |             color: #ffffff;
  80 |             font-size: 0.9rem;
  81 |             transition: background-color 0.2s;
  82 |         }
  83 | 
  84 |         select:hover, input:hover {
  85 |             background-color: #1a1a1a;
  86 |         }
  87 | 
  88 |         select {
  89 |             border-radius: 5px 0 0 5px;
  90 |             width: 160px;
  91 |             cursor: pointer;
  92 |             appearance: none;
  93 |             background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='16' height='16' viewBox='0 0 24 24' fill='none' stroke='%23888' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpolyline points='6 9 12 15 18 9'%3E%3C/polyline%3E%3C/svg%3E");
  94 |             background-repeat: no-repeat;
  95 |             background-position: right 12px center;
  96 |             padding-right: 35px;
  97 |         }
  98 | 
  99 |         input {
 100 |             flex: 1;
 101 |         }
 102 | 
 103 |         select:focus, input:focus {
 104 |             outline: none;
 105 |             background-color: #1a1a1a;
 106 |         }
 107 | 
 108 |         select option {
 109 |             background-color: #1e293b;
 110 |             color: #e2e8f0;
 111 |             padding: 8px;
 112 |         }
 113 | 
 114 |         input::placeholder {
 115 |             color: #94a3b8;
 116 |         }
 117 | 
 118 |         /* Special style for the lookup button */
 119 |         button.lookup-button {
 120 |             background-color: #121212;
 121 |             color: #aaaaaa;
 122 |             border: none;
 123 |             cursor: pointer;
 124 |             padding: 0 1.25rem;
 125 |             border-radius: 0 5px 5px 0;
 126 |             display: flex;
 127 |             align-items: center;
 128 |             justify-content: center;
 129 |             transition: all 0.2s;
 130 |         }
 131 | 
 132 |         button.lookup-button:hover:not(:disabled) {
 133 |             background-color: #1a1a1a;
 134 |             color: #ffffff;
 135 |         }
 136 | 
 137 |         button.lookup-button:disabled {
 138 |             background-color: #121212;
 139 |             cursor: not-allowed;
 140 |             opacity: 0.5;
 141 |         }
 142 | 
 143 |         button {
 144 |             background-color: #222222;
 145 |             color: white;
 146 |             border: none;
 147 |             cursor: pointer;
 148 |             padding: 0.5rem 1rem;
 149 |             border-radius: 4px;
 150 |         }
 151 | 
 152 |         button:hover {
 153 |             background-color: #303030;
 154 |         }
 155 | 
 156 |         button:disabled {
 157 |             background-color: #475569;
 158 |             cursor: not-allowed;
 159 |         }
 160 | 
 161 |         /* Tab styles */
 162 |         .tabs {
 163 |             margin-top: 1rem;
 164 |         }
 165 | 
 166 |         .tab-list {
 167 |             border-bottom: 1px solid #ddd;
 168 |             padding-bottom: 0.5rem;
 169 |             margin-bottom: 1rem;
 170 |         }
 171 | 
 172 |         .tab-button {
 173 |             background: none;
 174 |             border: none;
 175 |             color: #aaaaaa;
 176 |             margin-right: 1rem;
 177 |             padding: 0.5rem 1rem;
 178 |             cursor: pointer;
 179 |             font-family: "Roboto", sans-serif;
 180 |             font-size: 0.875rem;
 181 |             font-weight: 500;
 182 |             letter-spacing: normal;
 183 |             text-transform: none;
 184 |         }
 185 | 
 186 |         .tab-button.active {
 187 |             color: #ffffff;
 188 |             border-bottom: 2px solid #ffffff;
 189 |         }
 190 | 
 191 |         /* Video grid and card styles */
 192 |         .videos-grid {
 193 |             display: grid;
 194 |             grid-template-columns: repeat(auto-fit, 272px);
 195 |             column-gap: 1rem;
 196 |             row-gap: 2.5rem;
 197 |             padding: 0.5rem;
 198 |             justify-content: start;
 199 |             width: 100%;
 200 |             max-width: 1168px; /* Fits exactly 4 videos (272px * 4 + 16px * 3) */
 201 |             margin: 0 auto;
 202 |         }
 203 | 
 204 |         .video-card {
 205 |             padding: 0;
 206 |             width: 272px;
 207 |             background: transparent;
 208 |             border: none;
 209 |             box-shadow: none;
 210 |             cursor: pointer;
 211 |             text-decoration: none;
 212 |             color: inherit;
 213 |             display: block;
 214 |         }
 215 | 
 216 |         .video-thumbnail-container {
 217 |             position: relative;
 218 |             width: 272px;
 219 |             height: 153px; /* Maintains 16:9 ratio */
 220 |             border-radius: 12px;
 221 |             overflow: hidden;
 222 |             background: #181818;
 223 |             margin-bottom: 0.75rem;
 224 |         }
 225 | 
 226 |         .video-thumbnail {
 227 |             width: 100%;
 228 |             height: 100%;
 229 |             object-fit: cover;
 230 |             transition: transform 0.2s ease;
 231 |         }
 232 | 
 233 |         .video-card:hover .video-thumbnail {
 234 |             transform: scale(1.05);
 235 |         }
 236 | 
 237 |         .video-duration {
 238 |             position: absolute;
 239 |             bottom: 0.5rem;
 240 |             right: 0.5rem;
 241 |             background: rgba(0, 0, 0, 0.8);
 242 |             color: #fff;
 243 |             padding: 0.25rem 0.5rem;
 244 |             border-radius: 4px;
 245 |             font-size: 0.75rem;
 246 |             font-weight: 500;
 247 |             font-family: "Roboto", sans-serif;
 248 |         }
 249 | 
 250 |         .video-info {
 251 |             padding: 0;
 252 |         }
 253 | 
 254 |         .video-title {
 255 |             font-size: 0.9rem;
 256 |             font-weight: 500;
 257 |             margin: 0;
 258 |             margin-bottom: 0.5rem;
 259 |             display: -webkit-box;
 260 |             -webkit-line-clamp: 2;
 261 |             -webkit-box-orient: vertical;
 262 |             overflow: hidden;
 263 |             color: #f1f1f1;
 264 |             line-height: 1.4;
 265 |             font-family: "Roboto", sans-serif;
 266 |             position: relative;
 267 |         }
 268 | 
 269 |         .hidden-views-tag {
 270 |             display: inline-flex;
 271 |             align-items: center;
 272 |             background: rgba(255, 255, 255, 0.1);
 273 |             color: #aaa;
 274 |             padding: 0.2rem 0.4rem;
 275 |             border-radius: 3px;
 276 |             font-size: 0.7rem;
 277 |             font-weight: 500;
 278 |             margin-left: 0.5rem;
 279 |             vertical-align: middle;
 280 |             position: relative;
 281 |             top: -1px;
 282 |         }
 283 | 
 284 |         .video-metadata {
 285 |             font-size: 0.8rem;
 286 |             color: #aaa;
 287 |             font-family: "Roboto", sans-serif;
 288 |         }
 289 | 
 290 |         .video-stats {
 291 |             display: flex;
 292 |             align-items: center;
 293 |             color: #aaa;
 294 |             flex-wrap: wrap;
 295 |         }
 296 | 
 297 |         .video-stats > span {
 298 |             display: flex;
 299 |             align-items: center;
 300 |         }
 301 | 
 302 |         .video-stats > span:not(:last-child) {
 303 |             margin-right: 0.25rem;
 304 |         }
 305 | 
 306 |         /* Make the dots slightly smaller and lighter */
 307 |         .video-stats .separator {
 308 |             font-size: 0.6rem;
 309 |             opacity: 0.7;
 310 |             margin: 0 0.25rem;
 311 |         }
 312 | 
 313 |         /* Subscription grid and card styles */
 314 |         .subscriptions-grid {
 315 |             display: grid;
 316 |             grid-template-columns: repeat(auto-fill, minmax(200px, 1fr));
 317 |             gap: 1rem;
 318 |         }
 319 | 
 320 |         .subscription-card {
 321 |             padding: 0.75rem;
 322 |             display: flex;
 323 |             align-items: center;
 324 |             gap: 0.75rem;
 325 |         }
 326 | 
 327 |         .subscription-card:hover {
 328 |             text-decoration: none;
 329 |             color: inherit;
 330 |         }
 331 | 
 332 |         .subscription-image {
 333 |             width: 36px;
 334 |             height: 36px;
 335 |             border-radius: 50%;
 336 |         }
 337 | 
 338 |         .subscription-info {
 339 |             min-width: 0;
 340 |         }
 341 | 
 342 |         .subscription-title {
 343 |             font-size: 0.9rem;
 344 |             font-weight: 500;
 345 |             margin: 0;
 346 |             white-space: nowrap;
 347 |             overflow: hidden;
 348 |             text-overflow: ellipsis;
 349 |         }
 350 | 
 351 |         .subscription-date {
 352 |             font-size: 0.75rem;
 353 |             color: #94a3b8;
 354 |             margin: 0;
 355 |             margin-top: 0.25rem;
 356 |         }
 357 | 
 358 |         /* Loading spinner */
 359 |         @keyframes spin {
 360 |             to { transform: rotate(360deg); }
 361 |         }
 362 | 
 363 |         .loading {
 364 |             display: inline-block;
 365 |             width: 20px;
 366 |             height: 20px;
 367 |             border: 2px solid #f3f3f3;
 368 |             border-top: 2px solid #1a73e8;
 369 |             border-radius: 50%;
 370 |             animation: spin 1s linear infinite;
 371 |         }
 372 | 
 373 |         /* Error message */
 374 |         .error {
 375 |             color: #d32f2f;
 376 |             padding: 0.5rem;
 377 |             margin-top: 0.5rem;
 378 |         }
 379 | 
 380 |         /* Component-specific styles */
 381 |         .container {
 382 |             max-width: 1200px;
 383 |             margin: 0 auto;
 384 |             padding: 1rem;
 385 |         }
 386 | 
 387 |         .profile-image {
 388 |             width: 96px;
 389 |             height: 96px;
 390 |             border-radius: 50%;
 391 |             object-fit: cover;
 392 |         }
 393 | 
 394 |         .channel-header {
 395 |             margin-bottom: 1.5rem;
 396 |             position: relative;
 397 |         }
 398 | 
 399 |         .channel-id {
 400 |             position: absolute;
 401 |             top: 0;
 402 |             right: 0;
 403 |             font-family: "Roboto", "Arial", sans-serif;
 404 |             font-size: 0.875rem;
 405 |             color: #f1f1f1;
 406 |             background: rgba(255, 255, 255, 0.08);
 407 |             padding: 0.5rem 0.75rem;
 408 |             border-radius: 8px;
 409 |             cursor: pointer;
 410 |             transition: all 0.1s;
 411 |             white-space: nowrap;
 412 |             font-weight: 400;
 413 |             display: flex;
 414 |             align-items: center;
 415 |             gap: 0.5rem;
 416 |         }
 417 | 
 418 |         .channel-id:hover {
 419 |             background: rgba(255, 255, 255, 0.12);
 420 |         }
 421 | 
 422 |         .channel-id::after {
 423 |             content: "";
 424 |             display: inline-block;
 425 |             width: 16px;
 426 |             height: 16px;
 427 |             background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='%23fff' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Crect x='9' y='9' width='13' height='13' rx='2' ry='2'%3E%3C/rect%3E%3Cpath d='M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1'%3E%3C/path%3E%3C/svg%3E");
 428 |             opacity: 0.6;
 429 |         }
 430 | 
 431 |         .channel-id:active {
 432 |             transform: scale(0.98);
 433 |             background: rgba(255, 255, 255, 0.16);
 434 |         }
 435 | 
 436 |         .redirect-url {
 437 |             font-size: 0.875rem;
 438 |             color: #94a3b8;
 439 |             border-top: 1px solid #334155;
 440 |             margin-top: 1rem;
 441 |             padding-top: 1rem;
 442 |             font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;
 443 |             word-break: break-all;
 444 |         }
 445 | 
 446 |         .channel-main {
 447 |             display: flex;
 448 |             gap: 1.5rem;
 449 |             align-items: flex-start;
 450 |             margin-bottom: 1.5rem;
 451 |         }
 452 | 
 453 |         .channel-titles {
 454 |             flex: 1;
 455 |             min-width: 0;
 456 |         }
 457 | 
 458 |         .channel-name {
 459 |             font-size: 1.5rem;
 460 |             font-weight: 600;
 461 |             margin: 0;
 462 |             line-height: 1.2;
 463 |         }
 464 | 
 465 |         .channel-meta {
 466 |             display: flex;
 467 |             gap: 1rem;
 468 |             color: #94a3b8;
 469 |             font-size: 0.875rem;
 470 |             margin-top: 0.25rem;
 471 |         }
 472 | 
 473 |         .channel-handle {
 474 |             color: #60a5fa;
 475 |         }
 476 | 
 477 |         .channel-stats {
 478 |             display: flex;
 479 |             gap: 1.5rem;
 480 |             color: #e2e8f0;
 481 |             font-size: 0.9rem;
 482 |             margin-top: 0.75rem;
 483 |         }
 484 | 
 485 |         .channel-banner {
 486 |             margin-top: 1rem;
 487 |             border-radius: 0.5rem;
 488 |             overflow: hidden;
 489 |         }
 490 | 
 491 |         .channel-banner img {
 492 |             width: 100%;
 493 |             height: 200px;
 494 |             object-fit: cover;
 495 |             border-radius: 0.5rem;
 496 |         }
 497 | 
 498 |         .channel-description {
 499 |             white-space: pre-wrap;
 500 |             color: #cbd5e1;
 501 |             font-size: 0.925rem;
 502 |             line-height: 1.5;
 503 |         }
 504 | 
 505 |         .channel-metadata {
 506 |             margin-top: 1.5rem;
 507 |             display: flex;
 508 |             flex-direction: column;
 509 |             gap: 1rem;
 510 |             background: rgba(255, 255, 255, 0.08);
 511 |             padding: 1.25rem;
 512 |             border-radius: 12px;
 513 |         }
 514 | 
 515 |         .metadata-item {
 516 |             display: flex;
 517 |             gap: 1rem;
 518 |             align-items: center;
 519 |             padding: 0.25rem 0;
 520 |         }
 521 | 
 522 |         .metadata-item:hover {
 523 |             text-decoration: none;
 524 |             color: inherit;
 525 |         }
 526 | 
 527 |         .metadata-label {
 528 |             color: #aaa;
 529 |             font-size: 0.875rem;
 530 |             font-family: "Roboto", "Arial", sans-serif;
 531 |             min-width: 140px;
 532 |             font-weight: 500;
 533 |             position: relative;
 534 |             display: flex;
 535 |             align-items: center;
 536 |             gap: 0.5rem;
 537 |         }
 538 | 
 539 |         .metadata-label::after {
 540 |             content: ":";
 541 |             position: absolute;
 542 |             right: -0.5rem;
 543 |             color: #666;
 544 |         }
 545 | 
 546 |         .metadata-value {
 547 |             color: #f1f1f1;
 548 |             font-size: 0.875rem;
 549 |             font-family: "Roboto", "Arial", sans-serif;
 550 |             background: rgba(255, 255, 255, 0.05);
 551 |             padding: 0.5rem 0.75rem;
 552 |             border-radius: 6px;
 553 |             font-weight: 400;
 554 |             transition: background-color 0.1s;
 555 |         }
 556 | 
 557 |         .metadata-value:hover {
 558 |             background: rgba(255, 255, 255, 0.08);
 559 |         }
 560 | 
 561 |         /* Add icons for each metadata type */
 562 |         .metadata-label[data-type]::before {
 563 |             content: "";
 564 |             display: inline-block;
 565 |             width: 16px;
 566 |             height: 16px;
 567 |             opacity: 0.7;
 568 |         }
 569 | 
 570 |         .metadata-label[data-type="kids"]::before {
 571 |             background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='%23fff' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='M12 2a3 3 0 0 0-3 3v7a3 3 0 0 0 6 0V5a3 3 0 0 0-3-3Z'%3E%3C/path%3E%3Cpath d='M19 9h-4'%3E%3C/path%3E%3Cpath d='M5 9h4'%3E%3C/path%3E%3Cpath d='M12 19c-2.3 0-4.3-1.9-4.3-4.3V9'%3E%3C/path%3E%3Cpath d='M16.3 9v5.7c0 2.4-2 4.3-4.3 4.3'%3E%3C/path%3E%3C/svg%3E");
 572 |         }
 573 | 
 574 |         .metadata-label[data-type="analytics"]::before {
 575 |             background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='%23fff' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='M3 3v18h18'/%3E%3Cpath d='m19 9-5 5-4-4-3 3'/%3E%3C/svg%3E");
 576 |         }
 577 | 
 578 |         .metadata-label[data-type="noindex"]::before {
 579 |             background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='%23fff' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Ccircle cx='12' cy='12' r='10'%3E%3C/circle%3E%3Cline x1='4.93' y1='4.93' x2='19.07' y2='19.07'%3E%3C/line%3E%3C/svg%3E");
 580 |         }
 581 | 
 582 |         .metadata-label[data-type="blocked"]::before {
 583 |             background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='%23fff' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Crect x='3' y='11' width='18' height='11' rx='2' ry='2'%3E%3C/rect%3E%3Cpath d='M7 11V7a5 5 0 0 1 10 0v4'%3E%3C/path%3E%3C/svg%3E");
 584 |         }
 585 | 
 586 |         .metadata-label[data-type="redirect"]::before {
 587 |             background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='%23fff' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='M15 3h6v6'/%3E%3Cpath d='M10 14L21 3'/%3E%3Cpath d='M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6'/%3E%3C/svg%3E");
 588 |         }
 589 | 
 590 |         .metadata-label[data-type="url"]::before {
 591 |             background-image: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='%23fff' stroke-width='2' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='M10 13a5 5 0 0 0 7.54.54l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71'%3E%3C/path%3E%3Cpath d='M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71'%3E%3C/path%3E%3C/svg%3E");
 592 |         }
 593 | 
 594 |         .channel-tags {
 595 |             display: flex;
 596 |             flex-wrap: wrap;
 597 |             gap: 0.5rem;
 598 |             margin-top: 1rem;
 599 |         }
 600 | 
 601 |         .channel-tag {
 602 |             background: rgba(255, 255, 255, 0.08);
 603 |             color: #f1f1f1;
 604 |             padding: 0.5rem 1rem;
 605 |             border-radius: 8px;
 606 |             font-size: 0.875rem;
 607 |             font-family: "Roboto", "Arial", sans-serif;
 608 |             transition: background-color 0.1s;
 609 |             font-weight: 400;
 610 |             line-height: 1.2;
 611 |         }
 612 | 
 613 |         .channel-tag:hover {
 614 |             background: rgba(255, 255, 255, 0.12);
 615 |         }
 616 | 
 617 |         .subscription-card {
 618 |             display: flex;
 619 |             align-items: center;
 620 |             gap: 0.5rem;
 621 |         }
 622 | 
 623 |         .subscription-image {
 624 |             width: 40px;
 625 |             height: 40px;
 626 |             border-radius: 50%;
 627 |         }
 628 | 
 629 |         .name-and-sync {
 630 |             display: flex;
 631 |             align-items: center;
 632 |             gap: 0.75rem;
 633 |         }
 634 | 
 635 |         .sync-badge {
 636 |             background-color: #334155;
 637 |             color: #94a3b8;
 638 |             padding: 0.25rem 0.5rem;
 639 |             border-radius: 9999px;
 640 |             font-size: 0.75rem;
 641 |             font-weight: 400;
 642 |         }
 643 | 
 644 |         .image-loading {
 645 |             position: relative;
 646 |             background: #334155;
 647 |             overflow: hidden;
 648 |         }
 649 | 
 650 |         .image-loading::after {
 651 |             content: "";
 652 |             position: absolute;
 653 |             top: 0;
 654 |             right: 0;
 655 |             bottom: 0;
 656 |             left: 0;
 657 |             transform: translateX(-100%);
 658 |             background-image: linear-gradient(
 659 |                 90deg,
 660 |                 rgba(255, 255, 255, 0) 0,
 661 |                 rgba(255, 255, 255, 0.1) 20%,
 662 |                 rgba(255, 255, 255, 0.2) 60%,
 663 |                 rgba(255, 255, 255, 0)
 664 |             );
 665 |             animation: shimmer 2s infinite;
 666 |         }
 667 | 
 668 |         .loading-container {
 669 |             display: flex;
 670 |             justify-content: center;
 671 |             padding: 2rem;
 672 |             margin-top: 1rem;
 673 |         }
 674 | 
 675 |         @keyframes shimmer {
 676 |             100% {
 677 |                 transform: translateX(100%);
 678 |             }
 679 |         }
 680 |     </style>
 681 | </head>
 682 | <body>
 683 |     <div id="root"></div>
 684 | 
 685 |     <script type="text/babel">
 686 |         // React component
 687 |         const { useState } = React;
 688 | 
 689 |         const formatSubscriberCount = (count) => {
 690 |             if (count >= 1000000000) {
 691 |                 const billions = count / 1000000000;
 692 |                 // Only show decimal if it's not a whole number
 693 |                 return `${billions % 1 === 0 ? Math.floor(billions) : billions.toFixed(1)}B`;
 694 |             } else if (count >= 1000000) {
 695 |                 const millions = count / 1000000;
 696 |                 // Show up to 2 decimal places, but only if necessary
 697 |                 if (millions % 1 === 0) {
 698 |                     return `${Math.floor(millions)}M`;
 699 |                 }
 700 |                 // Remove trailing zeros but keep significant decimals
 701 |                 return `${millions.toFixed(2).replace(/\.?0+$/, '')}M`;
 702 |             } else if (count >= 1000) {
 703 |                 const thousands = count / 1000;
 704 |                 // Only show decimal if it's not a whole number
 705 |                 return `${thousands % 1 === 0 ? Math.floor(thousands) : thousands.toFixed(1)}K`;
 706 |             }
 707 |             return count.toLocaleString();
 708 |         };
 709 | 
 710 | 
 711 |         const VerificationBadge = ({ type }) => {
 712 |             // Common styling for all badges
 713 |             const badgeStyle = {
 714 |                 transform: 'translateY(1px)',
 715 |                 marginLeft: '-4px'
 716 |             };
 717 | 
 718 |             // If type is undefined (not null or "none"), show warning badge
 719 |             if (type === undefined) {
 720 |                 return (
 721 |                     <div 
 722 |                         className="flex items-center" 
 723 |                         style={badgeStyle} 
 724 |                         title="Channel verification status and handle caps could not be fetched"
 725 |                     >
 726 |                         <svg 
 727 |                             xmlns="http://www.w3.org/2000/svg" 
 728 |                             viewBox="0 0 24 24" 
 729 |                             width="14"
 730 |                             height="14"
 731 |                             fill="none"
 732 |                             stroke="#FCD34D"
 733 |                             strokeWidth="2"
 734 |                         >
 735 |                             <circle cx="12" cy="12" r="10" />
 736 |                             <path 
 737 |                                 d="M12 8v4m0 4h.01" 
 738 |                                 stroke="#FCD34D" 
 739 |                                 strokeWidth="2" 
 740 |                                 strokeLinecap="round" 
 741 |                                 strokeLinejoin="round"
 742 |                             />
 743 |                         </svg>
 744 |                     </div>
 745 |                 );
 746 |             }
 747 | 
 748 |             // Return null for explicit null or "none" type
 749 |             if (!type || type === "none") return null;
 750 | 
 751 |             return (
 752 |                 <div 
 753 |                     className="flex items-center" 
 754 |                     style={badgeStyle} 
 755 |                     title={type === "oac" ? "Official Artist Channel" : "Verified"}
 756 |                 >
 757 |                     {type === "oac" ? (
 758 |                         <svg 
 759 |                             xmlns="http://www.w3.org/2000/svg" 
 760 |                             viewBox="0 0 12 12" 
 761 |                             width="14"
 762 |                             height="14"
 763 |                             fill="white"
 764 |                         >
 765 |                             <g>
 766 |                                 <path 
 767 |                                     d="M10.334 4.205a1.8 1.8 0 010 3.59 1.8 1.8 0 01-2.539 2.54 1.8 1.8 0 01-3.59-.001 1.8 1.8 0 01-2.538-2.539 1.8 1.8 0 010-3.59 1.8 1.8 0 012.538-2.539 1.8 1.8 0 013.59 0 1.8 1.8 0 012.539 2.539ZM6 3v2.668A1.75 1.75 0 107 7.25V4h1V3H6Z"
 768 |                                     fillRule="evenodd"
 769 |                                     clipRule="evenodd"
 770 |                                 />
 771 |                             </g>
 772 |                         </svg>
 773 |                     ) : (
 774 |                         <svg 
 775 |                             xmlns="http://www.w3.org/2000/svg" 
 776 |                             viewBox="0 0 24 24" 
 777 |                             width="14"
 778 |                             height="14"
 779 |                             fill="white"
 780 |                         >
 781 |                             <path d="M12 2C6.5 2 2 6.5 2 12s4.5 10 10 10 10-4.5 10-10S17.5 2 12 2zM9.8 17.3l-4.2-4.1L7 11.8l2.8 2.7L17 7.4l1.4 1.4-8.6 8.5z" />
 782 |                         </svg>
 783 |                     )}
 784 |                 </div>
 785 |             );
 786 |         };
 787 | 
 788 |         const ChannelInfo = ({ channel, redirectUrl, onChannelClick }) => {
 789 |             const [profileImageLoaded, setProfileImageLoaded] = useState(false);
 790 |             const [bannerImageLoaded, setBannerImageLoaded] = useState(false);
 791 |             
 792 |             React.useEffect(() => {
 793 |                 setProfileImageLoaded(false);
 794 |                 setBannerImageLoaded(false);
 795 |             }, [channel?.user_id]);
 796 | 
 797 |             if (!channel) return null;
 798 |             
 799 |             const channelUrl = `https://youtube.com/channel/${channel.user_id}`;
 800 |             const isSynced = channel.profile_picture?.startsWith('ytc/');
 801 |             
 802 |             const handleCopyChannelId = async () => {
 803 |                 try {
 804 |                     await navigator.clipboard.writeText(channel.user_id);
 805 |                     const el = document.querySelector('.channel-id');
 806 |                     const originalText = el.textContent;
 807 |                     el.textContent = 'Copied!';
 808 |                     setTimeout(() => el.textContent = originalText, 300);
 809 |                 } catch (err) {
 810 |                     console.error('Failed to copy:', err);
 811 |                 }
 812 |             };
 813 | 
 814 |             const formatUTCDateTime = (timestamp) => {
 815 |                 const date = new Date(timestamp * 1000);
 816 |                 return `${String(date.getUTCDate()).padStart(2, '0')}/${String(date.getUTCMonth() + 1).padStart(2, '0')}/${date.getUTCFullYear()} ${String(date.getUTCHours()).padStart(2, '0')}:${String(date.getUTCMinutes()).padStart(2, '0')}:${String(date.getUTCSeconds()).padStart(2, '0')}`;
 817 |             };
 818 | 
 819 |             const formatViewCount = (count) => {
 820 |                 if (count >= 1000000000) {
 821 |                     const billions = count / 1000000000;
 822 |                     return `${billions.toFixed(1).replace(/\.0$/, '')}B`;
 823 |                 } else if (count >= 1000000) {
 824 |                     return `${Math.floor(count / 1000000)}M`;
 825 |                 } else if (count >= 1000) {
 826 |                     const thousands = count / 1000;
 827 |                     return `${thousands.toFixed(1).replace(/\.0$/, '')}K`;
 828 |                 }
 829 |                 return count.toLocaleString();
 830 |             };
 831 | 
 832 |             return (
 833 |                 <div className="card">
 834 |                     <div className="channel-header">
 835 |                         <div className="channel-id" 
 836 |                             onClick={handleCopyChannelId}
 837 |                             title="Click to copy">
 838 |                             {channel.user_id}
 839 |                         </div>
 840 |                         <div className="channel-main">
 841 |                             {channel.profile_picture && (
 842 |                                 <div className={`profile-image ${!profileImageLoaded ? 'image-loading' : ''}`}>
 843 |                                     <img 
 844 |                                         src={`https://external-content.duckduckgo.com/iu/?u=https://yt3.googleusercontent.com/${channel.profile_picture}`} 
 845 |                                         alt={channel.display_name} 
 846 |                                         className="profile-image"
 847 |                                         style={{ opacity: profileImageLoaded ? 1 : 0 }}
 848 |                                         onLoad={() => setProfileImageLoaded(true)}
 849 |                                     />
 850 |                                 </div>
 851 |                             )}
 852 |                             <div className="channel-titles">
 853 |                                 <div className="name-and-sync">
 854 |                                     <h2 className="channel-name">{channel.display_name}</h2>
 855 |                                     <VerificationBadge type={channel.verification?.toLowerCase()} />
 856 |                                     {isSynced && (
 857 |                                         <span className="sync-badge" title="Channel name and profile picture is synced with it's Google account">
 858 |                                         Synced
 859 |                                         </span>
 860 |                                     )}
 861 |                                     </div>
 862 |                                 <div className="channel-meta">
 863 |                                     {channel.handle && (
 864 |                                         <span className="channel-handle">@{channel.handle}</span>
 865 |                                     )}
 866 |                                     {channel.country && <span className="channel-location">{channel.country}</span>}
 867 |                                     <div className="meta-with-button">
 868 |                                         <span>{formatUTCDateTime(channel.created_at)}</span>
 869 |                                         <button 
 870 |                                             className="icon-button"
 871 |                                             onClick={() => window.open(`https://youtube.com/channel/${channel.user_id}`, '_blank')}
 872 |                                             title="Open in YouTube"
 873 |                                             style={{ padding: '2px' }}
 874 |                                         >
 875 |                                             <svg xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
 876 |                                                 <path d="M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6"/>
 877 |                                                 <polyline points="15 3 21 3 21 9"/>
 878 |                                                 <line x1="10" y1="14" x2="21" y2="3"/>
 879 |                                             </svg>
 880 |                                         </button>
 881 |                                     </div>
 882 |                                 </div>
 883 |                                 <div className="channel-stats">
 884 |                                     <span>{formatSubscriberCount(channel.subscriber_count)} subscribers</span>
 885 |                                     <span>{channel.video_count.toLocaleString()} videos</span>
 886 |                                     <span>{formatViewCount(channel.view_count)} views</span>
 887 |                                 </div>
 888 |                             </div>
 889 |                         </div>
 890 |                         {channel.banner && (
 891 |                             <div className={`channel-banner ${!bannerImageLoaded ? 'image-loading' : ''}`}>
 892 |                                 <img 
 893 |                                     src={`https://external-content.duckduckgo.com/iu/?u=https://yt3.googleusercontent.com/${channel.banner}=w1138-fcrop64=1,00005a57ffffa5a8-k-c0xffffffff-no-nd-rj`} 
 894 |                                     alt="Channel banner"
 895 |                                     style={{ opacity: bannerImageLoaded ? 1 : 0 }}
 896 |                                     onLoad={() => setBannerImageLoaded(true)}
 897 |                                 />
 898 |                             </div>
 899 |                         )}
 900 |                     </div>
 901 | 
 902 |                     {channel.description && (
 903 |                         <div className="channel-description" style={{ marginTop: '1.5rem', marginBottom: '1.5rem' }}>
 904 |                             {channel.description}
 905 |                         </div>
 906 |                     )}
 907 |                     
 908 |                     {(channel.made_for_kids || channel.analytics_account_id || channel.no_index === true || channel.blocked_countries || channel.conditional_redirect || redirectUrl) && (
 909 |                         <div className="channel-metadata" style={{ flexDirection: 'row', flexWrap: 'wrap', gap: '1.5rem' }}>
 910 |                             {redirectUrl && (
 911 |                                 <a 
 912 |                                     href={redirectUrl}
 913 |                                     className="metadata-item"
 914 |                                     onClick={(e) => {
 915 |                                         if (!e.ctrlKey && !e.metaKey && e.button !== 1) {
 916 |                                             e.preventDefault();
 917 |                                             window.open(redirectUrl, '_blank');
 918 |                                         }
 919 |                                     }}
 920 |                                     style={{ cursor: 'pointer', textDecoration: 'none', color: 'inherit' }}
 921 |                                     title="Click to open"
 922 |                                 >
 923 |                                     <span className="metadata-label" data-type="url">Channel Redirect</span>
 924 |                                     <span className="metadata-value">
 925 |                                         {redirectUrl.replace(/^https?:\/\/(www\.)?/, '')}
 926 |                                     </span>
 927 |                                 </a>
 928 |                             )}
 929 |                             {channel.conditional_redirect && (
 930 |                                 <a 
 931 |                                     href={`?type=CHANNEL_ID&id=${channel.conditional_redirect}`}
 932 |                                     className="metadata-item"
 933 |                                     onClick={(e) => {
 934 |                                         if (!e.ctrlKey && !e.metaKey && e.button !== 1) {
 935 |                                             e.preventDefault();
 936 |                                             onChannelClick(channel.conditional_redirect);
 937 |                                         }
 938 |                                     }}
 939 |                                     style={{ cursor: 'pointer', textDecoration: 'none', color: 'inherit' }}
 940 |                                     title="Click to look up this channel"
 941 |                                 >
 942 |                                     <span className="metadata-label" data-type="redirect">Conditional Redirect</span>
 943 |                                     <span className="metadata-value">
 944 |                                         {channel.conditional_redirect}
 945 |                                     </span>
 946 |                                 </a>
 947 |                             )}
 948 |                             {channel.made_for_kids && (
 949 |                                 <div className="metadata-item">
 950 |                                     <span className="metadata-label" data-type="kids">Made for Kids</span>
 951 |                                     <span className="metadata-value">Yes</span>
 952 |                                 </div>
 953 |                             )}
 954 |                             {channel.analytics_account_id && (
 955 |                                 <div className="metadata-item">
 956 |                                     <span className="metadata-label" data-type="analytics">Analytics Account</span>
 957 |                                     <span className="metadata-value">{channel.analytics_account_id}</span>
 958 |                                 </div>
 959 |                             )}
 960 |                             {channel.no_index === true && (
 961 |                                 <div className="metadata-item">
 962 |                                     <span className="metadata-label" data-type="noindex">No Index</span>
 963 |                                     <span className="metadata-value">Yes</span>
 964 |                                 </div>
 965 |                             )}
 966 |                             {channel.blocked_countries && channel.blocked_countries.length > 0 && (
 967 |                                 <div className="metadata-item">
 968 |                                     <span className="metadata-label" data-type="blocked">Blocked Countries</span>
 969 |                                     <span className="metadata-value" style={{ wordBreak: 'break-word' }}>
 970 |                                         {channel.blocked_countries.join(', ')}
 971 |                                     </span>
 972 |                                 </div>
 973 |                             )}
 974 |                         </div>
 975 |                     )}
 976 | 
 977 |                     {channel.keywords && channel.keywords.length > 0 && (
 978 |                         <div className="channel-tags">
 979 |                             {channel.keywords.map((tag, index) => (
 980 |                                 <span key={index} className="channel-tag">
 981 |                                     {tag}
 982 |                                 </span>
 983 |                             ))}
 984 |                         </div>
 985 |                     )}
 986 |                 </div>
 987 |             );
 988 |         };
 989 | 
 990 |         // AFTER - Updated Video Card JSX
 991 |         const VideoList = ({ videos, loading, hasMore, onLoadMore }) => {
 992 |             const containerRef = React.useRef(null);
 993 |             
 994 |             React.useEffect(() => {
 995 |                 const observer = new IntersectionObserver(
 996 |                     entries => {
 997 |                         const firstEntry = entries[0];
 998 |                         if (firstEntry.isIntersecting && hasMore && !loading) {
 999 |                             onLoadMore();
1000 |                         }
1001 |                     },
1002 |                     { threshold: 0.1 }
1003 |                 );
1004 | 
1005 |                 const currentContainer = containerRef.current;
1006 |                 if (currentContainer) {
1007 |                     observer.observe(currentContainer);
1008 |                 }
1009 | 
1010 |                 return () => {
1011 |                     if (currentContainer) {
1012 |                         observer.unobserve(currentContainer);
1013 |                     }
1014 |                 };
1015 |             }, [hasMore, loading, onLoadMore]);
1016 | 
1017 |             const formatCount = (count) => {
1018 |                 if (!count) return '';
1019 |                 if (count >= 1000000000) {
1020 |                     const billions = count / 1000000000;
1021 |                     return `${billions.toFixed(1).replace(/\.0$/, '')}B`;
1022 |                 } else if (count >= 1000000) {
1023 |                     const millions = count / 1000000;
1024 |                     return `${millions.toFixed(1).replace(/\.0$/, '')}M`;
1025 |                 } else if (count >= 1000) {
1026 |                     const thousands = count / 1000;
1027 |                     return `${thousands.toFixed(1).replace(/\.0$/, '')}K`;
1028 |                 }
1029 |                 return count.toLocaleString();
1030 |             };
1031 | 
1032 |             const formatDate = (timestamp) => {
1033 |                 const date = new Date(timestamp * 1000);
1034 |                 const now = new Date();
1035 |                 const diffTime = Math.abs(now - date);
1036 |                 const diffDays = Math.floor(diffTime / (1000 * 60 * 60 * 24));
1037 |                 
1038 |                 if (diffDays === 0) return 'Today';
1039 |                 if (diffDays === 1) return 'Yesterday';
1040 |                 if (diffDays < 7) return `${diffDays} days ago`;
1041 |                 if (diffDays < 30) return `${Math.floor(diffDays / 7)} weeks ago`;
1042 |                 if (diffDays < 365) return `${Math.floor(diffDays / 30)} months ago`;
1043 |                 return `${Math.floor(diffDays / 365)} years ago`;
1044 |             };
1045 | 
1046 |             if (!videos?.length && !loading) return <p>No videos found</p>;
1047 | 
1048 |             return (
1049 |                 <>
1050 |                     <div className="videos-grid">
1051 |                         {videos.map(video => (
1052 |                             <a 
1053 |                                 key={video.video_id} 
1054 |                                 href={`https://youtube.com/watch?v=${video.video_id}`}
1055 |                                 target="_blank"
1056 |                                 rel="noopener noreferrer"
1057 |                                 className="video-card"
1058 |                             >
1059 |                                 <div className="video-thumbnail-container">
1060 |                                     <img 
1061 |                                         src={`https://i.ytimg.com/vi/${video.video_id}/hqdefault.jpg`}
1062 |                                         alt={video.title}
1063 |                                         className="video-thumbnail"
1064 |                                     />
1065 |                                 </div>
1066 |                                 <div className="video-info">
1067 |                                     <h3 className="video-title">
1068 |                                         {video.title}
1069 |                                         {video.views === null && !video.livestream && (
1070 |                                             <span className="hidden-views-tag">Hidden</span>
1071 |                                         )}
1072 |                                     </h3>
1073 |                                     <div className="video-metadata">
1074 |                                         <div className="video-stats">
1075 |                                             <span>{video.views === 0 ? 'No views' : video.views ? `${formatCount(video.views)} views` : ''}</span>
1076 |                                             {video.views !== null && <span className="separator">•</span>}
1077 |                                             <span>{formatDate(video.created_at)}</span>
1078 |                                             {video.comments > 0 && <span className="separator">•</span>}
1079 |                                             {video.comments > 0 && <span>{formatCount(video.comments)}</span>}
1080 |                                         </div>
1081 |                                     </div>
1082 |                                 </div>
1083 |                             </a>
1084 |                         ))}
1085 |                     </div>
1086 |                     {(loading || hasMore) && (
1087 |                         <div ref={containerRef} className="loading-container">
1088 |                             <div className="loading"></div>
1089 |                         </div>
1090 |                     )}
1091 |                 </>
1092 |             );
1093 |         };
1094 | 
1095 |         const SubscriptionList = ({ subscriptions, loading, hasMore, onLoadMore, onSubscriptionClick }) => {
1096 |             const containerRef = React.useRef(null);
1097 |             
1098 |             React.useEffect(() => {
1099 |                 const observer = new IntersectionObserver(
1100 |                     entries => {
1101 |                         const firstEntry = entries[0];
1102 |                         if (firstEntry.isIntersecting && hasMore && !loading) {
1103 |                             onLoadMore();
1104 |                         }
1105 |                     },
1106 |                     { threshold: 0.1 }
1107 |                 );
1108 | 
1109 |                 const currentContainer = containerRef.current;
1110 |                 if (currentContainer) {
1111 |                     observer.observe(currentContainer);
1112 |                 }
1113 | 
1114 |                 return () => {
1115 |                     if (currentContainer) {
1116 |                         observer.unobserve(currentContainer);
1117 |                     }
1118 |                 };
1119 |             }, [hasMore, loading, onLoadMore]);
1120 | 
1121 |             if (!subscriptions?.length && !loading) return <p>No subscriptions found</p>;
1122 | 
1123 |             return (
1124 |                 <>
1125 |                     <div className="subscriptions-grid">
1126 |                         {subscriptions.map(sub => (
1127 |                             <a 
1128 |                                 key={sub.channel_id}
1129 |                                 href={`?type=CHANNEL_ID&id=${sub.channel_id}`}
1130 |                                 className="card subscription-card"
1131 |                                 onClick={(e) => {
1132 |                                     // Only prevent default for regular clicks
1133 |                                     if (!e.ctrlKey && !e.metaKey && e.button !== 1) {
1134 |                                         e.preventDefault();
1135 |                                         onSubscriptionClick(sub.channel_id);
1136 |                                     }
1137 |                                 }}
1138 |                                 style={{ cursor: 'pointer', textDecoration: 'none', color: 'inherit' }}
1139 |                             >
1140 |                                 {sub.profile_picture && (
1141 |                                     <img 
1142 |                                         src={`https://external-content.duckduckgo.com/iu/?u=https://yt3.googleusercontent.com/${sub.profile_picture}`} 
1143 |                                         alt={sub.title} 
1144 |                                         className="subscription-image"
1145 |                                     />
1146 |                                 )}
1147 |                                 <div className="subscription-info">
1148 |                                     <h3 className="subscription-title">{sub.title}</h3>
1149 |                                     <p className="subscription-date">
1150 |                                         {new Date(sub.created_at * 1000).toLocaleDateString('en-GB', {
1151 |                                             day: '2-digit',
1152 |                                             month: '2-digit',
1153 |                                             year: '2-digit'
1154 |                                         })}
1155 |                                     </p>
1156 |                                 </div>
1157 |                             </a>
1158 |                         ))}
1159 |                     </div>
1160 |                     {(loading || hasMore) && (
1161 |                         <div ref={containerRef} className="loading-container">
1162 |                             <div className="loading"></div>
1163 |                         </div>
1164 |                     )}
1165 |                 </>
1166 |             );
1167 |         };
1168 | 
1169 |         const YouTubeLookup = () => {
1170 |             const [lookupType, setLookupType] = useState(() => {
1171 |                 const params = new URLSearchParams(window.location.search);
1172 |                 return params.get('type') || 'HANDLE';
1173 |             });
1174 |             const [channelId, setChannelId] = useState(() => {
1175 |                 const params = new URLSearchParams(window.location.search);
1176 |                 return params.get('id') || '';
1177 |             });
1178 |             const [loading, setLoading] = useState(false);
1179 |             const [channelData, setChannelData] = useState(null);
1180 | 
1181 |             const [videos, setVideos] = useState([]);
1182 |             const [subscriptions, setSubscriptions] = useState([]);
1183 |             const [loadingVideos, setLoadingVideos] = useState(false);
1184 |             const [loadingSubs, setLoadingSubs] = useState(false);
1185 |             const [videosPageToken, setVideosPageToken] = useState(null);
1186 |             const [subsPageToken, setSubsPageToken] = useState(null);
1187 |             const [hasMoreVideos, setHasMoreVideos] = useState(true);
1188 |             const [hasMoreSubs, setHasMoreSubs] = useState(true);
1189 | 
1190 |             const [error, setError] = useState('');
1191 |             const [activeTab, setActiveTab] = useState('videos');
1192 | 
1193 |             // Handle URL changes, including back/forward navigation
1194 |             // Inside the YouTubeLookup component, modify the useEffect:
1195 |             React.useEffect(() => {
1196 |                 const handleLocationChange = () => {
1197 |                     const params = new URLSearchParams(window.location.search);
1198 |                     const typeParam = params.get('type');
1199 |                     const idParam = params.get('id');
1200 |                     
1201 |                     if (typeParam && idParam) {
1202 |                         lookupChannel(idParam, typeParam, true); // true to update form state on back/forward
1203 |                     }
1204 |                 };
1205 | 
1206 |                 window.addEventListener('popstate', handleLocationChange);
1207 |                 handleLocationChange();
1208 | 
1209 |                 return () => window.removeEventListener('popstate', handleLocationChange);
1210 |             }, []);
1211 | 
1212 |             // Modify lookupChannel function to accept both type and id overrides
1213 |             const lookupChannel = async (overrideChannelId = null, overrideType = null, updateFormState = true) => {
1214 |                 const idToUse = overrideChannelId || channelId;
1215 |                 const typeToUse = overrideType || lookupType;
1216 | 
1217 |                 setLoading(true);
1218 |                 setError('');
1219 |                 setVideos([]);
1220 |                 setSubscriptions([]);
1221 |                 setChannelData(null);
1222 |                 
1223 |                 try {
1224 |                     // Update URL
1225 |                     const url = new URL(window.location);
1226 |                     url.searchParams.set('type', typeToUse);
1227 |                     url.searchParams.set('id', idToUse);
1228 |                     window.history.pushState({}, '', url);
1229 | 
1230 |                     const response = await fetch('/api/channel', {
1231 |                         method: 'POST',
1232 |                         headers: {
1233 |                             'Content-Type': 'application/json',
1234 |                         },
1235 |                         body: JSON.stringify({
1236 |                             type: typeToUse,
1237 |                             id: idToUse,
1238 |                         }),
1239 |                     });
1240 |                     
1241 |                     const data = await response.json();
1242 |                     if (!response.ok) {
1243 |                         throw new Error(data.message || 'Failed to fetch channel');
1244 |                     }
1245 | 
1246 |                     // Only update form state if flag is true
1247 |                     if (updateFormState) {
1248 |                         if (overrideType) setLookupType(overrideType);
1249 |                         if (overrideChannelId) setChannelId(overrideChannelId);
1250 |                     }
1251 |                     
1252 |                     setChannelData(data);
1253 |                     fetchVideos(data.channel.user_id);
1254 | 
1255 |                     // Reset to videos tab if we're on subscriptions and there are no subscriptions
1256 |                     if (activeTab === 'subscriptions') {
1257 |                         setActiveTab('videos');
1258 |                     }   
1259 | 
1260 |                     fetchSubscriptions(data.channel.user_id);
1261 |                 } catch (err) {
1262 |                     setError(err.message);
1263 |                 } finally {
1264 |                     setLoading(false);
1265 |                 }
1266 |             };
1267 | 
1268 |             const fetchVideos = async (userId, pageToken = null) => {
1269 |                 setLoadingVideos(true);
1270 |                 try {
1271 |                     const response = await fetch('/api/videos', {
1272 |                         method: 'POST',
1273 |                         headers: {
1274 |                             'Content-Type': 'application/json',
1275 |                         },
1276 |                         body: JSON.stringify({
1277 |                             id: `UU${userId.substring(2)}`,
1278 |                             page_token: pageToken
1279 |                         }),
1280 |                     });
1281 |                     
1282 |                     const data = await response.json();
1283 |                     if (!response.ok) {
1284 |                         throw new Error(data.message || 'Failed to fetch videos');
1285 |                     }
1286 |                     
1287 |                     if (pageToken) {
1288 |                         setVideos(prev => [...prev, ...data.items]);
1289 |                     } else {
1290 |                         setVideos(data.items);
1291 |                     }
1292 |                     
1293 |                     setVideosPageToken(data.page_token);
1294 |                     setHasMoreVideos(!!data.page_token);
1295 |                 } catch (err) {
1296 |                     console.error('Error fetching videos:', err);
1297 |                 } finally {
1298 |                     setLoadingVideos(false);
1299 |                 }
1300 |             };
1301 | 
1302 |             const fetchSubscriptions = async (userId, pageToken = null) => {
1303 |                 setLoadingSubs(true);
1304 |                 try {
1305 |                     const response = await fetch('/api/subscriptions', {
1306 |                         method: 'POST',
1307 |                         headers: {
1308 |                             'Content-Type': 'application/json',
1309 |                         },
1310 |                         body: JSON.stringify({
1311 |                             id: userId,
1312 |                             page_token: pageToken
1313 |                         }),
1314 |                     });
1315 |                     
1316 |                     const data = await response.json();
1317 |                     if (!response.ok) {
1318 |                         throw new Error(data.message || 'Failed to fetch subscriptions');
1319 |                     }
1320 |                     
1321 |                     if (pageToken) {
1322 |                         setSubscriptions(prev => [...prev, ...data.items]);
1323 |                     } else {
1324 |                         setSubscriptions(data.items);
1325 |                     }
1326 |                     
1327 |                     setSubsPageToken(data.page_token);
1328 |                     setHasMoreSubs(!!data.page_token);
1329 |                 } catch (err) {
1330 |                     console.error('Error fetching subscriptions:', err);
1331 |                 } finally {
1332 |                     setLoadingSubs(false);
1333 |                 }
1334 |             };
1335 | 
1336 |             return (
1337 |                 <div className="container">
1338 |                     <div className="card">
1339 |                         <h1 style={{ fontSize: '1.5rem', fontWeight: 'bold', marginBottom: '1rem' }}>
1340 |                             YouTube Channel Lookup
1341 |                         </h1>
1342 |                         <div className="lookup-form">
1343 |                             <select 
1344 |                                 value={lookupType} 
1345 |                                 onChange={(e) => setLookupType(e.target.value)}
1346 |                                 style={{ width: '200px' }}
1347 |                             >
1348 |                                 <option value="HANDLE">Handle (@)</option>
1349 |                                 <option value="CHANNEL_ID">Channel ID</option>
1350 |                                 <option value="USERNAME">Username</option>
1351 |                                 <option value="CUSTOM_URL">Custom URL</option>
1352 |                                 <option value="VANITY">Vanity URL</option>
1353 |                             </select>
1354 |                             <input 
1355 |                                 placeholder="Enter channel identifier"
1356 |                                 value={channelId}
1357 |                                 onChange={(e) => {
1358 |                                     const newValue = e.target.value;
1359 |                                     setChannelId(newValue);
1360 |                                     
1361 |                                     // Handle auto-switching of types
1362 |                                     if (lookupType !== 'CHANNEL_ID' && /^UC[\w-]{22}$/.test(newValue)) {
1363 |                                         setLookupType('CHANNEL_ID');
1364 |                                     } else if (lookupType !== 'HANDLE' && /^@/.test(newValue)) {
1365 |                                         setLookupType('HANDLE');
1366 |                                     } else if (lookupType !== 'CUSTOM_URL' && /^\+/.test(newValue)) {
1367 |                                         setLookupType('CUSTOM_URL');
1368 |                                     } else if (lookupType === 'CHANNEL_ID' && !newValue.startsWith('UC')) {
1369 |                                         // New condition: If in channel ID mode and input doesn't start with UC,
1370 |                                         // switch to handle mode and prepend @
1371 |                                         setLookupType('HANDLE');
1372 |                                         if (!newValue.startsWith('@')) {
1373 |                                             setChannelId(`@${newValue}`);
1374 |                                         }
1375 |                                     }
1376 |                                 }}
1377 |                                 onKeyDown={(e) => {
1378 |                                     if (e.key === 'Enter' && channelId && !loading) {
1379 |                                         const processedId = channelId.replace(/^[@+]/, '');
1380 |                                         lookupChannel(processedId, lookupType, true);
1381 |                                     }
1382 |                                 }}
1383 |                                 style={{ flex: 1 }}
1384 |                             />
1385 |                             <button 
1386 |                                 className="lookup-button" 
1387 |                                 onClick={() => lookupChannel(channelId.replace(/^[@+]/, ''), lookupType, true)} 
1388 |                                 disabled={loading || !channelId}
1389 |                             >
1390 |                                 {loading ? <div className="loading"></div> : (
1391 |                                     <svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
1392 |                                         <circle cx="11" cy="11" r="8"/>
1393 |                                         <line x1="21" y1="21" x2="16.65" y2="16.65"/>
1394 |                                     </svg>
1395 |                                 )}
1396 |                             </button>
1397 |                         </div>
1398 |                         {error && <p className="error">{error}</p>}
1399 |                     </div>
1400 | 
1401 |                     {channelData && (  // Changed this condition
1402 |                         <>
1403 |                         <ChannelInfo 
1404 |                             channel={channelData.channel}
1405 |                             redirectUrl={channelData.redirect_url}
1406 |                             onChannelClick={(channelId) => lookupChannel(channelId, 'CHANNEL_ID', true)}
1407 |                         />
1408 |                             <div className="tabs">
1409 |                                 <div className="tab-list">
1410 |                                     <button 
1411 |                                         className={`tab-button ${activeTab === 'videos' ? 'active' : ''}`}
1412 |                                         onClick={() => setActiveTab('videos')}
1413 |                                     >
1414 |                                         Videos
1415 |                                     </button>
1416 |                                     {subscriptions.length > 0 && (
1417 |                                         <button 
1418 |                                             className={`tab-button ${activeTab === 'subscriptions' ? 'active' : ''}`}
1419 |                                             onClick={() => setActiveTab('subscriptions')}
1420 |                                         >
1421 |                                             Subscriptions
1422 |                                         </button>
1423 |                                     )}
1424 |                                 </div>
1425 |                                 
1426 |                                 {activeTab === 'videos' && (
1427 |                                     <VideoList 
1428 |                                         videos={videos} 
1429 |                                         loading={loadingVideos}
1430 |                                         hasMore={hasMoreVideos}
1431 |                                         onLoadMore={() => channelData?.channel && fetchVideos(channelData.channel.user_id, videosPageToken)}
1432 |                                     />
1433 |                                 )}
1434 | 
1435 |                                 {activeTab === 'subscriptions' && (
1436 |                                     <SubscriptionList 
1437 |                                         subscriptions={subscriptions} 
1438 |                                         loading={loadingSubs}
1439 |                                         hasMore={hasMoreSubs}
1440 |                                         onLoadMore={() => channelData?.channel && fetchSubscriptions(channelData.channel.user_id, subsPageToken)}
1441 |                                         onSubscriptionClick={(channelId) => {
1442 |                                             lookupChannel(channelId, 'CHANNEL_ID', false);
1443 |                                         }}
1444 |                                     />
1445 |                                 )}
1446 |                             </div>
1447 |                         </>
1448 |                     )}
1449 |                 </div>
1450 |             );
1451 |         };
1452 | 
1453 |         // Render the app
1454 |         const root = ReactDOM.createRoot(document.getElementById('root'));
1455 |         root.render(<YouTubeLookup />);
1456 |     </script>
1457 | </body>
1458 | </html>


--------------------------------------------------------------------------------