taskfast_cli/cmd/
backer.rs1use clap::{Args, Subcommand};
17use serde_json::json;
18use uuid::Uuid;
19
20use super::{CmdError, CmdResult, Ctx};
21use crate::envelope::Envelope;
22
23use taskfast_client::api::types::OperatorBackerCreateRequest;
24use taskfast_client::{map_api_error, TaskFastClient};
25
26#[derive(Debug, Subcommand)]
27pub enum Command {
28 List(ListArgs),
30 Add(AddArgs),
32 Revoke(RevokeArgs),
34}
35
36#[derive(Debug, Args)]
37pub struct ListArgs {
38 #[arg(long)]
40 pub operator: String,
41 #[arg(long, env = "TASKFAST_HUMAN_API_KEY")]
43 pub human_api_key: Option<String>,
44}
45
46#[derive(Debug, Args)]
47pub struct AddArgs {
48 #[arg(long)]
50 pub operator: String,
51 #[arg(long)]
53 pub account: String,
54 #[arg(long)]
56 pub wallet: String,
57 #[arg(long, env = "TASKFAST_HUMAN_API_KEY")]
59 pub human_api_key: Option<String>,
60}
61
62#[derive(Debug, Args)]
63pub struct RevokeArgs {
64 #[arg(long)]
66 pub operator: String,
67 #[arg(long)]
69 pub id: String,
70 #[arg(long, env = "TASKFAST_HUMAN_API_KEY")]
72 pub human_api_key: Option<String>,
73}
74
75pub async fn run(ctx: &Ctx, cmd: Command) -> CmdResult {
76 match cmd {
77 Command::List(a) => list(ctx, a).await,
78 Command::Add(a) => add(ctx, a).await,
79 Command::Revoke(a) => revoke(ctx, a).await,
80 }
81}
82
83fn pat_client(ctx: &Ctx, human_api_key: Option<&str>) -> Result<TaskFastClient, CmdError> {
87 let key = human_api_key
88 .filter(|k| !k.trim().is_empty())
89 .or(ctx.api_key.as_deref())
90 .ok_or(CmdError::MissingApiKey)?;
91 TaskFastClient::from_api_key(ctx.base_url(), key).map_err(CmdError::from)
92}
93
94fn parse_operator(s: &str) -> Result<Uuid, CmdError> {
95 Uuid::parse_str(s).map_err(|e| CmdError::Usage(format!("--operator must be a UUID: {e}")))
96}
97
98async fn list(ctx: &Ctx, args: ListArgs) -> CmdResult {
99 let operator_id = parse_operator(&args.operator)?;
101 let client = pat_client(ctx, args.human_api_key.as_deref())?;
102 let resp = match client.inner().list_operator_backers(&operator_id).await {
103 Ok(v) => v.into_inner(),
104 Err(e) => return Err(map_api_error(e).await.into()),
105 };
106 Ok(Envelope::success(
107 ctx.environment,
108 ctx.dry_run,
109 json!({ "backers": resp.backers }),
110 ))
111}
112
113async fn add(ctx: &Ctx, args: AddArgs) -> CmdResult {
114 let operator_id = parse_operator(&args.operator)?;
115 let backer_account_id = Uuid::parse_str(&args.account)
116 .map_err(|e| CmdError::Usage(format!("--account must be a UUID: {e}")))?;
117 let wallet_address = super::parse_wallet_address(&args.wallet)?;
118
119 if ctx.dry_run {
120 return Ok(Envelope::success(
121 ctx.environment,
122 ctx.dry_run,
123 json!({
124 "action": "would_add_backer",
125 "operator_id": operator_id.to_string(),
126 "backer_account_id": backer_account_id.to_string(),
127 "wallet_address": wallet_address,
128 }),
129 ));
130 }
131
132 let client = pat_client(ctx, args.human_api_key.as_deref())?;
133 let body = OperatorBackerCreateRequest::Variant0 {
137 backer_account_id,
138 backer_wallet_address: wallet_address,
139 };
140 let resp = match client
141 .inner()
142 .approve_operator_backer(&operator_id, &body)
143 .await
144 {
145 Ok(v) => v.into_inner(),
146 Err(e) => return Err(map_api_error(e).await.into()),
147 };
148 Ok(Envelope::success(
149 ctx.environment,
150 ctx.dry_run,
151 json!({ "backer": resp }),
152 ))
153}
154
155async fn revoke(ctx: &Ctx, args: RevokeArgs) -> CmdResult {
156 let operator_id = parse_operator(&args.operator)?;
157 let backer_id = Uuid::parse_str(&args.id)
158 .map_err(|e| CmdError::Usage(format!("--id must be a UUID: {e}")))?;
159
160 if ctx.dry_run {
161 return Ok(Envelope::success(
162 ctx.environment,
163 ctx.dry_run,
164 json!({
165 "action": "would_revoke_backer",
166 "operator_id": operator_id.to_string(),
167 "id": backer_id.to_string(),
168 }),
169 ));
170 }
171
172 let client = pat_client(ctx, args.human_api_key.as_deref())?;
173 let resp = match client
174 .inner()
175 .revoke_operator_backer(&operator_id, &backer_id)
176 .await
177 {
178 Ok(v) => v.into_inner(),
179 Err(e) => return Err(map_api_error(e).await.into()),
180 };
181 Ok(Envelope::success(
182 ctx.environment,
183 ctx.dry_run,
184 json!({ "backer": resp }),
185 ))
186}