use std::path::PathBuf;
use clap::{Parser, Subcommand};
use serde_json::json;
use super::{CmdError, CmdResult, Ctx};
use crate::envelope::Envelope;
use taskfast_agent::webhooks;
use taskfast_client::api::types::WebhookConfigRequest;
pub const DEFAULT_WORKER_EVENTS: &[&str] = &[
"task_assigned",
"bid_accepted",
"bid_rejected",
"pickup_deadline_warning",
"payment_held",
"payment_disbursed",
"dispute_resolved",
"review_received",
"message_received",
];
#[derive(Debug, Subcommand)]
pub enum Command {
Register(RegisterArgs),
Test,
Subscribe(SubscribeArgs),
Get,
Delete,
}
#[derive(Debug, Parser)]
pub struct RegisterArgs {
#[arg(long)]
pub url: String,
#[arg(long)]
pub secret_file: Option<PathBuf>,
#[arg(long = "event", value_name = "EVENT")]
pub events: Vec<String>,
}
#[derive(Debug, Parser)]
pub struct SubscribeArgs {
#[arg(long = "event", value_name = "EVENT", conflicts_with_all = ["default_events", "list"])]
pub events: Vec<String>,
#[arg(long, conflicts_with_all = ["events", "list"])]
pub default_events: bool,
#[arg(long, conflicts_with_all = ["events", "default_events"])]
pub list: bool,
}
pub async fn run(ctx: &Ctx, cmd: Command) -> CmdResult {
match cmd {
Command::Register(args) => register(ctx, args).await,
Command::Test => test(ctx).await,
Command::Subscribe(args) => subscribe(ctx, args).await,
Command::Get => get(ctx).await,
Command::Delete => delete(ctx).await,
}
}
#[derive(Debug, Clone)]
pub struct WebhookProvisionOutcome {
pub url: String,
pub secret_returned: bool,
pub secret_persisted: bool,
pub secret_file: Option<PathBuf>,
pub subscribed: Option<Vec<String>>,
}
pub async fn provision_webhook(
client: &taskfast_client::TaskFastClient,
url: &str,
secret_file: Option<&std::path::Path>,
events: &[String],
) -> Result<WebhookProvisionOutcome, CmdError> {
let body = WebhookConfigRequest {
url: url.to_string(),
secret: None,
events: None,
};
let cfg = webhooks::configure_webhook(client, &body)
.await
.map_err(CmdError::from)?;
let secret_persisted = match (cfg.secret.as_deref(), secret_file) {
(Some(secret), Some(path)) => {
persist_secret(path, secret)?;
true
}
_ => false,
};
let subscribed = if events.is_empty() {
None
} else {
let subs = webhooks::update_subscriptions(client, events.to_vec())
.await
.map_err(CmdError::from)?;
Some(subs.subscribed_event_types)
};
Ok(WebhookProvisionOutcome {
url: cfg.url,
secret_returned: cfg.secret.is_some(),
secret_persisted,
secret_file: secret_file.map(std::path::Path::to_path_buf),
subscribed,
})
}
async fn register(ctx: &Ctx, args: RegisterArgs) -> CmdResult {
if args.url.trim().is_empty() {
return Err(CmdError::Usage("--url must not be empty".into()));
}
if ctx.dry_run {
return Ok(Envelope::success(
ctx.environment,
ctx.dry_run,
json!({
"action": "would_register",
"url": args.url,
"events": args.events,
"secret_file": args.secret_file.as_ref().map(|p| p.display().to_string()),
}),
));
}
let client = ctx.client()?;
let outcome = provision_webhook(
&client,
&args.url,
args.secret_file.as_deref(),
&args.events,
)
.await?;
let mut data = json!({
"action": "registered",
"url": outcome.url,
"secret_returned": outcome.secret_returned,
"secret_persisted": outcome.secret_persisted,
});
if let Some(path) = outcome.secret_file.as_ref() {
data["secret_file"] = json!(path.display().to_string());
}
if let Some(subscribed) = outcome.subscribed {
data["subscription"] = json!({
"subscribed": subscribed,
});
}
Ok(Envelope::success(ctx.environment, ctx.dry_run, data))
}
async fn test(ctx: &Ctx) -> CmdResult {
if ctx.dry_run {
return Ok(Envelope::success(
ctx.environment,
ctx.dry_run,
json!({ "action": "would_test" }),
));
}
let client = ctx.client()?;
let receipt = webhooks::test_webhook(&client)
.await
.map_err(CmdError::from)?;
Ok(Envelope::success(
ctx.environment,
ctx.dry_run,
json!({
"success": receipt.success,
"status_code": receipt.status_code,
"message": receipt.message,
}),
))
}
async fn subscribe(ctx: &Ctx, args: SubscribeArgs) -> CmdResult {
let client = ctx.client()?;
if args.list {
let subs = webhooks::get_subscriptions(&client)
.await
.map_err(CmdError::from)?;
return Ok(Envelope::success(
ctx.environment,
ctx.dry_run,
json!({
"subscribed": subs.subscribed_event_types,
"available": subs.available_event_types,
}),
));
}
let events: Vec<String> = if args.default_events {
DEFAULT_WORKER_EVENTS
.iter()
.map(|e| (*e).to_string())
.collect()
} else if !args.events.is_empty() {
args.events.clone()
} else {
return Err(CmdError::Usage(
"pass --event <NAME> (repeatable), --default-events, or --list".into(),
));
};
if ctx.dry_run {
return Ok(Envelope::success(
ctx.environment,
ctx.dry_run,
json!({
"action": "would_subscribe",
"events": events,
}),
));
}
let subs = webhooks::update_subscriptions(&client, events)
.await
.map_err(CmdError::from)?;
Ok(Envelope::success(
ctx.environment,
ctx.dry_run,
json!({
"subscribed": subs.subscribed_event_types,
"available": subs.available_event_types,
}),
))
}
async fn get(ctx: &Ctx) -> CmdResult {
let client = ctx.client()?;
let cfg = webhooks::get_webhook(&client)
.await
.map_err(CmdError::from)?;
Ok(Envelope::success(
ctx.environment,
ctx.dry_run,
json!({
"url": cfg.url,
"events": cfg.events,
"created_at": cfg.created_at,
"updated_at": cfg.updated_at,
}),
))
}
async fn delete(ctx: &Ctx) -> CmdResult {
if ctx.dry_run {
return Ok(Envelope::success(
ctx.environment,
ctx.dry_run,
json!({ "action": "would_delete" }),
));
}
let client = ctx.client()?;
webhooks::delete_webhook(&client)
.await
.map_err(CmdError::from)?;
Ok(Envelope::success(
ctx.environment,
ctx.dry_run,
json!({ "action": "deleted" }),
))
}
pub(crate) fn persist_secret(path: &std::path::Path, secret: &str) -> Result<(), CmdError> {
crate::state_store::StateStore::atomic_write_file(path, secret.as_bytes())
.map_err(|e| CmdError::Usage(format!("write secret {}: {e}", path.display())))
}
#[cfg(test)]
mod tests {
use super::*;
use tempfile::TempDir;
#[test]
fn persist_secret_writes_file_with_tight_perms() {
let tmp = TempDir::new().unwrap();
let path = tmp.path().join("hook.secret");
persist_secret(&path, "whsec_abc").unwrap();
let body = std::fs::read_to_string(&path).unwrap();
assert_eq!(body, "whsec_abc");
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
let mode = std::fs::metadata(&path).unwrap().permissions().mode() & 0o777;
assert_eq!(mode, 0o600, "secret file must be 0600");
}
}
#[test]
fn default_worker_events_match_shell_script_list() {
assert_eq!(
DEFAULT_WORKER_EVENTS,
&[
"task_assigned",
"bid_accepted",
"bid_rejected",
"pickup_deadline_warning",
"payment_held",
"payment_disbursed",
"dispute_resolved",
"review_received",
"message_received",
]
);
}
}