keylimectl: Use API version 3.0 when --push-model is passed

Signed-off-by: Anderson Toshiyuki Sasaki <[email protected]>

Author: ansasaki

keylimectl/src/client/verifier.rs

@@ -159,12 +159,18 @@ pub struct VerifierClient {
 #[derive(Debug)]
 pub struct VerifierClientBuilder<'a> {
     config: Option<&'a Config>,
+    api_version: Option<String>,
+    skip_version_detection: bool,
 }
 
 impl<'a> VerifierClientBuilder<'a> {
     /// Create a new builder instance
     pub fn new() -> Self {
-        Self { config: None }
+        Self {
+            config: None,
+            api_version: None,
+            skip_version_detection: false,
+        }
     }
 
     /// Set the configuration for the client
@@ -173,18 +179,55 @@ impl<'a> VerifierClientBuilder<'a> {
         self
     }
 
+    /// Set a specific API version to use
+    ///
+    /// When set, this version will be used instead of automatic detection.
+    /// Typically used with `skip_version_detection()` for cases where the
+    /// API version is known in advance (e.g., push-model requires v3.0).
+    pub fn api_version(mut self, version: &str) -> Self {
+        self.api_version = Some(version.to_string());
+        self
+    }
+
+    /// Skip automatic API version detection
+    ///
+    /// When set, the client will not attempt to detect the API version
+    /// from the server. Use with `api_version()` to specify the version
+    /// explicitly, or the default version (2.1) will be used.
+    pub fn skip_version_detection(mut self) -> Self {
+        self.skip_version_detection = true;
+        self
+    }
+
     /// Build the VerifierClient with automatic API version detection
     ///
     /// This is the recommended way to create a client for production use,
     /// as it will automatically detect the optimal API version supported
     /// by the verifier service.
+    ///
+    /// If `skip_version_detection()` was called, version detection is skipped.
+    /// If `api_version()` was called, that version is used instead of detection.
     pub async fn build(self) -> Result<VerifierClient, KeylimectlError> {
         let config = self.config.ok_or_else(|| {
             KeylimectlError::validation(
                 "Configuration is required for VerifierClient",
             )
         })?;
 
+        // If version detection is skipped, create client without detection
+        if self.skip_version_detection {
+            let mut client =
+                VerifierClient::new_without_version_detection(config)?;
+
+            // If specific API version was requested, set it
+            if let Some(version) = self.api_version {
+                client.api_version = version;
+            }
+
+            return Ok(client);
+        }
+
+        // Otherwise, use normal version detection
         VerifierClient::new(config).await
     }
 }
@@ -274,7 +317,8 @@ impl VerifierClient {
     ///
     /// Initializes a new `VerifierClient` with the provided configuration
     /// using the default API version without attempting to detect the
-    /// server's supported version. This is mainly useful for testing.
+    /// server's supported version. This is mainly useful for testing and
+    /// when the API version is known in advance (e.g., push-model).
     ///
     /// # Arguments
     ///
@@ -290,7 +334,7 @@ impl VerifierClient {
     /// - TLS certificate files cannot be read
     /// - Certificate/key files are invalid
     /// - HTTP client initialization fails
-    pub(crate) fn new_without_version_detection(
+    pub fn new_without_version_detection(
         config: &Config,
     ) -> Result<Self, KeylimectlError> {
         let base_url = config.verifier_base_url();
@@ -1948,6 +1992,52 @@ mod tests {
             }
         }
 
+        #[tokio::test]
+        async fn test_builder_with_explicit_api_version() {
+            let config = create_test_config();
+            let client = VerifierClient::builder()
+                .config(&config)
+                .api_version("3.0")
+                .skip_version_detection()
+                .build()
+                .await;
+
+            assert!(client.is_ok());
+            let client = client.unwrap();
+            assert_eq!(client.api_version, "3.0");
+        }
+
+        #[tokio::test]
+        async fn test_builder_skip_version_detection() {
+            let config = create_test_config();
+            let client = VerifierClient::builder()
+                .config(&config)
+                .skip_version_detection()
+                .build()
+                .await;
+
+            assert!(client.is_ok());
+            let client = client.unwrap();
+            // Should use default version when skipping detection
+            assert_eq!(client.api_version, "2.1");
+        }
+
+        #[tokio::test]
+        async fn test_builder_with_custom_version() {
+            let config = create_test_config();
+            let client = VerifierClient::builder()
+                .config(&config)
+                .api_version("3.0")
+                .skip_version_detection()
+                .build()
+                .await;
+
+            assert!(client.is_ok());
+            let client = client.unwrap();
+            // Should use the specified version
+            assert_eq!(client.api_version, "3.0");
+        }
+
         #[test]
         fn test_client_struct_fields() {
             let config = create_test_config();

keylimectl/src/commands/agent.rs

@@ -772,19 +772,32 @@ async fn add_agent(
     let agent_data = agent_data.unwrap();
 
     // Step 2: Determine API version and enrollment approach
-    output.step(2, 4, "Detecting verifier API version");
-
-    let verifier_client = VerifierClient::builder()
-        .config(config)
-        .build()
-        .await
-        .map_err(|e| {
-            CommandError::resource_error("verifier", e.to_string())
-        })?;
+    // If push_model is explicitly requested, use API v3.0 without detection
+    let verifier_client = if params.push_model {
+        output.step(2, 4, "Using API v3.0 for push-model");
+        VerifierClient::builder()
+            .config(config)
+            .api_version("3.0")
+            .skip_version_detection()
+            .build()
+            .await
+            .map_err(|e| {
+                CommandError::resource_error("verifier", e.to_string())
+            })?
+    } else {
+        output.step(2, 4, "Detecting verifier API version");
+        VerifierClient::builder()
+            .config(config)
+            .build()
+            .await
+            .map_err(|e| {
+                CommandError::resource_error("verifier", e.to_string())
+            })?
+    };
 
     let api_version =
         verifier_client.api_version().parse::<f32>().unwrap_or(2.1);
-    let is_push_model = api_version >= 3.0;
+    let is_push_model = params.push_model || api_version >= 3.0;
 
     debug!("Detected API version: {api_version}, using push model: {is_push_model}");