cairn_cli/cli/

intent.rs

use clap::{Args, Subcommand};
use serde_json::json;

use crate::client::BackpacClient;
use crate::errors::CairnError;

use super::{output_json, Cli};

#[derive(Args, Debug)]
pub struct IntentArgs {
    #[command(subcommand)]
    pub command: IntentCommands,
}

#[derive(Subcommand, Debug)]
pub enum IntentCommands {
    /// Submit a JSON-RPC call as an execution intent with PoI binding.
    Send {
        /// JSON-RPC method (e.g., eth_sendRawTransaction)
        #[arg(long)]
        method: String,

        /// JSON-RPC params as JSON array string
        #[arg(long)]
        params: Option<String>,

        /// Path to a file containing JSON-RPC params (alternative to --params)
        #[arg(long)]
        params_file: Option<String>,

        /// PoI ID to bind this intent to
        #[arg(long)]
        poi_id: Option<String>,

        /// Confidence score (0.0 – 1.0)
        #[arg(long)]
        confidence: Option<f64>,

        /// JSON-RPC ID (default: 1)
        #[arg(long, default_value = "1")]
        id: u64,

        /// Hostname to use for the RPC call (e.g., solana-devnet.backpac.xyz)
        #[arg(long)]
        x_backpac_hostname: Option<String>,
    },

    /// Check the current status of an execution intent.
    Status {
        /// Execution intent ID
        intent_id: String,
    },

    /// Receiver-side verification of an intent's PoI and payment.
    Verify {
        /// Execution intent ID to verify
        intent_id: String,

        /// Receiver DID for ownership check
        #[arg(long)]
        receiver_did: Option<String>,

        /// Minimum confidence threshold (default: 0.30)
        #[arg(long)]
        min_confidence: Option<f64>,
    },

    /// Poll until the intent reaches a terminal state.
    Wait {
        /// Execution intent ID
        intent_id: String,

        /// Poll interval in seconds (default: 2)
        #[arg(long, default_value = "2")]
        interval: u64,

        /// Maximum wait time in seconds (default: 120)
        #[arg(long, default_value = "120")]
        timeout: u64,
    },

    /// View the historical state transitions for an intent.
    History {
        /// Execution intent ID
        intent_id: String,

        /// Maximum results to return (default: 50)
        #[arg(long, default_value = "50")]
        limit: u32,

        /// Filter by specific status
        #[arg(long)]
        status: Option<String>,
    },

    /// List intents for the authenticated agent.
    List {
        /// Filter by status (e.g., CREATED, FINALIZED)
        #[arg(long)]
        status: Option<String>,

        /// Filter by ISO timestamp (show intents since this time)
        #[arg(long)]
        since: Option<String>,

        /// Maximum results to return (default: 20, max: 100)
        #[arg(long, default_value = "20")]
        limit: u32,
    },
}

impl IntentArgs {
    pub async fn execute(&self, cli: &Cli) -> Result<(), CairnError> {
        let client = BackpacClient::new(cli.jwt.as_deref(), cli.api_url.as_deref());

        match &self.command {
            IntentCommands::Send {
                method,
                params,
                params_file,
                poi_id,
                confidence,
                id,
                x_backpac_hostname,
            } => {
                // Resolve params from --params or --params-file
                let params_str = match (params, params_file) {
                    (Some(p), _) => p.clone(),
                    (None, Some(f)) => {
                        std::fs::read_to_string(f)
                            .map_err(|e| CairnError::InvalidInput(format!("Cannot read params file: {}", e)))?
                            .trim()
                            .to_string()
                    }
                    (None, None) => {
                        return Err(CairnError::InvalidInput(
                            "Either --params or --params-file is required".to_string(),
                        ));
                    }
                };

                let params_val: serde_json::Value = serde_json::from_str(&params_str)
                    .map_err(|e| CairnError::InvalidInput(format!("Invalid JSON params: {}", e)))?;

                let body = json!({
                    "jsonrpc": "2.0",
                    "method": method,
                    "params": params_val,
                    "id": id,
                });

                let result = client
                    .rpc_post(&body, poi_id.as_deref(), *confidence, x_backpac_hostname.as_deref())
                    .await?;

                output_json(&result, &cli.output);
                Ok(())
            }

            IntentCommands::Status { intent_id } => {
                let path = format!("/v1/intents/{}", intent_id);
                let result = client.get(&path).await?;
                output_json(&result, &cli.output);
                Ok(())
            }

            IntentCommands::Verify {
                intent_id,
                receiver_did,
                min_confidence,
            } => {
                let mut path = format!("/v1/intents/{}/verify", intent_id);
                let mut query_parts: Vec<String> = Vec::new();

                if let Some(did) = receiver_did {
                    query_parts.push(format!("receiver_did={}", did));
                }
                if let Some(conf) = min_confidence {
                    query_parts.push(format!("min_confidence={}", conf));
                }
                if !query_parts.is_empty() {
                    path = format!("{}?{}", path, query_parts.join("&"));
                }

                let result = client.get(&path).await?;
                output_json(&result, &cli.output);
                Ok(())
            }

            IntentCommands::Wait {
                intent_id,
                interval,
                timeout,
            } => {
                let start = std::time::Instant::now();
                let max_duration = std::time::Duration::from_secs(*timeout);
                let poll_interval = std::time::Duration::from_secs(*interval);
                let terminal_states = ["FINALIZED", "ABORTED", "EXPIRED"];

                loop {
                    if start.elapsed() > max_duration {
                        return Err(CairnError::Timeout);
                    }

                    let path = format!("/v1/intents/{}", intent_id);
                    let result = client.get(&path).await?;

                    let status = result
                        .get("status")
                        .and_then(|v| v.as_str())
                        .unwrap_or("UNKNOWN");

                    if terminal_states.contains(&status) {
                        output_json(&result, &cli.output);
                        return Ok(());
                    }

                    tokio::time::sleep(poll_interval).await;
                }
            }

            IntentCommands::History { intent_id, limit, status } => {
                let mut path = format!("/v1/intents/{}/history?limit={}", intent_id, limit);
                if let Some(s) = status {
                    path = format!("{}&status={}", path, s);
                }
                let result = client.get(&path).await?;
                output_json(&result, &cli.output);
                Ok(())
            }

            IntentCommands::List {
                status,
                since,
                limit,
            } => {
                let mut query_parts: Vec<String> = Vec::new();

                if let Some(s) = status {
                    query_parts.push(format!("status={}", s));
                }
                if let Some(s) = since {
                    query_parts.push(format!("since={}", s));
                }
                query_parts.push(format!("limit={}", limit));

                let path = format!("/v1/intents?{}", query_parts.join("&"));
                let result = client.get(&path).await?;
                output_json(&result, &cli.output);
                Ok(())
            }
        }
    }
}