use std::path::PathBuf;
use alloy_primitives::{Address, Bytes};
use clap::Parser;
use serde_json::json;
use uuid::Uuid;
use super::{is_proxy_rpc_url, validate_override_rpc_url, CmdError, CmdResult, Ctx};
use crate::envelope::Envelope;
use taskfast_agent::tempo_rpc::{sign_and_broadcast_erc20_transfer, TempoRpcClient};
use taskfast_chains::tempo::{is_allowed_fee_token, is_known_network};
use taskfast_client::api::types::{
CompletionCriterionInput, TaskDraftPrepareRequest, TaskDraftPrepareRequestAssignmentType,
TaskDraftPrepareRequestPickupDeadlineHours, TaskDraftPrepareRequestPosterWalletAddress,
TaskDraftSubmitRequest, TaskDraftSubmitRequestSignature,
};
use taskfast_client::{map_api_error, TaskFastClient};
#[derive(Debug, Parser)]
pub struct Args {
#[arg(long)]
pub title: String,
#[arg(long)]
pub description: String,
#[arg(long)]
pub budget: Option<String>,
#[arg(long, value_delimiter = ',')]
pub capabilities: Vec<String>,
#[arg(long = "criterion")]
pub criteria: Vec<String>,
#[arg(long)]
pub criteria_file: Option<PathBuf>,
#[arg(long)]
pub pickup_deadline_hours: PickupDeadlineHours,
#[arg(long)]
pub execution_deadline: Option<String>,
#[arg(long, default_value = "open")]
pub assignment_type: AssignmentType,
#[arg(long)]
pub direct_agent_id: Option<String>,
#[arg(long, env = "TEMPO_WALLET_ADDRESS")]
pub wallet_address: Option<String>,
#[arg(long, env = "TEMPO_KEY_SOURCE")]
pub keystore: Option<String>,
#[arg(long, env = "TASKFAST_WALLET_PASSWORD_FILE")]
pub wallet_password_file: Option<PathBuf>,
#[arg(long, env = "TEMPO_RPC_URL")]
pub rpc_url: Option<String>,
#[arg(long)]
pub yes: bool,
}
#[derive(Debug, Clone, Copy, clap::ValueEnum)]
pub enum AssignmentType {
Open,
Direct,
}
impl AssignmentType {
fn as_str(self) -> &'static str {
match self {
Self::Open => "open",
Self::Direct => "direct",
}
}
}
impl From<AssignmentType> for TaskDraftPrepareRequestAssignmentType {
fn from(a: AssignmentType) -> Self {
match a {
AssignmentType::Open => Self::Open,
AssignmentType::Direct => Self::Direct,
}
}
}
#[derive(Debug, Clone, Copy, clap::ValueEnum)]
pub enum PickupDeadlineHours {
#[value(name = "1")]
H1,
#[value(name = "4")]
H4,
#[value(name = "12")]
H12,
#[value(name = "24")]
H24,
#[value(name = "72")]
H72,
}
impl PickupDeadlineHours {
fn as_i64(self) -> i64 {
match self {
Self::H1 => 1,
Self::H4 => 4,
Self::H12 => 12,
Self::H24 => 24,
Self::H72 => 72,
}
}
}
impl From<PickupDeadlineHours> for TaskDraftPrepareRequestPickupDeadlineHours {
fn from(h: PickupDeadlineHours) -> Self {
Self::try_from(h.as_i64()).expect("pickup window is a schema-valid choice")
}
}
pub async fn run(ctx: &Ctx, args: Args) -> CmdResult {
if args.description.trim().is_empty() {
return Err(CmdError::Usage(
"--description must not be empty (server requires a non-blank description)".into(),
));
}
ctx.enforce_budget_gate(args.budget.as_deref(), args.yes, "post a task")?;
let wallet_address = args
.wallet_address
.as_deref()
.or(ctx.wallet_address.as_deref())
.ok_or_else(|| {
CmdError::Usage(
"--wallet-address (or TEMPO_WALLET_ADDRESS, or wallet_address in config) required to post a task".into(),
)
})?;
let _: Address = wallet_address.parse().map_err(|e| {
CmdError::Usage(format!("--wallet-address is not a valid EVM address: {e}"))
})?;
let direct_agent_id = match (args.assignment_type, args.direct_agent_id.as_deref()) {
(AssignmentType::Direct, Some(s)) => Some(
Uuid::parse_str(s)
.map_err(|e| CmdError::Usage(format!("--direct-agent-id not a UUID: {e}")))?,
),
(AssignmentType::Direct, None) => {
return Err(CmdError::Usage(
"--assignment-type=direct requires --direct-agent-id".into(),
));
}
(AssignmentType::Open, _) => None,
};
let execution_deadline =
parse_iso_opt(args.execution_deadline.as_deref(), "--execution-deadline")?;
let poster_wallet: TaskDraftPrepareRequestPosterWalletAddress = wallet_address
.parse()
.map_err(|e| CmdError::Usage(format!("--wallet-address rejected by schema: {e}")))?;
let completion_criteria = resolve_criteria(args.criteria_file.as_deref(), &args.criteria)?;
let prep_body = TaskDraftPrepareRequest {
assignment_type: args.assignment_type.into(),
budget_max: args.budget.clone(),
completion_criteria,
description: args.description.clone(),
direct_agent_id,
execution_deadline,
pickup_deadline_hours: args.pickup_deadline_hours.into(),
poster_wallet_address: poster_wallet,
required_capabilities: args.capabilities.clone(),
title: args.title.clone(),
};
if ctx.dry_run {
let network = ctx.environment.network();
let rpc_url = if let Some(ref override_url) = args.rpc_url {
validate_override_rpc_url(override_url, network, ctx.allow_custom_endpoints)?;
override_url.clone()
} else {
format!(
"{}/rpc/{}",
ctx.base_url().trim_end_matches('/'),
network.as_str()
)
};
return Ok(Envelope::success(
ctx.environment,
ctx.dry_run,
json!({
"action": "would_post",
"draft_id": serde_json::Value::Null,
"title": args.title,
"assignment_type": args.assignment_type.as_str(),
"budget_max": args.budget,
"required_capabilities": args.capabilities,
"completion_criteria_count": prep_body.completion_criteria.len(),
"rpc_url": rpc_url,
"wallet_address": wallet_address,
}),
));
}
let client = ctx.client()?;
let (rpc_url, _via_proxy) = resolve_rpc_url(&client, &args, ctx).await?;
let prep = match client.inner().prepare_task_draft(&prep_body).await {
Ok(r) => r.into_inner(),
Err(e) => return Err(map_api_error(e).await.into()),
};
let token_address: Address = prep.token_address.parse().map_err(|e| {
CmdError::Server(format!(
"server returned invalid token_address `{}`: {e}",
prep.token_address
))
})?;
let calldata = decode_0x_bytes(&prep.payload_to_sign)
.map_err(|e| CmdError::Server(format!("server returned invalid payload_to_sign: {e}")))?;
let keystore_ref = args.keystore.as_deref().map(str::to_string).or_else(|| {
ctx.keystore_path
.as_deref()
.and_then(|p| p.to_str().map(str::to_string))
});
let signer = super::wallet_args::load_signer(
keystore_ref.as_deref(),
args.wallet_password_file.as_deref(),
"submission fee",
)?;
let parsed_wallet_address = wallet_address
.parse::<Address>()
.map_err(|_| CmdError::Usage(format!("invalid wallet address: {}", wallet_address)))?;
if signer.address() != parsed_wallet_address {
return Err(CmdError::Usage(format!(
"keystore address {:#x} does not match --wallet-address {}",
signer.address(),
wallet_address
)));
}
let http = ctx.rpc_http_client(&client, &rpc_url);
let rpc = TempoRpcClient::new(http, rpc_url.clone());
let chain_id = rpc
.chain_id()
.await
.map_err(|e| CmdError::Server(format!("tempo rpc eth_chainId: {e}")))?;
if !ctx.allow_custom_endpoints && !is_known_network(chain_id) {
return Err(CmdError::Validation {
code: "unknown_chain".into(),
message: format!(
"RPC reports chain_id={chain_id} which is not a known Tempo or \
local-dev network; refusing to sign. Pass --allow-custom-endpoints \
to override."
),
});
}
if !is_allowed_fee_token(chain_id, &prep.token_address) {
return Err(CmdError::Validation {
code: "fee_token_not_allowed".into(),
message: format!(
"server returned token_address {} which is not on the PathUSD \
allowlist for chain_id={chain_id}. Refusing to sign — this would \
redirect your fee transfer to an arbitrary ERC-20 contract.",
prep.token_address
),
});
}
eprintln!(
"taskfast: signing submission-fee transfer — token={} chain_id={} rpc={}",
prep.token_address, chain_id, rpc_url
);
let _guard = if let Some(ref raw) = keystore_ref {
let path_str = raw.strip_prefix("file:").unwrap_or(raw);
Some(crate::wallet_lock::acquire(std::path::Path::new(path_str))?)
} else {
None
};
let tx_hash =
sign_and_broadcast_erc20_transfer(&rpc, &signer, token_address, Bytes::from(calldata))
.await
.map_err(|e| CmdError::Server(format!("tempo rpc: {e}")))?;
let tx_hash_hex = format!("{tx_hash:#x}");
let signature: TaskDraftSubmitRequestSignature = tx_hash_hex
.parse()
.map_err(|e| CmdError::Server(format!("tx hash rejected by schema pattern: {e}")))?;
let submit_body = TaskDraftSubmitRequest { signature };
let submitted = match client
.inner()
.submit_task_draft(&prep.draft_id, &submit_body)
.await
{
Ok(r) => r.into_inner(),
Err(e) => return Err(map_api_error(e).await.into()),
};
Ok(Envelope::success(
ctx.environment,
ctx.dry_run,
json!({
"task_id": submitted.id,
"draft_id": prep.draft_id,
"submission_fee_tx_hash": tx_hash_hex,
"status": submitted.status,
"submission_fee_status": submitted.submission_fee_status,
}),
))
}
async fn resolve_rpc_url(
client: &TaskFastClient,
args: &Args,
ctx: &Ctx,
) -> Result<(String, bool), CmdError> {
let network = ctx.environment.network();
if let Some(ref override_url) = args.rpc_url {
validate_override_rpc_url(override_url, network, ctx.allow_custom_endpoints)?;
return Ok((override_url.clone(), false));
}
let cfg = client.fetch_network_config().await.map_err(|e| match e {
taskfast_client::Error::Auth(_) | taskfast_client::Error::Validation { .. } => {
CmdError::Server(format!("fetch network config from {}: {e}", ctx.base_url()))
}
other => CmdError::from(other),
})?;
let name = network.as_str();
if !ctx.allow_custom_endpoints
&& ctx.environment != crate::Environment::Local
&& cfg.networks.len() != 1
{
let advertised: Vec<&str> = cfg.networks.keys().map(String::as_str).collect();
let strict = std::env::var("TASKFAST_STRICT_ENV_NETWORK")
.is_ok_and(|v| v == "1" || v.eq_ignore_ascii_case("true"));
if strict {
return Err(CmdError::Server(format!(
"deployment at {} advertises networks {advertised:?}; env {} requires \
exactly [{name}]. Server-side fix tracked in issue #62. Unset \
TASKFAST_STRICT_ENV_NETWORK or pass --allow-custom-endpoints to bypass.",
ctx.base_url(),
ctx.environment.as_str(),
)));
}
tracing::warn!(
api_base = %ctx.base_url(),
env = ctx.environment.as_str(),
expected = name,
advertised = ?advertised,
"deployment advertises additional networks; server-side fix tracked in #62. \
Set TASKFAST_STRICT_ENV_NETWORK=1 to fail-closed."
);
}
let entry = cfg.entry(name).map_err(|e| {
CmdError::Server(format!(
"deployment at {} does not advertise network `{name}`: {e}",
ctx.base_url()
))
})?;
if !is_proxy_rpc_url(&entry.rpc_url, ctx.base_url()) {
return Err(CmdError::Server(format!(
"deployment at {} returned rpc_url {:?} for network `{name}`, \
which is not on the same host. Refusing to route RPC traffic \
off-host.",
ctx.base_url(),
entry.rpc_url,
)));
}
Ok((entry.rpc_url.clone(), true))
}
fn resolve_criteria(
file: Option<&std::path::Path>,
inline: &[String],
) -> Result<Vec<CompletionCriterionInput>, CmdError> {
let mut out = Vec::with_capacity(inline.len());
if let Some(path) = file {
let raw = std::fs::read_to_string(path).map_err(|e| {
CmdError::Usage(format!("read --criteria-file {}: {e}", path.display()))
})?;
let parsed: Vec<CompletionCriterionInput> = serde_json::from_str(&raw).map_err(|e| {
CmdError::Usage(format!(
"--criteria-file {} is not a JSON array of CompletionCriterionInput: {e}",
path.display()
))
})?;
out.extend(parsed);
}
for (i, raw) in inline.iter().enumerate() {
let one: CompletionCriterionInput = serde_json::from_str(raw)
.map_err(|e| CmdError::Usage(format!("--criterion[{i}] not valid JSON: {e}")))?;
out.push(one);
}
Ok(out)
}
fn parse_iso_opt(
s: Option<&str>,
flag: &str,
) -> Result<Option<chrono::DateTime<chrono::Utc>>, CmdError> {
match s {
None => Ok(None),
Some(raw) => chrono::DateTime::parse_from_rfc3339(raw)
.map(|d| Some(d.with_timezone(&chrono::Utc)))
.map_err(|e| CmdError::Usage(format!("{flag} not a valid RFC3339 timestamp: {e}"))),
}
}
fn decode_0x_bytes(s: &str) -> Result<Vec<u8>, String> {
let stripped = s.strip_prefix("0x").unwrap_or(s);
hex::decode(stripped).map_err(|e| e.to_string())
}
#[cfg(test)]
mod tests {
use super::*;
use crate::Network;
#[test]
fn validate_override_rejects_without_opt_in() {
let err = validate_override_rpc_url("https://mallory.example", Network::Mainnet, false)
.expect_err("override without opt-in must be refused");
match err {
CmdError::Usage(msg) => {
assert!(msg.contains("--allow-custom-endpoints"), "msg: {msg}");
}
other => panic!("expected Usage, got {other:?}"),
}
}
#[test]
fn validate_override_accepts_with_opt_in() {
validate_override_rpc_url("https://my-node.example", Network::Testnet, true)
.expect("opt-in bypasses the guard");
}
#[test]
fn validate_override_rejects_plain_http_on_mainnet() {
let err = validate_override_rpc_url("http://my-node.example", Network::Mainnet, true)
.expect_err("plain-http on mainnet is always refused (except loopback)");
assert!(matches!(err, CmdError::Usage(msg) if msg.contains("plain-HTTP")));
}
#[test]
fn validate_override_allows_plain_http_loopback_on_mainnet() {
validate_override_rpc_url("http://127.0.0.1:8545", Network::Mainnet, true)
.expect("loopback bypasses mainnet-HTTPS check");
validate_override_rpc_url("http://localhost:8545", Network::Mainnet, true)
.expect("loopback bypasses mainnet-HTTPS check");
}
#[test]
fn validate_override_allows_plain_http_on_testnet() {
validate_override_rpc_url("http://my-testnet.example", Network::Testnet, true)
.expect("testnet does not enforce HTTPS");
}
#[test]
fn pickup_hours_rejects_out_of_set_and_maps_to_wire() {
use clap::ValueEnum;
assert!(PickupDeadlineHours::from_str("3", false).is_err());
let hours = PickupDeadlineHours::from_str("24", false).expect("24 is valid");
let wire: TaskDraftPrepareRequestPickupDeadlineHours = hours.into();
assert_eq!(i64::from(wire), 24);
}
#[test]
fn network_name_matches_config_map_keys() {
assert_eq!(Network::Mainnet.as_str(), "mainnet");
assert_eq!(Network::Testnet.as_str(), "testnet");
}
}