bug: Removed hardcoded oauth metadata field values

Signed-off-by: Nick Gerakines <[e-mail]>

crates/atproto-client/src/bin/atproto-client-dpop.rs

···
     );
     println!();
     println!("Examples:");
-    println!(
-        "  # GET request (default behavior without prefix)"
-    );
+    println!("  # GET request (default behavior without prefix)");
     println!(
         "  atproto-client-dpop alice.bsky.social dpop.pem token123 com.atproto.repo.listRecords repo=alice.bsky.social collection=app.bsky.feed.post"
     );
-    println!(
-        "  # GET request (explicit query: prefix)"
-    );
+    println!("  # GET request (explicit query: prefix)");
     println!(
         "  atproto-client-dpop alice.bsky.social dpop.pem token123 query:com.atproto.repo.listRecords repo=alice.bsky.social collection=app.bsky.feed.post"
     );
-    println!(
-        "  # POST request (requires procedure: prefix and JSON file)"
-    );
+    println!("  # POST request (requires procedure: prefix and JSON file)");
     println!(
         "  atproto-client-dpop alice.bsky.social dpop.pem token123 procedure:com.atproto.repo.createRecord data.json"
     );
···
     let xrpc_path_with_prefix = &args[3];
 
     // Parse the xrpc_path prefix (optional, defaults to query:)
-    let (is_procedure, xrpc_path) = if let Some(path) = xrpc_path_with_prefix.strip_prefix("query:") {
+    let (is_procedure, xrpc_path) = if let Some(path) = xrpc_path_with_prefix.strip_prefix("query:")
+    {
         (false, path)
     } else if let Some(path) = xrpc_path_with_prefix.strip_prefix("procedure:") {
         (true, path)
···
         let file_path = &args[arg_index];
         let file_content = std::fs::read_to_string(file_path)
             .map_err(|e| anyhow::anyhow!("Failed to read file '{}': {}", file_path, e))?;
-        json_data = Some(serde_json::from_str(&file_content)
-            .map_err(|e| anyhow::anyhow!("Failed to parse JSON from file '{}': {}", file_path, e))?);
+        json_data = Some(serde_json::from_str(&file_content).map_err(|e| {
+            anyhow::anyhow!("Failed to parse JSON from file '{}': {}", file_path, e)
+        })?);
         arg_index += 1;
     }
 
···
                     eprintln!("Expected format: header=name=value");
                 }
             } else if is_procedure {
-                eprintln!("Warning: Query parameters are not supported for procedure calls. Ignoring: {}", arg);
+                eprintln!(
+                    "Warning: Query parameters are not supported for procedure calls. Ignoring: {}",
+                    arg
+                );
             } else {
                 query_params.insert(key.to_string(), value.to_string());
             }
···
 
     println!("Making DPoP authenticated XRPC call");
     println!("Subject: {}", subject);
-    println!("Request Type: {}", if is_procedure { "POST (procedure)" } else { "GET (query)" });
+    println!(
+        "Request Type: {}",
+        if is_procedure {
+            "POST (procedure)"
+        } else {
+            "GET (query)"
+        }
+    );
     println!("XRPC Path: {}", xrpc_path);
     if !query_params.is_empty() {
         println!("Query Parameters: {:?}", query_params);
···
     println!("Making DPoP authenticated request...");
 
     let response = if is_procedure {
-        let data = json_data.ok_or_else(|| anyhow::anyhow!("No JSON data provided for procedure call"))?;
-        post_dpop_json_with_headers(&http_client, &dpop_auth, &url, data, &additional_headers).await?
+        let data =
+            json_data.ok_or_else(|| anyhow::anyhow!("No JSON data provided for procedure call"))?;
+        post_dpop_json_with_headers(&http_client, &dpop_auth, &url, data, &additional_headers)
+            .await?
     } else {
         get_dpop_json_with_headers(&http_client, &dpop_auth, &url, &additional_headers).await?
     };

crates/atproto-oauth-axum/src/bin/atproto-oauth-tool.rs

···
     }
 
     let oauth_client_config = OAuthClientConfig {
-        client_uri: format!("https://{}", &external_base),
         jwks_uri: format!("https://{}/.well-known/jwks.json", &external_base),
         redirect_uris: format!("https://{}/oauth/callback", &external_base),
         client_id: format!("https://{}/oauth/client-metadata.json", &external_base),
···
             .iter()
             .filter_map(|value| to_public(value).ok())
             .collect(),
+        client_name: None,
+        client_uri: None,
+        logo_uri: None,
+        tos_uri: None,
+        policy_uri: None,
     };
 
     let mut signing_key_storage = HashMap::new();

crates/atproto-oauth-axum/src/handler_metadata.rs

···
 
 use crate::state::OAuthClientConfig;
 
-#[derive(Serialize)]
-struct AuthMetadata {
+// See also: https://atproto.com/specs/oauth#client-id-metadata-document
+#[derive(Serialize, Default)]
+struct AuthMetadata<'a> {
     client_id: String,
     dpop_bound_access_tokens: bool,
-    application_type: &'static str,
+    application_type: &'a str,
     redirect_uris: Vec<String>,
-    client_uri: String,
-    grant_types: Vec<&'static str>,
-    response_types: Vec<&'static str>,
-    scope: &'static str,
-    client_name: &'static str,
-    token_endpoint_auth_method: &'static str,
+    grant_types: Vec<&'a str>,
+    response_types: Vec<&'a str>,
+    scope: &'a str,
+    token_endpoint_auth_method: &'a str,
     jwks_uri: String,
-    subject_type: &'static str,
-    token_endpoint_auth_signing_alg: &'static str,
+    subject_type: &'a str,
+    token_endpoint_auth_signing_alg: &'a str,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(default)]
+    client_name: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(default)]
+    client_uri: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(default)]
+    logo_uri: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(default)]
+    tos_uri: Option<String>,
+
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(default)]
+    policy_uri: Option<String>,
 }
 
 /// Handles requests for OAuth client metadata.
···
     let resp = AuthMetadata {
         application_type: "web",
         client_id: oauth_client_config.client_id.clone(),
-        client_name: "Smoke Signal",
-        client_uri: oauth_client_config.client_uri.clone(),
         dpop_bound_access_tokens: true,
         grant_types: vec!["authorization_code", "refresh_token"],
         jwks_uri: oauth_client_config.jwks_uri.clone(),
···
         token_endpoint_auth_method: "private_key_jwt",
         token_endpoint_auth_signing_alg: "ES256",
         subject_type: "public",
+        client_name: oauth_client_config.client_name.clone(),
+        client_uri: oauth_client_config.client_uri.clone(),
+        logo_uri: oauth_client_config.logo_uri.clone(),
+        tos_uri: oauth_client_config.tos_uri.clone(),
+        policy_uri: oauth_client_config.policy_uri.clone(),
     };
     Json(resp)
 }

crates/atproto-oauth-axum/src/state.rs

···
 /// Contains the essential configuration needed for OAuth client operations.
 #[derive(Clone)]
 pub struct OAuthClientConfig {
-    /// OAuth client URI
-    pub client_uri: String,
     /// OAuth client identifier
     pub client_id: String,
     /// Allowed OAuth redirect URIs
···
     pub jwks_uri: String,
     /// Signing keys for JWT operations
     pub signing_keys: Vec<KeyData>,
+
+    /// Optional human-readable client name
+    pub client_name: Option<String>,
+    /// Optional client website URI
+    pub client_uri: Option<String>,
+    /// Optional client logo URI
+    pub logo_uri: Option<String>,
+    /// Optional terms of service URI
+    pub tos_uri: Option<String>,
+    /// Optional privacy policy URI
+    pub policy_uri: Option<String>,
 }
 
 impl<S> FromRequestParts<S> for OAuthClientConfig
···
 {
     type Rejection = Infallible;
 
+    /// Extracts OAuth client configuration from Axum application state.
     async fn from_request_parts(_parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
         let oauth_client_config = OAuthClientConfig::from_ref(state);
         Ok(oauth_client_config)
···
 impl std::ops::Deref for HttpClient {
     type Target = reqwest::Client;
 
+    /// Provides direct access to the underlying reqwest::Client.
     fn deref(&self) -> &Self::Target {
         &self.0
     }
···
 {
     type Rejection = Infallible;
 
+    /// Extracts HTTP client from Axum application state.
     async fn from_request_parts(_parts: &mut Parts, state: &S) -> Result<Self, Self::Rejection> {
         let client = reqwest::Client::from_ref(state);
         Ok(HttpClient(client))

crates/atproto-xrpcs-helloworld/src/main.rs

···
         }
     });
 
-    println!("XRPC Hello World service started on http://0.0.0.0:{}", port);
+    println!(
+        "XRPC Hello World service started on http://0.0.0.0:{}",
+        port
+    );
 
     // Keep the server running
     server_handle.await.unwrap();

crates/atproto-xrpcs/src/errors.rs

···
         error: anyhow::Error,
     },
 }
-