Initial implementation of fetch-post CLI subcommand

Vibe-coded with cursor-agent

Author: AliSoftware

Cargo.lock

@@ -15,6 +15,7 @@ serde_json = { workspace = true }
 tokio = { workspace = true, features = ["full"] }
 tokio-stream = { workspace = true }
 wp_api = { path = "../wp_api", features = [ "reqwest-request-executor" ] }
+async-trait = { workspace = true }
 
 [[bin]]
 name = "wp_rs_cli"

wp_rs_cli/Cargo.toml

@@ -32,6 +32,26 @@ wp_rs_cli --help
 ## Commands
 
 - `discover-login-url`: Tries connecting to the given URL, and prints the library's relevant error message if unable to.
+- `fetch-post`: Fetch a post and its comments, supporting WordPress.com (Bearer token) and WordPress.org/Jetpack (Application Password) sites.
+
+### fetch-post examples
+
+```bash
+# WordPress.com (Bearer)
+wp_rs_cli fetch-post \
+  --wpcom-site example.wordpress.com \
+  --post-id 123 \
+  --bearer "$WP_BEARER_TOKEN" \
+  --pretty
+
+# WordPress.org/Jetpack (Application Password)
+wp_rs_cli fetch-post \
+  --api-root https://yoursite.com/wp-json \
+  --post-id 123 \
+  --username "$WP_USERNAME" \
+  --password "$WP_APP_PASSWORD" \
+  --pretty
+```
 
 ## License
 

wp_rs_cli/README.md

@@ -1,9 +1,16 @@
-use anyhow::Result;
-use clap::{Parser, Subcommand};
+use anyhow::{Result, anyhow};
+use clap::{ArgGroup, Parser, Subcommand};
 use colored::Colorize;
 use csv::Writer;
 use futures::stream::StreamExt;
 use std::{fmt::Display, fs::File, sync::Arc, time::Duration};
+use wp_api::{
+    comments::CommentListParams,
+    parsed_url::ParsedUrl,
+    posts::{PostId, PostRetrieveParams},
+    request::endpoint::WpOrgSiteApiUrlResolver,
+    wp_com::{WpComBaseUrl, endpoint::WpComDotOrgApiUrlResolver},
+};
 use wp_api::{
     login::url_discovery::{
         AutoDiscoveryAttemptFailure, FetchAndParseApiRootFailure, FindApiRootFailure,
@@ -29,6 +36,8 @@ enum Commands {
         input_file: String,
         output_file: String,
     },
+    /// Fetch a single post and its comments
+    FetchPost(FetchPostArgs),
 }
 
 #[tokio::main]
@@ -46,6 +55,9 @@ async fn main() -> Result<()> {
         } => {
             batch_test_autodiscovery(&login_client, input_file.as_str(), output_file).await?;
         }
+        Commands::FetchPost(args) => {
+            fetch_post_and_comments(args).await?;
+        }
     }
 
     Ok(())
@@ -123,6 +135,180 @@ fn build_login_client() -> WpLoginClient {
     WpLoginClient::new_with_default_middleware_pipeline(request_executor)
 }
 
+#[derive(Debug, Parser)]
+#[command(group(
+    ArgGroup::new("target")
+        .required(true)
+        .args(["wpcom_site", "api_root"]),
+))]
+struct FetchPostArgs {
+    /// The post ID to fetch
+    #[arg(long, value_parser = parse_post_id)]
+    post_id: PostId,
+
+    /// For WordPress.com: site identifier (e.g. example.wordpress.com or numeric site id)
+    #[arg(long)]
+    wpcom_site: Option<String>,
+
+    /// For WordPress.org/Jetpack: full API root URL (must end with /wp-json)
+    #[arg(long)]
+    api_root: Option<String>,
+
+    /// Bearer token for WordPress.com (fallback env: WP_BEARER_TOKEN)
+    #[arg(long)]
+    bearer: Option<String>,
+
+    /// Application Password username for wp.org/Jetpack (fallback env: WP_USERNAME)
+    #[arg(long)]
+    username: Option<String>,
+
+    /// Application Password for wp.org/Jetpack (fallback env: WP_APP_PASSWORD)
+    #[arg(long)]
+    password: Option<String>,
+
+    /// Password for the post if it is password-protected
+    #[arg(long)]
+    post_password: Option<String>,
+
+    /// Max items per page when fetching comments
+    #[arg(long, default_value_t = 100)]
+    per_page: u32,
+
+    /// Output pretty-printed JSON
+    #[arg(long, default_value_t = false)]
+    pretty: bool,
+}
+
+fn parse_post_id(s: &str) -> Result<PostId, String> {
+    s.parse::<i64>()
+        .map(PostId)
+        .map_err(|e| format!("Invalid post id '{s}': {e}"))
+}
+
+#[derive(Debug)]
+enum TargetSiteResolver {
+    WpCom { site: String },
+    WpOrg { api_root: Arc<ParsedUrl> },
+}
+
+fn build_api_client(args: &FetchPostArgs) -> Result<WpApiClient> {
+    // Determine target and auth
+    let target = if let Some(site) = &args.wpcom_site {
+        TargetSiteResolver::WpCom { site: site.clone() }
+    } else if let Some(api_root) = &args.api_root {
+        let parsed = ParsedUrl::try_from(api_root.as_str()).map_err(|_| {
+            anyhow!("Invalid api_root URL: must be a valid URL ending with /wp-json")
+        })?;
+        TargetSiteResolver::WpOrg {
+            api_root: Arc::new(parsed),
+        }
+    } else {
+        return Err(anyhow!(
+            "Either --wpcom-site or --api-root must be provided"
+        ));
+    };
+
+    fn env_or_arg(value: &Option<String>, var: &str) -> Option<String> {
+        value.clone().or_else(|| std::env::var(var).ok())
+    }
+
+    let (resolver, auth_provider): (Arc<dyn ApiUrlResolver>, Arc<WpAuthenticationProvider>) =
+        match target {
+            TargetSiteResolver::WpCom { site } => {
+                let token = env_or_arg(&args.bearer, "WP_BEARER_TOKEN").ok_or_else(|| {
+                    anyhow!("Missing bearer token. Provide --bearer or set WP_BEARER_TOKEN")
+                })?;
+                let resolver: Arc<dyn ApiUrlResolver> = Arc::new(WpComDotOrgApiUrlResolver::new(
+                    site,
+                    WpComBaseUrl::Production,
+                ));
+                let auth_provider = Arc::new(WpAuthenticationProvider::static_with_auth(
+                    WpAuthentication::Bearer { token },
+                ));
+                (resolver, auth_provider)
+            }
+            TargetSiteResolver::WpOrg { api_root } => {
+                let username = env_or_arg(&args.username, "WP_USERNAME").ok_or_else(|| {
+                    anyhow!("Missing username. Provide --username or set WP_USERNAME")
+                })?;
+                let password = env_or_arg(&args.password, "WP_APP_PASSWORD").ok_or_else(|| {
+                    anyhow!(
+                        "Missing application password. Provide --password or set WP_APP_PASSWORD"
+                    )
+                })?;
+                let resolver: Arc<dyn ApiUrlResolver> =
+                    Arc::new(WpOrgSiteApiUrlResolver::new(api_root));
+                let auth_provider = Arc::new(
+                    WpAuthenticationProvider::static_with_username_and_password(username, password),
+                );
+                (resolver, auth_provider)
+            }
+        };
+
+    let request_executor = Arc::new(ReqwestRequestExecutor::new(false, Duration::from_secs(60)));
+    let middleware_pipeline = Arc::new(WpApiMiddlewarePipeline::default());
+
+    #[derive(Debug)]
+    struct NoopNotifier;
+    #[async_trait::async_trait]
+    impl WpAppNotifier for NoopNotifier {
+        async fn requested_with_invalid_authentication(&self) {}
+    }
+
+    Ok(WpApiClient::new(
+        resolver,
+        WpApiClientDelegate {
+            auth_provider,
+            request_executor,
+            middleware_pipeline,
+            app_notifier: Arc::new(NoopNotifier),
+        },
+    ))
+}
+
+async fn fetch_post_and_comments(args: FetchPostArgs) -> Result<()> {
+    let client = build_api_client(&args)?;
+
+    let post = client
+        .posts()
+        .retrieve_with_view_context(
+            &args.post_id,
+            &PostRetrieveParams {
+                password: args.post_password.clone(),
+            },
+        )
+        .await?;
+
+    let mut all_comments = Vec::new();
+    let mut page = client
+        .comments()
+        .list_with_view_context(&CommentListParams {
+            post: vec![args.post_id],
+            per_page: Some(args.per_page),
+            ..Default::default()
+        })
+        .await?;
+    all_comments.extend(page.data);
+    while let Some(next_params) = page.next_page_params.take() {
+        page = client
+            .comments()
+            .list_with_view_context(&next_params)
+            .await?;
+        all_comments.extend(page.data);
+    }
+
+    let out = serde_json::json!({
+        "post": post,
+        "comments": all_comments,
+    });
+    if args.pretty {
+        println!("{}", serde_json::to_string_pretty(&out)?);
+    } else {
+        println!("{}", serde_json::to_string(&out)?);
+    }
+    Ok(())
+}
+
 fn parse_input_file(input_file: &str) -> Result<Vec<BatchTestRow>> {
     Ok(csv::Reader::from_path(input_file)?
         .deserialize::<BatchTestRow>()