1#![allow(missing_docs)]
12
13pub mod cmd;
14pub mod config;
15pub mod envelope;
16pub mod exit;
17pub mod trace;
18pub mod wallet_lock;
19
20pub use config::Config;
21pub use envelope::{Envelope, ErrorPayload};
22pub use exit::ExitCode;
23
24#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, clap::ValueEnum)]
27pub enum Environment {
28 Prod,
29 Staging,
30 Local,
31}
32
33#[derive(Debug, Clone, Copy, PartialEq, Eq)]
39pub enum Network {
40 Mainnet,
41 Testnet,
42}
43
44impl Network {
45 pub fn as_str(self) -> &'static str {
46 match self {
47 Self::Mainnet => "mainnet",
48 Self::Testnet => "testnet",
49 }
50 }
51}
52
53impl Environment {
54 pub const ALL: &'static [Environment] = &[Self::Prod, Self::Staging, Self::Local];
58
59 pub fn as_str(self) -> &'static str {
60 match self {
61 Self::Prod => "production",
62 Self::Staging => "staging",
63 Self::Local => "local",
64 }
65 }
66
67 pub fn api_base(self) -> &'static str {
75 match self {
76 Self::Prod => "https://api.taskfast.app",
77 Self::Staging => "https://staging.api.taskfast.app",
78 Self::Local => "http://127.0.0.1:4000",
79 }
80 }
81
82 pub fn network(self) -> Network {
87 match self {
88 Self::Prod => Network::Mainnet,
89 Self::Staging => Network::Testnet,
90 Self::Local => Network::Testnet,
91 }
92 }
93}
94
95pub fn well_known_api_bases() -> impl Iterator<Item = &'static str> {
102 Environment::ALL.iter().map(|e| e.api_base())
103}
104
105pub fn is_well_known_api_base(url: &str) -> bool {
109 let trimmed = url.trim_end_matches('/');
110 well_known_api_bases().any(|w| w.trim_end_matches('/') == trimmed)
111}
112
113pub fn accounts_url(api_base: &str) -> String {
120 match url::Url::parse(api_base) {
121 Ok(mut u) => {
122 let rewritten = u.host_str().and_then(strip_api_label);
123 if let Some(h) = rewritten {
124 let _ = u.set_host(Some(&h));
125 }
126 u.set_path("/account/tokens");
127 u.set_query(None);
128 u.set_fragment(None);
129 u.to_string()
130 }
131 Err(_) => format!("{}/account/tokens", api_base.trim_end_matches('/')),
133 }
134}
135
136fn strip_api_label(host: &str) -> Option<String> {
141 if let Some(rest) = host.strip_prefix("api.") {
142 return Some(rest.to_owned());
143 }
144 if host.contains(".api.") {
146 return Some(host.replacen(".api.", ".", 1));
147 }
148 None
149}
150
151#[cfg(test)]
152mod tests {
153 use super::{accounts_url, is_well_known_api_base, well_known_api_bases, Environment, Network};
154 use std::collections::HashSet;
155
156 #[test]
157 fn all_covers_every_variant() {
158 let n = Environment::ALL.len();
163 let unique: HashSet<_> = Environment::ALL.iter().copied().collect();
164 assert_eq!(unique.len(), n, "Environment::ALL has duplicates");
165 for env in Environment::ALL {
166 let _ = env.as_str();
169 let _ = env.api_base();
170 let _ = env.network();
171 }
172 }
173
174 #[test]
175 fn each_env_has_unique_api_base() {
176 let bases: HashSet<_> = Environment::ALL.iter().map(|e| e.api_base()).collect();
177 assert_eq!(
178 bases.len(),
179 Environment::ALL.len(),
180 "two envs share an api_base"
181 );
182 }
183
184 #[test]
185 fn env_api_base_table_is_frozen() {
186 assert_eq!(Environment::Prod.api_base(), "https://api.taskfast.app");
188 assert_eq!(
189 Environment::Staging.api_base(),
190 "https://staging.api.taskfast.app"
191 );
192 assert_eq!(Environment::Local.api_base(), "http://127.0.0.1:4000");
193 }
194
195 #[test]
196 fn env_network_table_is_frozen() {
197 assert_eq!(Environment::Prod.network(), Network::Mainnet);
198 assert_eq!(Environment::Staging.network(), Network::Testnet);
199 assert_eq!(Environment::Local.network(), Network::Testnet);
200 }
201
202 #[test]
203 fn well_known_api_bases_cover_every_environment_default() {
204 for env in Environment::ALL {
205 let url = env.api_base();
206 assert!(
207 is_well_known_api_base(url),
208 "api_base for {env:?} ({url}) must be in well_known_api_bases"
209 );
210 }
211 }
212
213 #[test]
214 fn is_well_known_api_base_accepts_exact_defaults() {
215 for url in well_known_api_bases() {
216 assert!(is_well_known_api_base(url), "expected well-known: {url}");
217 }
218 }
219
220 #[test]
221 fn is_well_known_api_base_tolerates_trailing_slash() {
222 assert!(is_well_known_api_base("https://api.taskfast.app/"));
223 assert!(is_well_known_api_base("http://127.0.0.1:4000/"));
224 }
225
226 #[test]
227 fn is_well_known_api_base_rejects_attacker_hosts() {
228 assert!(!is_well_known_api_base("https://evil.example"));
229 assert!(!is_well_known_api_base(
230 "https://api.taskfast.app.evil.example"
231 ));
232 assert!(!is_well_known_api_base("http://api.taskfast.app"));
233 assert!(!is_well_known_api_base("https://staging.taskfast.app"));
234 }
235
236 #[test]
237 fn accounts_url_strips_api_prefix_prod() {
238 assert_eq!(
239 accounts_url("https://api.taskfast.app"),
240 "https://taskfast.app/account/tokens"
241 );
242 }
243
244 #[test]
245 fn accounts_url_strips_api_prefix_staging() {
246 assert_eq!(
247 accounts_url("https://staging.api.taskfast.app"),
248 "https://staging.taskfast.app/account/tokens"
249 );
250 }
251
252 #[test]
253 fn accounts_url_passthrough_localhost_with_port() {
254 assert_eq!(
255 accounts_url("http://127.0.0.1:4000"),
256 "http://127.0.0.1:4000/account/tokens"
257 );
258 }
259
260 #[test]
261 fn accounts_url_passthrough_bare_domain() {
262 assert_eq!(
263 accounts_url("https://taskfast.app"),
264 "https://taskfast.app/account/tokens"
265 );
266 }
267
268 #[test]
269 fn accounts_url_drops_existing_path_and_query() {
270 assert_eq!(
271 accounts_url("https://api.taskfast.app/v1?x=1"),
272 "https://taskfast.app/account/tokens"
273 );
274 }
275
276 #[test]
277 fn accounts_url_malformed_falls_back_to_concat() {
278 assert_eq!(accounts_url("not a url"), "not a url/account/tokens");
279 }
280}