1use std::fs;
18use std::path::PathBuf;
19
20use clap::{Parser, Subcommand};
21use serde_json::json;
22
23use super::{CmdError, CmdResult, Ctx};
24use crate::envelope::Envelope;
25
26use taskfast_agent::webhooks;
27use taskfast_client::api::types::WebhookConfigRequest;
28
29pub const DEFAULT_WORKER_EVENTS: &[&str] = &[
35 "task_assigned",
36 "bid_accepted",
37 "bid_rejected",
38 "pickup_deadline_warning",
39 "payment_held",
40 "payment_disbursed",
41 "dispute_resolved",
42 "review_received",
43 "message_received",
44];
45
46#[derive(Debug, Subcommand)]
47pub enum Command {
48 Register(RegisterArgs),
52 Test,
55 Subscribe(SubscribeArgs),
58 Get,
60 Delete,
62}
63
64#[derive(Debug, Parser)]
65pub struct RegisterArgs {
66 #[arg(long)]
68 pub url: String,
69
70 #[arg(long)]
75 pub secret_file: Option<PathBuf>,
76
77 #[arg(long = "event", value_name = "EVENT")]
81 pub events: Vec<String>,
82}
83
84#[derive(Debug, Parser)]
85pub struct SubscribeArgs {
86 #[arg(long = "event", value_name = "EVENT", conflicts_with_all = ["default_events", "list"])]
89 pub events: Vec<String>,
90
91 #[arg(long, conflicts_with_all = ["events", "list"])]
95 pub default_events: bool,
96
97 #[arg(long, conflicts_with_all = ["events", "default_events"])]
100 pub list: bool,
101}
102
103pub async fn run(ctx: &Ctx, cmd: Command) -> CmdResult {
104 match cmd {
105 Command::Register(args) => register(ctx, args).await,
106 Command::Test => test(ctx).await,
107 Command::Subscribe(args) => subscribe(ctx, args).await,
108 Command::Get => get(ctx).await,
109 Command::Delete => delete(ctx).await,
110 }
111}
112
113async fn register(ctx: &Ctx, args: RegisterArgs) -> CmdResult {
114 if args.url.trim().is_empty() {
115 return Err(CmdError::Usage("--url must not be empty".into()));
116 }
117
118 if ctx.dry_run {
119 return Ok(Envelope::success(
120 ctx.environment,
121 ctx.dry_run,
122 json!({
123 "action": "would_register",
124 "url": args.url,
125 "events": args.events,
126 "secret_file": args.secret_file.as_ref().map(|p| p.display().to_string()),
127 }),
128 ));
129 }
130
131 let client = ctx.client()?;
132 let body = WebhookConfigRequest {
133 url: args.url.clone(),
134 secret: None,
135 events: None,
140 };
141 let cfg = webhooks::configure_webhook(&client, &body)
142 .await
143 .map_err(CmdError::from)?;
144
145 let secret_persisted = match (cfg.secret.as_deref(), args.secret_file.as_ref()) {
146 (Some(secret), Some(path)) => {
147 persist_secret(path, secret)?;
148 true
149 }
150 _ => false,
151 };
152
153 let subscription = if args.events.is_empty() {
156 None
157 } else {
158 let subs = webhooks::update_subscriptions(&client, args.events.clone())
159 .await
160 .map_err(CmdError::from)?;
161 Some(json!({
162 "subscribed": subs.subscribed_event_types,
163 "available": subs.available_event_types,
164 }))
165 };
166
167 let mut data = json!({
168 "action": "registered",
169 "url": cfg.url,
170 "events": cfg.events,
171 "secret_returned": cfg.secret.is_some(),
172 "secret_persisted": secret_persisted,
173 });
174 if let Some(path) = args.secret_file.as_ref() {
175 data["secret_file"] = json!(path.display().to_string());
176 }
177 if let Some(s) = subscription {
178 data["subscription"] = s;
179 }
180 Ok(Envelope::success(ctx.environment, ctx.dry_run, data))
181}
182
183async fn test(ctx: &Ctx) -> CmdResult {
184 if ctx.dry_run {
185 return Ok(Envelope::success(
186 ctx.environment,
187 ctx.dry_run,
188 json!({ "action": "would_test" }),
189 ));
190 }
191 let client = ctx.client()?;
192 let receipt = webhooks::test_webhook(&client)
193 .await
194 .map_err(CmdError::from)?;
195 Ok(Envelope::success(
196 ctx.environment,
197 ctx.dry_run,
198 json!({
199 "success": receipt.success,
200 "status_code": receipt.status_code,
201 "message": receipt.message,
202 }),
203 ))
204}
205
206async fn subscribe(ctx: &Ctx, args: SubscribeArgs) -> CmdResult {
207 let client = ctx.client()?;
208
209 if args.list {
210 let subs = webhooks::get_subscriptions(&client)
211 .await
212 .map_err(CmdError::from)?;
213 return Ok(Envelope::success(
214 ctx.environment,
215 ctx.dry_run,
216 json!({
217 "subscribed": subs.subscribed_event_types,
218 "available": subs.available_event_types,
219 }),
220 ));
221 }
222
223 let events: Vec<String> = if args.default_events {
224 DEFAULT_WORKER_EVENTS
225 .iter()
226 .map(|e| (*e).to_string())
227 .collect()
228 } else if !args.events.is_empty() {
229 args.events.clone()
230 } else {
231 return Err(CmdError::Usage(
232 "pass --event <NAME> (repeatable), --default-events, or --list".into(),
233 ));
234 };
235
236 if ctx.dry_run {
237 return Ok(Envelope::success(
238 ctx.environment,
239 ctx.dry_run,
240 json!({
241 "action": "would_subscribe",
242 "events": events,
243 }),
244 ));
245 }
246
247 let subs = webhooks::update_subscriptions(&client, events)
248 .await
249 .map_err(CmdError::from)?;
250 Ok(Envelope::success(
251 ctx.environment,
252 ctx.dry_run,
253 json!({
254 "subscribed": subs.subscribed_event_types,
255 "available": subs.available_event_types,
256 }),
257 ))
258}
259
260async fn get(ctx: &Ctx) -> CmdResult {
261 let client = ctx.client()?;
262 let cfg = webhooks::get_webhook(&client)
263 .await
264 .map_err(CmdError::from)?;
265 Ok(Envelope::success(
266 ctx.environment,
267 ctx.dry_run,
268 json!({
269 "url": cfg.url,
270 "events": cfg.events,
271 "created_at": cfg.created_at,
272 "updated_at": cfg.updated_at,
273 }),
274 ))
275}
276
277async fn delete(ctx: &Ctx) -> CmdResult {
278 if ctx.dry_run {
279 return Ok(Envelope::success(
280 ctx.environment,
281 ctx.dry_run,
282 json!({ "action": "would_delete" }),
283 ));
284 }
285 let client = ctx.client()?;
286 webhooks::delete_webhook(&client)
287 .await
288 .map_err(CmdError::from)?;
289 Ok(Envelope::success(
290 ctx.environment,
291 ctx.dry_run,
292 json!({ "action": "deleted" }),
293 ))
294}
295
296pub(crate) fn persist_secret(path: &std::path::Path, secret: &str) -> Result<(), CmdError> {
304 let tmp = path.with_extension("secret.tmp");
305 fs::write(&tmp, secret)
306 .map_err(|e| CmdError::Usage(format!("write {}: {e}", tmp.display())))?;
307 #[cfg(unix)]
308 {
309 use std::os::unix::fs::PermissionsExt;
310 let perms = fs::Permissions::from_mode(0o600);
311 fs::set_permissions(&tmp, perms)
312 .map_err(|e| CmdError::Usage(format!("chmod {}: {e}", tmp.display())))?;
313 }
314 fs::rename(&tmp, path)
315 .map_err(|e| CmdError::Usage(format!("rename into {}: {e}", path.display())))?;
316 Ok(())
317}
318
319#[cfg(test)]
320mod tests {
321 use super::*;
322 use tempfile::TempDir;
323
324 #[test]
325 fn persist_secret_writes_file_with_tight_perms() {
326 let tmp = TempDir::new().unwrap();
327 let path = tmp.path().join("hook.secret");
328 persist_secret(&path, "whsec_abc").unwrap();
329 let body = std::fs::read_to_string(&path).unwrap();
330 assert_eq!(body, "whsec_abc");
331 #[cfg(unix)]
332 {
333 use std::os::unix::fs::PermissionsExt;
334 let mode = std::fs::metadata(&path).unwrap().permissions().mode() & 0o777;
335 assert_eq!(mode, 0o600, "secret file must be 0600");
336 }
337 }
338
339 #[test]
340 fn default_worker_events_match_shell_script_list() {
341 assert_eq!(
344 DEFAULT_WORKER_EVENTS,
345 &[
346 "task_assigned",
347 "bid_accepted",
348 "bid_rejected",
349 "pickup_deadline_warning",
350 "payment_held",
351 "payment_disbursed",
352 "dispute_resolved",
353 "review_received",
354 "message_received",
355 ]
356 );
357 }
358}