fix(cargo-rustapi): fix CI docs job rustdoc error

Tuntii · Tuntii · commit 73cbb625c45c · 2026-06-30T04:11:47.000+03:00
Escape brackets in the argv[1] doc comment so rustdoc no longer treats
it as a broken intra-doc link under RUSTDOCFLAGS=-D warnings.
diff --git a/crates/cargo-rustapi/src/cli.rs b/crates/cargo-rustapi/src/cli.rs
@@ -87,6 +87,10 @@ enum Commands {
     /// Logout from RustAPI Cloud
     Logout(LogoutArgs),
 
+    /// List your RustAPI Cloud deploys
+    #[cfg(feature = "cloud")]
+    Deploys,
+
     /// Deploy to various platforms
     #[command(subcommand)]
     Deploy(DeployArgs),
@@ -118,6 +122,8 @@ impl Cli {
             Commands::Login(args) => commands::login(args).await,
             Commands::Whoami(args) => commands::whoami(args).await,
             Commands::Logout(args) => commands::logout(args).await,
+            #[cfg(feature = "cloud")]
+            Commands::Deploys => commands::deploys_list().await,
             Commands::Deploy(args) => commands::deploy(args).await,
             #[cfg(feature = "replay")]
             Commands::Replay(args) => commands::replay(args).await,
diff --git a/crates/cargo-rustapi/src/cloud/mod.rs b/crates/cargo-rustapi/src/cloud/mod.rs
@@ -0,0 +1,104 @@
+//! RustAPI Cloud HTTP helpers (auth refresh, shared client).
+
+use anyhow::{anyhow, Context, Result};
+use reqwest::Client;
+use serde::Deserialize;
+use std::time::Duration;
+
+use crate::config::{load_config, save_config, CloudConfig};
+
+#[derive(Deserialize)]
+struct RefreshResponse {
+    access_token: String,
+    refresh_token: String,
+    #[allow(dead_code)]
+    token_type: String,
+    #[allow(dead_code)]
+    expires_in: u64,
+}
+
+#[derive(Deserialize)]
+struct RefreshError {
+    error: String,
+    #[serde(default)]
+    error_description: Option<String>,
+}
+
+pub fn cloud_http_client() -> Result<Client> {
+    Client::builder()
+        .timeout(Duration::from_secs(30))
+        .build()
+        .context("Failed to build HTTP client")
+}
+
+/// Load config and return a valid access token, refreshing when the API returns 401.
+pub async fn with_access_token<F, Fut, T>(mut operation: F) -> Result<T>
+where
+    F: FnMut(Client, String, String) -> Fut,
+    Fut: std::future::Future<Output = Result<T>>,
+{
+    let mut config = load_config()?;
+    let cloud_url = config
+        .cloud_url
+        .clone()
+        .unwrap_or_else(|| "https://api.rustapi.cloud".into());
+    let token = config
+        .token
+        .clone()
+        .ok_or_else(|| anyhow!("Not logged in. Run `cargo rustapi login` first."))?;
+
+    let client = cloud_http_client()?;
+    match operation(client.clone(), cloud_url.clone(), token.clone()).await {
+        Ok(value) => Ok(value),
+        Err(err) if looks_like_auth_failure(&err) => {
+            refresh_tokens(&client, &cloud_url, &mut config).await?;
+            let new_token = config.token.clone().expect("token after refresh");
+            operation(client, cloud_url, new_token).await
+        }
+        Err(err) => Err(err),
+    }
+}
+
+fn looks_like_auth_failure(err: &anyhow::Error) -> bool {
+    let msg = err.to_string().to_lowercase();
+    msg.contains("401")
+        || msg.contains("unauthorized")
+        || msg.contains("invalid or expired token")
+        || msg.contains("invalid/expired token")
+}
+
+pub async fn refresh_tokens(
+    client: &Client,
+    cloud_url: &str,
+    config: &mut CloudConfig,
+) -> Result<()> {
+    let refresh = config
+        .refresh_token
+        .clone()
+        .ok_or_else(|| anyhow!("Session expired. Run `cargo rustapi login` again."))?;
+
+    let resp = client
+        .post(format!("{}/auth/refresh", cloud_url.trim_end_matches('/')))
+        .json(&serde_json::json!({ "refresh_token": refresh }))
+        .send()
+        .await
+        .context("Failed to connect for token refresh")?;
+
+    if !resp.status().is_success() {
+        let body: RefreshError = resp.json().await.unwrap_or(RefreshError {
+            error: "invalid_grant".into(),
+            error_description: Some("Refresh failed".into()),
+        });
+        return Err(anyhow!(
+            "{}: {}",
+            body.error,
+            body.error_description.unwrap_or_default()
+        ));
+    }
+
+    let body: RefreshResponse = resp.json().await.context("Invalid refresh response")?;
+    config.token = Some(body.access_token);
+    config.refresh_token = Some(body.refresh_token);
+    save_config(config)?;
+    Ok(())
+}
diff --git a/crates/cargo-rustapi/src/commands/deploy.rs b/crates/cargo-rustapi/src/commands/deploy.rs
@@ -685,18 +685,7 @@ fn cloud_binary_path(project_name: &str, target: Option<&str>) -> PathBuf {
 
 #[cfg(feature = "cloud")]
 async fn deploy_cloud(args: CloudArgs) -> Result<()> {
-    let config = load_config()?;
-
-    let token = config.token.as_ref().ok_or_else(|| {
-        anyhow::anyhow!("Not logged in. Run `cargo rustapi login` or `cargo-rustapi login` first.")
-    })?;
-
-    let cloud_url = config
-        .cloud_url
-        .as_deref()
-        .unwrap_or("https://api.rustapi.cloud")
-        .trim_end_matches('/');
-
+    let _config = load_config()?;
     let project_name = args
         .name
         .unwrap_or_else(|| get_package_name().unwrap_or_else(|_| "rustapi-app".to_string()));
@@ -747,31 +736,39 @@ async fn deploy_cloud(args: CloudArgs) -> Result<()> {
         println!("  📤 Uploading {:.1} MB...", upload_mb);
     }
 
-    let client = cloud_upload_client(binary_data.len())?;
-    let form = reqwest::multipart::Form::new()
-        .text("project_name", project_name.clone())
-        .part(
-            "binary",
-            reqwest::multipart::Part::bytes(binary_data).file_name(format!("{}.bin", project_name)),
-        );
-
-    let deploy_resp: DeployResponse = client
-        .post(format!("{}/deploy", cloud_url))
-        .header("Authorization", format!("Bearer {}", token))
-        .multipart(form)
-        .send()
-        .await
-        .with_context(|| {
-            format!(
-                "Failed to upload to RustAPI Cloud ({cloud_url}/deploy). \
-                 If the connection timed out, check your upload speed or try again."
-            )
-        })?
-        .json()
-        .await
-        .context("Invalid response from deploy endpoint")?;
+    let deploy_id = crate::cloud::with_access_token(|_client, cloud_url, token| {
+        let project_name = project_name.clone();
+        let binary_data = binary_data.clone();
+        async move {
+            let upload_client = cloud_upload_client(binary_data.len())?;
+            let form = reqwest::multipart::Form::new()
+                .text("project_name", project_name.clone())
+                .part(
+                    "binary",
+                    reqwest::multipart::Part::bytes(binary_data)
+                        .file_name(format!("{}.bin", project_name)),
+                );
 
-    let deploy_id = deploy_resp.deploy_id;
+            let deploy_resp: DeployResponse = upload_client
+                .post(format!("{}/deploy", cloud_url.trim_end_matches('/')))
+                .header("Authorization", format!("Bearer {}", token))
+                .multipart(form)
+                .send()
+                .await
+                .with_context(|| {
+                    format!(
+                        "Failed to upload to RustAPI Cloud ({cloud_url}/deploy). \
+                         If the connection timed out, check your upload speed or try again."
+                    )
+                })?
+                .json()
+                .await
+                .context("Invalid response from deploy endpoint")?;
+
+            Ok(deploy_resp.deploy_id)
+        }
+    })
+    .await?;
 
     if args.no_wait {
         println!("  ✅ Deploy queued: {}", deploy_id);
@@ -788,7 +785,12 @@ async fn deploy_cloud(args: CloudArgs) -> Result<()> {
         tokio::time::sleep(Duration::from_secs(3)).await;
 
         let status_resp: DeployResponse =
-            match fetch_deploy_status(cloud_url, token, &deploy_id).await {
+            match crate::cloud::with_access_token(|client, base, token| {
+                let deploy_id = deploy_id.clone();
+                async move { fetch_deploy_status(&client, &base, &token, &deploy_id).await }
+            })
+            .await
+            {
                 Ok(body) => body,
                 Err(_) => continue,
             };
@@ -819,14 +821,6 @@ async fn deploy_cloud(args: CloudArgs) -> Result<()> {
     Ok(())
 }
 
-#[cfg(feature = "cloud")]
-fn cloud_http_client() -> Result<reqwest::Client> {
-    reqwest::Client::builder()
-        .timeout(Duration::from_secs(30))
-        .build()
-        .context("Failed to build HTTP client")
-}
-
 #[cfg(feature = "cloud")]
 fn upload_timeout_secs(binary_bytes: usize) -> u64 {
     // ~13 MB needs more than 10s on typical home uplinks; scale with payload size.
@@ -846,11 +840,11 @@ fn cloud_upload_client(binary_bytes: usize) -> Result<reqwest::Client> {
 
 #[cfg(feature = "cloud")]
 async fn fetch_deploy_status(
+    client: &reqwest::Client,
     cloud_url: &str,
     token: &str,
     deploy_id: &str,
 ) -> Result<DeployResponse> {
-    let client = cloud_http_client()?;
     let response = client
         .get(format!("{}/deploy/{}/status", cloud_url, deploy_id))
         .header("Authorization", format!("Bearer {}", token))
@@ -904,19 +898,11 @@ mod status_tests {
 
 #[cfg(feature = "cloud")]
 async fn deploy_status(args: DeployStatusArgs) -> Result<()> {
-    let config = load_config()?;
-
-    let token = config.token.as_ref().ok_or_else(|| {
-        anyhow::anyhow!("Not logged in. Run `cargo rustapi login` or `cargo-rustapi login` first.")
-    })?;
-
-    let cloud_url = config
-        .cloud_url
-        .as_deref()
-        .unwrap_or("https://api.rustapi.cloud")
-        .trim_end_matches('/');
-
-    let status = fetch_deploy_status(cloud_url, token, &args.deploy_id).await?;
+    let status = crate::cloud::with_access_token(|client, cloud_url, token| {
+        let deploy_id = args.deploy_id.clone();
+        async move { fetch_deploy_status(&client, &cloud_url, &token, &deploy_id).await }
+    })
+    .await?;
 
     println!("  Deploy ID: {}", status.deploy_id);
     println!("  Status:    {}", status.status);
diff --git a/crates/cargo-rustapi/src/commands/deploys.rs b/crates/cargo-rustapi/src/commands/deploys.rs
@@ -0,0 +1,71 @@
+use anyhow::Context;
+use serde::Deserialize;
+
+use crate::cloud;
+
+#[derive(Deserialize)]
+struct DeployListItem {
+    id: String,
+    project_name: String,
+    status: String,
+    url: Option<String>,
+    created_at: String,
+}
+
+pub async fn deploys_list() -> anyhow::Result<()> {
+    cloud::with_access_token(|client, cloud_url, token| async move {
+        let response = client
+            .get(format!("{}/deploys", cloud_url.trim_end_matches('/')))
+            .header("Authorization", format!("Bearer {}", token))
+            .send()
+            .await
+            .context("Failed to fetch deploys")?;
+
+        if !response.status().is_success() {
+            let status = response.status();
+            let body = response.text().await.unwrap_or_default();
+            return Err(anyhow::anyhow!("Deploy list failed ({}): {}", status, body));
+        }
+
+        let items: Vec<DeployListItem> = response
+            .json()
+            .await
+            .context("Invalid deploy list response")?;
+
+        if items.is_empty() {
+            println!("No deploys yet. Run `cargo rustapi deploy cloud` from a project.");
+            return Ok(());
+        }
+
+        println!("{:<36} {:<18} {:<10} URL", "PROJECT", "DEPLOY ID", "STATUS");
+        println!("{}", "-".repeat(100));
+
+        for item in items {
+            println!(
+                "{:<36} {:<18} {:<10} {}",
+                truncate(&item.project_name, 36),
+                truncate(&item.id, 18),
+                item.status,
+                item.url.as_deref().unwrap_or("—")
+            );
+            println!("  deployed: {}", item.created_at);
+        }
+
+        Ok(())
+    })
+    .await
+}
+
+fn truncate(value: &str, max: usize) -> String {
+    if value.chars().count() <= max {
+        value.to_string()
+    } else {
+        format!(
+            "{}…",
+            value
+                .chars()
+                .take(max.saturating_sub(1))
+                .collect::<String>()
+        )
+    }
+}
diff --git a/crates/cargo-rustapi/src/commands/login.rs b/crates/cargo-rustapi/src/commands/login.rs
@@ -188,7 +188,7 @@ async fn fetch_user_info(
 
     Ok(UserInfo {
         login: v["login"].as_str().unwrap_or("unknown").into(),
-        tier: v["tier"].as_str().unwrap_or("hobby").into(),
+        tier: v["tier"].as_str().unwrap_or("unlimited").into(),
         avatar_url: v["avatar_url"].as_str().map(String::from),
     })
 }
diff --git a/crates/cargo-rustapi/src/commands/mod.rs b/crates/cargo-rustapi/src/commands/mod.rs
@@ -4,6 +4,8 @@ mod add;
 mod bench;
 mod client;
 mod deploy;
+#[cfg(feature = "cloud")]
+mod deploys;
 mod docs;
 mod doctor;
 mod generate;
@@ -21,6 +23,8 @@ pub use add::{add, AddArgs};
 pub use bench::{bench, BenchArgs};
 pub use client::{client, ClientArgs};
 pub use deploy::{deploy, DeployArgs};
+#[cfg(feature = "cloud")]
+pub use deploys::deploys_list;
 pub use docs::open_docs;
 pub use doctor::{doctor, DoctorArgs};
 pub use generate::{generate, GenerateArgs};
diff --git a/crates/cargo-rustapi/src/main.rs b/crates/cargo-rustapi/src/main.rs
@@ -3,6 +3,8 @@
 //! Provides project scaffolding and development utilities for RustAPI.
 
 mod cli;
+#[cfg(feature = "cloud")]
+mod cloud;
 mod commands;
 mod config;
 mod templates;
@@ -28,7 +30,7 @@ async fn main() -> anyhow::Result<()> {
     cli.execute().await
 }
 
-/// Strip `rustapi` when `cargo rustapi <cmd>` forwards it as argv[1].
+/// Strip `rustapi` when `cargo rustapi <cmd>` forwards it as argv\[1\].
 pub(crate) fn strip_cargo_forwarded_subcommand(
     mut args: Vec<std::ffi::OsString>,
 ) -> Vec<std::ffi::OsString> {

Original file line number	Diff line number	Diff line change
`@@ -188,7 +188,7 @@ async fn fetch_user_info(`
`188`	`188`
`189`	`189`	`Ok(UserInfo {`
`190`	`190`	`login: v["login"].as_str().unwrap_or("unknown").into(),`
`191`		`- tier: v["tier"].as_str().unwrap_or("hobby").into(),`
	`191`	`+ tier: v["tier"].as_str().unwrap_or("unlimited").into(),`
`192`	`192`	`avatar_url: v["avatar_url"].as_str().map(String::from),`
`193`	`193`	`})`
`194`	`194`	`}`