1#![deny(
13 clippy::unwrap_used,
14 clippy::expect_used,
15 clippy::indexing_slicing,
16 clippy::panic,
17 clippy::unreachable
18)]
19
20use std::{net::SocketAddr, path::PathBuf, str::FromStr, time::Duration};
21
22use anyhow::{anyhow, bail, Context, Result};
23use sqlx::postgres::{PgConnectOptions, PgSslMode};
24
25pub const LOCAL_ENV_FILE: &str = "secrets/.env";
27
28pub const SYSTEM_ENV_FILE: Option<&str> = option_env!("TEAMCRAFT_SYSTEM_CONFIG");
32
33pub fn load_local_env_file() -> std::result::Result<bool, dotenvy::Error> {
36 load_env_file(LOCAL_ENV_FILE)
37}
38
39fn load_env_file(path: &str) -> std::result::Result<bool, dotenvy::Error> {
40 match dotenvy::from_path(path) {
41 Ok(()) => Ok(true),
42 Err(e) if e.not_found() => Ok(false),
43 Err(e) => Err(e),
44 }
45}
46
47pub fn load_env_files() -> Vec<(String, dotenvy::Error)> {
50 let mut paths: Vec<String> = Vec::new();
51 if let Ok(explicit) = std::env::var("TEAMCRAFT_ENV_FILE") {
52 if !explicit.trim().is_empty() {
53 paths.push(explicit.trim().to_string());
54 }
55 }
56 paths.push(LOCAL_ENV_FILE.to_string());
57 if let Some(system) = SYSTEM_ENV_FILE.filter(|p| !p.is_empty()) {
58 paths.push(system.to_string());
59 }
60 paths
61 .into_iter()
62 .filter_map(|path| load_env_file(&path).err().map(|e| (path, e)))
63 .collect()
64}
65
66pub const KNOWN_VARIABLES: &[&str] = &[
70 "DATABASE_URL",
71 "MATTERMOST_ERROR_WEBHOOK",
72 "TEAMCRAFT_ANTHROPIC_API_KEY",
73 "TEAMCRAFT_APPROVAL_REAUTH",
74 "TEAMCRAFT_ASSISTANT_API_KEY",
75 "TEAMCRAFT_ASSISTANT_BASE_URL",
76 "TEAMCRAFT_ASSISTANT_INTERNAL_URLS",
77 "TEAMCRAFT_ASSISTANT_MAX_CONCURRENT",
78 "TEAMCRAFT_ASSISTANT_MAX_STEPS",
79 "TEAMCRAFT_ASSISTANT_MAX_TOKENS",
80 "TEAMCRAFT_ASSISTANT_MODEL",
81 "TEAMCRAFT_ASSISTANT_PROVIDER",
82 "TEAMCRAFT_ASSISTANT_REQUEST_TIMEOUT",
83 "TEAMCRAFT_ASSISTANT_RETENTION_DAYS",
84 "TEAMCRAFT_ASSISTANT_RUN_TIMEOUT",
85 "TEAMCRAFT_AUDIT_RETENTION_DAYS",
86 "TEAMCRAFT_BACKUP_PASSPHRASE",
87 "TEAMCRAFT_BIND_ADDR",
88 "TEAMCRAFT_BOOTSTRAP_ADMIN_PASSWORD",
89 "TEAMCRAFT_BOOTSTRAP_ADMIN_USERNAME",
90 "TEAMCRAFT_CLAMD_ADDR",
91 "TEAMCRAFT_CLAMD_MAX_MB",
92 "TEAMCRAFT_COOKIE_SECURE",
93 "TEAMCRAFT_DATABASE_URL",
94 "TEAMCRAFT_DB_HOST",
95 "TEAMCRAFT_DB_MAX_CONNECTIONS",
96 "TEAMCRAFT_DB_NAME",
97 "TEAMCRAFT_DB_PASSWORD",
98 "TEAMCRAFT_DB_PORT",
99 "TEAMCRAFT_DB_SSLMODE",
100 "TEAMCRAFT_DB_USER",
101 "TEAMCRAFT_ENV_FILE",
102 "TEAMCRAFT_INSTANCE_NAME",
103 "TEAMCRAFT_LOCAL_AGENTS",
104 "TEAMCRAFT_LOCAL_LOGIN",
105 "TEAMCRAFT_LOG_FORMAT",
106 "TEAMCRAFT_MAIL_FROM",
107 "TEAMCRAFT_MATTERMOST_BOT_TOKEN",
108 "TEAMCRAFT_MATTERMOST_DIRECT",
109 "TEAMCRAFT_MATTERMOST_URL",
110 "TEAMCRAFT_MATTERMOST_WEBHOOK",
111 "TEAMCRAFT_MAX_UPLOAD_MB",
112 "TEAMCRAFT_METRICS_TOKEN",
113 "TEAMCRAFT_OIDC_ADMIN_GROUP",
114 "TEAMCRAFT_OIDC_CLIENT_ID",
115 "TEAMCRAFT_OIDC_CLIENT_SECRET",
116 "TEAMCRAFT_OIDC_DISPLAY_NAME",
117 "TEAMCRAFT_OIDC_EDITOR_GROUP",
118 "TEAMCRAFT_OIDC_GROUPS_CLAIM",
119 "TEAMCRAFT_OIDC_ISSUER_URL",
120 "TEAMCRAFT_OIDC_SCOPES",
121 "TEAMCRAFT_OIDC_TOKEN_IDLE_DAYS",
122 "TEAMCRAFT_OIDC_USERNAME_CLAIM",
123 "TEAMCRAFT_OIDC_VIEWER_GROUP",
124 "TEAMCRAFT_PREVIEW_CACHE_MAX_MB",
125 "TEAMCRAFT_PREVIEW_MAX_MEMORY_MB",
126 "TEAMCRAFT_PREVIEW_MAX_MESH_MB",
127 "TEAMCRAFT_PREVIEW_MAX_RESULT_MB",
128 "TEAMCRAFT_PREVIEW_MAX_STEP_MB",
129 "TEAMCRAFT_PUBLIC_URL",
130 "TEAMCRAFT_REQUEST_DIGEST_HOURS",
131 "TEAMCRAFT_RETENTION_LATEST_GRACE_DAYS",
132 "TEAMCRAFT_SERVER",
133 "TEAMCRAFT_SESSION_TTL_HOURS",
134 "TEAMCRAFT_SIGNIN_MAX_FAILURES",
135 "TEAMCRAFT_SMTP_URL",
136 "TEAMCRAFT_TOKEN",
137 "TEAMCRAFT_UPLOAD_CHUNK_MB",
138 "TEAMCRAFT_VAULT_DIR",
139 "TEAMCRAFT_WEBHOOK_ALLOWED_HOSTS",
140 "TEAMCRAFT_WEBHOOK_ALLOW_PRIVATE",
141 "TEAMCRAFT_WEBHOOK_RETENTION_DAYS",
142];
143
144pub const TOOLING_VARIABLES: &[&str] = &[
147 "TEAMCRAFT_REQUIRE_DB_TESTS",
148 "TEAMCRAFT_REQUIRE_PG_TOOLS",
149 "TEAMCRAFT_SYSTEM_CONFIG",
150 "TEAMCRAFT_TEST_DATABASE_URL",
151 "TEAMCRAFT_WRITE_SIM_FIXTURES",
152];
153
154fn edit_distance(a: &str, b: &str) -> usize {
156 let b: Vec<char> = b.chars().collect();
157 let mut row: Vec<usize> = (0..=b.len()).collect();
158 for (i, ca) in a.chars().enumerate() {
159 let mut diagonal = i;
160 if let Some(first) = row.first_mut() {
161 *first = i + 1;
162 }
163 for (j, cb) in b.iter().enumerate() {
164 let above = row.get(j + 1).copied().unwrap_or(0);
165 let left = row.get(j).copied().unwrap_or(0);
166 let value = (diagonal + usize::from(ca != *cb))
167 .min(above + 1)
168 .min(left + 1);
169 if let Some(slot) = row.get_mut(j + 1) {
170 *slot = value;
171 }
172 diagonal = above;
173 }
174 }
175 row.last().copied().unwrap_or(0)
176}
177
178fn nearest_known(base: &str) -> Option<&'static str> {
180 let limit = (base.len() / 6).clamp(2, 4);
181 KNOWN_VARIABLES
182 .iter()
183 .map(|known| (edit_distance(base, known), *known))
184 .filter(|(distance, _)| *distance <= limit)
185 .min_by_key(|(distance, _)| *distance)
186 .map(|(_, known)| known)
187}
188
189pub fn unknown_variables<I: IntoIterator<Item = String>>(
192 names: I,
193) -> Vec<(String, Option<String>)> {
194 let mut out: Vec<(String, Option<String>)> = names
195 .into_iter()
196 .filter(|n| n.starts_with("TEAMCRAFT_") || n.starts_with("MATTERMOST_"))
197 .filter_map(|name| {
198 let (base, file) = match name.strip_suffix("_FILE") {
199 Some(base) => (base, true),
200 None => (name.as_str(), false),
201 };
202 let is_known = |n: &str| KNOWN_VARIABLES.contains(&n) || TOOLING_VARIABLES.contains(&n);
203 if is_known(&name) || is_known(base) {
205 return None;
206 }
207 let hint = nearest_known(base).map(|known| {
208 if file {
209 format!("{known}_FILE")
210 } else {
211 known.to_string()
212 }
213 });
214 Some((name, hint))
215 })
216 .collect();
217 out.sort();
218 out.dedup();
219 out
220}
221
222pub fn warn_unknown_variables() {
226 let names = std::env::vars_os().map(|(k, _)| k.to_string_lossy().into_owned());
227 for (name, hint) in unknown_variables(names) {
228 match hint {
229 Some(known) => tracing::warn!(
230 "unknown environment variable {name} is ignored; did you mean {known}?"
231 ),
232 None => tracing::warn!("unknown environment variable {name} is ignored"),
233 }
234 }
235}
236
237#[derive(Clone, Copy, Debug, PartialEq, Eq)]
238pub enum LogFormat {
239 Text,
240 Json,
241}
242
243#[derive(Clone)]
244pub struct Config {
245 pub bind_addr: SocketAddr,
247 pub public_url: String,
249 pub instance_name: String,
251 pub database: PgConnectOptions,
253 pub database_password: Option<String>,
257 pub database_display: String,
259 pub db_max_connections: u32,
260 pub vault_dir: PathBuf,
262 pub max_upload_bytes: u64,
263 pub preview: crate::preview::PreviewLimits,
265 pub preview_cache_max_bytes: u64,
269 pub upload_chunk_bytes: u64,
271 pub clamd: Option<crate::malware::ScannerConfig>,
274 pub backup_passphrase: Option<String>,
277 pub session_ttl: Duration,
278 pub approval_reauth: crate::domain::ApprovalReauth,
281 pub audit_retention_days: u32,
285 pub retention_latest_grace_days: u32,
290 pub signin_max_failures: u32,
294 pub oidc_token_idle_days: u32,
300 pub metrics_token: Option<String>,
302 pub cookie_secure: bool,
304 pub log_format: LogFormat,
305 pub bootstrap_admin: Option<BootstrapAdmin>,
307 pub oidc: Option<OidcConfig>,
309 pub local_login: bool,
311 pub setup_without_code: bool,
316 pub mattermost_error_webhook: Option<String>,
318 pub smtp: Option<SmtpConfig>,
320 pub request_digest_hours: u64,
323 pub mattermost: Option<MattermostConfig>,
325 pub assistant: Option<AssistantConfig>,
327 pub local_agents: LocalAgents,
331 pub webhooks: WebhookConfig,
333}
334
335pub const MIN_AUDIT_RETENTION_DAYS: u32 = 30;
338
339const MAX_PREVIEW_CACHE_MB: u64 = 16 * 1024 * 1024;
341
342pub const DEFAULT_WEBHOOK_RETENTION_DAYS: u32 = 30;
344
345#[derive(Clone, Debug, PartialEq, Eq)]
348pub struct WebhookConfig {
349 pub allowed_hosts: Vec<String>,
353 pub allow_private: bool,
356 pub retention_days: u32,
358}
359
360impl Default for WebhookConfig {
361 fn default() -> Self {
362 WebhookConfig {
363 allowed_hosts: Vec::new(),
364 allow_private: false,
365 retention_days: DEFAULT_WEBHOOK_RETENTION_DAYS,
366 }
367 }
368}
369
370#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
383pub enum LocalAgents {
384 #[default]
386 Allowed,
387 Off,
390}
391
392pub const LOCAL_AGENT_HEADER: &str = "x-teamcraft-client";
395pub const LOCAL_AGENT_HEADER_VALUE: &str = "desktop-agent";
397
398impl LocalAgents {
399 pub fn parse(raw: &str) -> Result<LocalAgents> {
401 match raw.trim().to_ascii_lowercase().as_str() {
402 "allowed" => Ok(LocalAgents::Allowed),
403 "off" => Ok(LocalAgents::Off),
404 other => bail!("TEAMCRAFT_LOCAL_AGENTS must be 'allowed' or 'off', got '{other}'"),
405 }
406 }
407
408 pub fn as_str(self) -> &'static str {
409 match self {
410 LocalAgents::Allowed => "allowed",
411 LocalAgents::Off => "off",
412 }
413 }
414
415 pub fn allowed(self) -> bool {
416 self == LocalAgents::Allowed
417 }
418}
419
420fn parse_allowed_hosts(raw: &str) -> Result<Vec<String>> {
422 let mut hosts = Vec::new();
423 for entry in raw.split([',', ' ', '\n', '\t']).map(str::trim) {
424 if entry.is_empty() {
425 continue;
426 }
427 let host = entry
428 .trim_start_matches('[')
429 .trim_end_matches(']')
430 .trim_end_matches('.')
431 .to_ascii_lowercase();
432 let name = host.strip_prefix("*.").unwrap_or(&host);
433 if name.is_empty()
434 || name.contains('*')
435 || !name
436 .chars()
437 .all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '-' | ':'))
438 {
439 bail!(
440 "TEAMCRAFT_WEBHOOK_ALLOWED_HOSTS: '{entry}' is not a host name, an IP address or *.domain"
441 );
442 }
443 let host = host
445 .parse::<std::net::IpAddr>()
446 .map(|ip| ip.to_string())
447 .unwrap_or(host);
448 if !hosts.contains(&host) {
449 hosts.push(host);
450 }
451 }
452 Ok(hosts)
453}
454
455pub const DEFAULT_ASSISTANT_MODEL: &str = "claude-opus-5-5";
457pub const DEFAULT_ASSISTANT_MAX_STEPS: u32 = 12;
459pub const DEFAULT_ASSISTANT_MAX_TOKENS: u32 = 16_000;
461pub const DEFAULT_ASSISTANT_REQUEST_TIMEOUT: u64 = 180;
463pub const DEFAULT_ASSISTANT_RUN_TIMEOUT: u64 = 240;
465pub const DEFAULT_ASSISTANT_MAX_CONCURRENT: usize = 4;
467pub const DEFAULT_ASSISTANT_RETENTION_DAYS: u32 = 30;
469
470#[derive(Clone, Copy, Debug, PartialEq, Eq)]
472pub enum AssistantProvider {
473 Anthropic,
475 OpenAi,
477 OpenAiCompatible,
480}
481
482impl AssistantProvider {
483 pub fn as_str(self) -> &'static str {
484 match self {
485 AssistantProvider::Anthropic => "anthropic",
486 AssistantProvider::OpenAi => "openai",
487 AssistantProvider::OpenAiCompatible => "openai-compatible",
488 }
489 }
490
491 pub fn parse(s: &str) -> Option<AssistantProvider> {
492 match s.trim().to_ascii_lowercase().as_str() {
493 "anthropic" => Some(AssistantProvider::Anthropic),
494 "openai" => Some(AssistantProvider::OpenAi),
495 "openai-compatible" => Some(AssistantProvider::OpenAiCompatible),
496 _ => None,
497 }
498 }
499
500 pub fn default_base_url(self) -> Option<&'static str> {
502 match self {
503 AssistantProvider::Anthropic => Some("https://api.anthropic.com/v1"),
504 AssistantProvider::OpenAi => Some("https://api.openai.com/v1"),
505 AssistantProvider::OpenAiCompatible => None,
506 }
507 }
508}
509
510#[derive(Clone)]
511pub struct AssistantConfig {
512 pub provider: AssistantProvider,
513 pub base_url: String,
515 pub api_key: Option<String>,
517 pub model: String,
519 pub max_steps: u32,
521 pub max_tokens: u32,
523 pub request_timeout: Duration,
525 pub run_timeout: Duration,
527 pub max_concurrent: usize,
529 pub retention_days: u32,
531 pub internal_urls: Vec<String>,
535}
536
537impl std::fmt::Debug for AssistantConfig {
538 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
539 f.debug_struct("AssistantConfig")
540 .field("provider", &self.provider)
541 .field("base_url", &self.base_url)
542 .field("api_key", &self.api_key.as_ref().map(|_| "<redacted>"))
543 .field("model", &self.model)
544 .field("max_steps", &self.max_steps)
545 .field("max_tokens", &self.max_tokens)
546 .field("request_timeout", &self.request_timeout)
547 .field("run_timeout", &self.run_timeout)
548 .field("max_concurrent", &self.max_concurrent)
549 .field("retention_days", &self.retention_days)
550 .field("internal_urls", &self.internal_urls)
551 .finish()
552 }
553}
554
555impl AssistantConfig {
556 pub fn host(&self) -> String {
558 reqwest::Url::parse(&self.base_url)
559 .ok()
560 .and_then(|u| u.host_str().map(str::to_string))
561 .unwrap_or_default()
562 }
563
564 pub fn label(&self) -> String {
566 format!("{}:{}@{}", self.provider.as_str(), self.model, self.host())
567 }
568
569 pub fn is_internal(&self) -> bool {
571 self.internal_urls
572 .iter()
573 .any(|u| url_is_under(&self.base_url, u))
574 }
575
576 pub fn insecure_key_warning(&self) -> Option<String> {
579 self.api_key.as_ref()?;
580 let url = reqwest::Url::parse(&self.base_url).ok()?;
581 if url.scheme() != "http" {
582 return None;
583 }
584 let host = url.host_str()?;
585 let bare = host.trim_start_matches('[').trim_end_matches(']');
586 let loopback = host.eq_ignore_ascii_case("localhost")
587 || host.to_ascii_lowercase().ends_with(".localhost")
588 || bare
589 .parse::<std::net::IpAddr>()
590 .is_ok_and(|ip| ip.is_loopback());
591 (!loopback).then(|| {
592 format!(
593 "the assistant API key is sent over plain http to {host}: use https, or a host on this computer"
594 )
595 })
596 }
597}
598
599fn assistant_config<F: Fn(&str) -> Option<String>>(
602 env: &Env<F>,
603) -> Result<Option<AssistantConfig>> {
604 let read_key = |name: &str| -> Result<Option<String>> {
606 let key = env
607 .get(name)?
608 .map(|k| k.trim().to_string())
609 .filter(|k| !k.is_empty());
610 if let Some(k) = &key {
611 if k.chars().any(|c| c.is_whitespace() || c.is_control()) {
612 bail!("{name} must not contain spaces or line breaks");
613 }
614 }
615 Ok(key)
616 };
617 let primary = read_key("TEAMCRAFT_ASSISTANT_API_KEY")?;
618 let alias = read_key("TEAMCRAFT_ANTHROPIC_API_KEY")?;
619 let api_key = match (primary, alias) {
620 (Some(a), Some(b)) if a != b => bail!(
621 "TEAMCRAFT_ASSISTANT_API_KEY and TEAMCRAFT_ANTHROPIC_API_KEY are both set with \
622 different values: set only TEAMCRAFT_ASSISTANT_API_KEY"
623 ),
624 (a, b) => a.or(b),
625 };
626 let explicit = env
627 .get("TEAMCRAFT_ASSISTANT_PROVIDER")?
628 .map(|p| p.trim().to_string())
629 .filter(|p| !p.is_empty());
630 let provider = match &explicit {
631 Some(p) => AssistantProvider::parse(p).ok_or_else(|| {
632 anyhow!("TEAMCRAFT_ASSISTANT_PROVIDER must be anthropic, openai or openai-compatible")
633 })?,
634 None => AssistantProvider::Anthropic,
635 };
636 let base_url = env
637 .get("TEAMCRAFT_ASSISTANT_BASE_URL")?
638 .map(|u| u.trim().to_string())
639 .filter(|u| !u.is_empty());
640 let enabled = match provider {
643 AssistantProvider::OpenAiCompatible => api_key.is_some() || base_url.is_some(),
644 _ => api_key.is_some(),
645 };
646 if !enabled {
647 return Ok(None);
648 }
649 let base_url = match base_url.as_deref().or(provider.default_base_url()) {
650 Some(u) => u.to_string(),
651 None => bail!("TEAMCRAFT_ASSISTANT_BASE_URL is required for TEAMCRAFT_ASSISTANT_PROVIDER=openai-compatible"),
652 };
653 let parsed = reqwest::Url::parse(&base_url)
654 .map_err(|e| anyhow!("TEAMCRAFT_ASSISTANT_BASE_URL is not a valid URL: {e}"))?;
655 if !matches!(parsed.scheme(), "http" | "https") || parsed.host_str().is_none() {
656 bail!("TEAMCRAFT_ASSISTANT_BASE_URL must be an http:// or https:// URL with a host");
657 }
658 if !parsed.username().is_empty() || parsed.password().is_some() {
659 bail!("TEAMCRAFT_ASSISTANT_BASE_URL must not contain a user name or password");
660 }
661 if parsed.query().is_some() || parsed.fragment().is_some() {
662 bail!("TEAMCRAFT_ASSISTANT_BASE_URL must not contain a query or fragment");
663 }
664 let base_url = base_url.trim_end_matches('/').to_string();
665
666 let model = env
667 .get("TEAMCRAFT_ASSISTANT_MODEL")?
668 .map(|m| m.trim().to_string())
669 .filter(|m| !m.is_empty());
670 let model = match (model, provider) {
671 (Some(m), _) => m,
672 (None, AssistantProvider::Anthropic) => DEFAULT_ASSISTANT_MODEL.to_string(),
673 (None, _) => bail!("TEAMCRAFT_ASSISTANT_MODEL is required for the openai providers"),
674 };
675 if !model
676 .chars()
677 .all(|c| c.is_ascii_alphanumeric() || matches!(c, '-' | '.' | '_' | ':' | '@' | '/'))
678 {
679 bail!("TEAMCRAFT_ASSISTANT_MODEL must be a model id such as {DEFAULT_ASSISTANT_MODEL}");
680 }
681 let max_steps = env.parse_or("TEAMCRAFT_ASSISTANT_MAX_STEPS", DEFAULT_ASSISTANT_MAX_STEPS)?;
682 if !(1..=50).contains(&max_steps) {
683 bail!("TEAMCRAFT_ASSISTANT_MAX_STEPS must be between 1 and 50");
684 }
685 let max_tokens = env.parse_or(
686 "TEAMCRAFT_ASSISTANT_MAX_TOKENS",
687 DEFAULT_ASSISTANT_MAX_TOKENS,
688 )?;
689 if !(256..=200_000).contains(&max_tokens) {
690 bail!("TEAMCRAFT_ASSISTANT_MAX_TOKENS must be between 256 and 200000");
691 }
692 let request_timeout = env.parse_or(
693 "TEAMCRAFT_ASSISTANT_REQUEST_TIMEOUT",
694 DEFAULT_ASSISTANT_REQUEST_TIMEOUT,
695 )?;
696 let run_timeout = env.parse_or(
697 "TEAMCRAFT_ASSISTANT_RUN_TIMEOUT",
698 DEFAULT_ASSISTANT_RUN_TIMEOUT.max(request_timeout),
699 )?;
700 if !(5..=3600).contains(&request_timeout) {
701 bail!("TEAMCRAFT_ASSISTANT_REQUEST_TIMEOUT must be between 5 and 3600 seconds");
702 }
703 if !(5..=7200).contains(&run_timeout) || run_timeout < request_timeout {
704 bail!(
705 "TEAMCRAFT_ASSISTANT_RUN_TIMEOUT must be between 5 and 7200 seconds and at least \
706 TEAMCRAFT_ASSISTANT_REQUEST_TIMEOUT"
707 );
708 }
709 let max_concurrent = env.parse_or(
710 "TEAMCRAFT_ASSISTANT_MAX_CONCURRENT",
711 DEFAULT_ASSISTANT_MAX_CONCURRENT,
712 )?;
713 if !(1..=64).contains(&max_concurrent) {
714 bail!("TEAMCRAFT_ASSISTANT_MAX_CONCURRENT must be between 1 and 64");
715 }
716 let retention_days = env.parse_or(
717 "TEAMCRAFT_ASSISTANT_RETENTION_DAYS",
718 DEFAULT_ASSISTANT_RETENTION_DAYS,
719 )?;
720 if !(1..=365).contains(&retention_days) {
721 bail!("TEAMCRAFT_ASSISTANT_RETENTION_DAYS must be between 1 and 365");
722 }
723 let internal_urls = internal_urls(env)?;
724 Ok(Some(AssistantConfig {
725 provider,
726 base_url,
727 api_key,
728 model,
729 max_steps,
730 max_tokens,
731 request_timeout: Duration::from_secs(request_timeout),
732 run_timeout: Duration::from_secs(run_timeout),
733 max_concurrent,
734 retention_days,
735 internal_urls,
736 }))
737}
738
739pub fn url_is_under(base_url: &str, listed: &str) -> bool {
742 let (Ok(a), Ok(b)) = (reqwest::Url::parse(base_url), reqwest::Url::parse(listed)) else {
743 return false;
744 };
745 if a.scheme() != b.scheme()
746 || a.host_str().map(str::to_ascii_lowercase) != b.host_str().map(str::to_ascii_lowercase)
747 || a.port_or_known_default() != b.port_or_known_default()
748 {
749 return false;
750 }
751 let (pa, pb) = (
752 a.path().trim_end_matches('/'),
753 b.path().trim_end_matches('/'),
754 );
755 pa == pb || pa.starts_with(&format!("{pb}/"))
756}
757
758fn internal_urls<F: Fn(&str) -> Option<String>>(env: &Env<F>) -> Result<Vec<String>> {
761 let raw = env
762 .get("TEAMCRAFT_ASSISTANT_INTERNAL_URLS")?
763 .unwrap_or_default();
764 let mut out = Vec::new();
765 for entry in raw
766 .split(|c: char| c == ',' || c.is_whitespace())
767 .filter(|e| !e.is_empty())
768 {
769 let url = reqwest::Url::parse(entry).map_err(|e| {
770 anyhow!("TEAMCRAFT_ASSISTANT_INTERNAL_URLS: '{entry}' is not a valid URL: {e}")
771 })?;
772 if !matches!(url.scheme(), "http" | "https")
773 || url.host_str().is_none()
774 || !url.username().is_empty()
775 || url.password().is_some()
776 || url.query().is_some()
777 || url.fragment().is_some()
778 {
779 bail!(
780 "TEAMCRAFT_ASSISTANT_INTERNAL_URLS: '{entry}' must be an http:// or https:// URL \
781 with a host and without credentials, query or fragment"
782 );
783 }
784 out.push(entry.trim_end_matches('/').to_string());
785 }
786 Ok(out)
787}
788
789#[derive(Clone)]
790pub struct SmtpConfig {
791 pub url: String,
794 pub from: String,
796}
797
798#[derive(Clone)]
799pub struct MattermostConfig {
800 pub bot: Option<MattermostBot>,
802 pub webhook: Option<String>,
804 pub direct: bool,
807}
808
809impl MattermostConfig {
810 pub fn is_direct(&self) -> bool {
812 self.bot.is_some() || self.direct
813 }
814
815 pub fn is_legacy_webhook(&self) -> bool {
817 self.bot.is_none() && self.webhook.is_some()
818 }
819}
820
821#[derive(Clone)]
822pub struct MattermostBot {
823 pub url: String,
825 pub token: String,
827}
828
829#[derive(Clone)]
830pub struct BootstrapAdmin {
831 pub username: String,
832 pub password: String,
833}
834
835#[derive(Clone)]
836pub struct OidcConfig {
837 pub issuer_url: String,
839 pub client_id: String,
840 pub client_secret: String,
841 pub scopes: String,
843 pub display_name: String,
845 pub groups_claim: String,
847 pub username_claim: String,
849 pub admin_group: String,
851 pub editor_group: String,
853 pub viewer_group: Option<String>,
857}
858
859impl OidcConfig {
860 pub fn redirect_uri(&self, public_url: &str) -> String {
862 format!("{public_url}/auth/oidc/callback")
863 }
864}
865
866impl Config {
867 pub fn from_env() -> Result<Self> {
869 Self::from_lookup(|key| std::env::var(key).ok())
870 }
871
872 pub fn from_lookup<F>(lookup: F) -> Result<Self>
874 where
875 F: Fn(&str) -> Option<String>,
876 {
877 let env = Env { lookup };
878
879 let bind_addr: SocketAddr = env
880 .get("TEAMCRAFT_BIND_ADDR")?
881 .unwrap_or_else(|| "127.0.0.1:8080".to_string())
882 .parse()
883 .context("TEAMCRAFT_BIND_ADDR must be a socket address such as 0.0.0.0:8080")?;
884
885 let public_url = env
886 .get("TEAMCRAFT_PUBLIC_URL")?
887 .unwrap_or_else(|| format!("http://localhost:{}", bind_addr.port()))
888 .trim_end_matches('/')
889 .to_string();
890 if !(public_url.starts_with("http://") || public_url.starts_with("https://")) {
891 bail!("TEAMCRAFT_PUBLIC_URL must start with http:// or https://");
892 }
893
894 let instance_name = env
895 .get("TEAMCRAFT_INSTANCE_NAME")?
896 .unwrap_or_else(|| "TeamCraft".to_string());
897
898 let (database, database_display, database_password) = database_options(&env)?;
899
900 let db_max_connections = env.parse_or("TEAMCRAFT_DB_MAX_CONNECTIONS", 10u32)?;
901 if db_max_connections == 0 {
902 bail!("TEAMCRAFT_DB_MAX_CONNECTIONS must be at least 1");
903 }
904
905 let vault_dir = PathBuf::from(
906 env.get("TEAMCRAFT_VAULT_DIR")?
907 .unwrap_or_else(|| "./data/vault".to_string()),
908 );
909 let max_upload_mb = env.parse_or("TEAMCRAFT_MAX_UPLOAD_MB", 512u64)?;
910 if max_upload_mb == 0 {
911 bail!("TEAMCRAFT_MAX_UPLOAD_MB must be at least 1");
912 }
913 let preview = {
914 let defaults = crate::preview::PreviewLimits::default();
915 let mb = |key: &str, default: u64, min: u64| -> Result<u64> {
916 let value = env.parse_or(key, default / (1024 * 1024))?;
917 if !(min..=1_048_576).contains(&value) {
918 bail!("{key} must be between {min} and 1048576");
919 }
920 Ok(value * 1024 * 1024)
921 };
922 crate::preview::PreviewLimits {
923 max_result_bytes: mb(
924 "TEAMCRAFT_PREVIEW_MAX_RESULT_MB",
925 defaults.max_result_bytes,
926 1,
927 )?,
928 max_mesh_bytes: mb("TEAMCRAFT_PREVIEW_MAX_MESH_MB", defaults.max_mesh_bytes, 1)?,
929 max_step_bytes: mb("TEAMCRAFT_PREVIEW_MAX_STEP_MB", defaults.max_step_bytes, 1)?,
930 max_memory_bytes: mb(
932 "TEAMCRAFT_PREVIEW_MAX_MEMORY_MB",
933 defaults.max_memory_bytes,
934 0,
935 )?,
936 }
937 };
938 let preview_cache_max_mb = env.parse_or("TEAMCRAFT_PREVIEW_CACHE_MAX_MB", 0u64)?;
940 if preview_cache_max_mb > MAX_PREVIEW_CACHE_MB {
941 bail!("TEAMCRAFT_PREVIEW_CACHE_MAX_MB must be between 0 (no limit) and {MAX_PREVIEW_CACHE_MB}");
942 }
943 let upload_chunk_mb = env.parse_or("TEAMCRAFT_UPLOAD_CHUNK_MB", 16u64)?;
944 if !(1..=1024).contains(&upload_chunk_mb) {
945 bail!("TEAMCRAFT_UPLOAD_CHUNK_MB must be between 1 and 1024");
946 }
947 let clamd_max_mb = env.parse_or("TEAMCRAFT_CLAMD_MAX_MB", 25u64)?;
948 if !(1..=4096).contains(&clamd_max_mb) {
949 bail!("TEAMCRAFT_CLAMD_MAX_MB must be between 1 and 4096");
950 }
951 let clamd = match env
952 .get("TEAMCRAFT_CLAMD_ADDR")?
953 .map(|a| a.trim().to_string())
954 .filter(|a| !a.is_empty())
955 {
956 Some(addr) => {
957 let unix = addr.strip_prefix("unix:");
958 if unix.is_some_and(|p| !p.starts_with('/'))
959 || (unix.is_none() && !addr.contains(':'))
960 {
961 bail!("TEAMCRAFT_CLAMD_ADDR must be host:port or unix:/path/to/clamd.socket");
962 }
963 Some(crate::malware::ScannerConfig {
964 addr,
965 max_bytes: clamd_max_mb * 1024 * 1024,
966 timeout: Duration::from_secs(120),
967 })
968 }
969 None => None,
970 };
971 let backup_passphrase = env
972 .get("TEAMCRAFT_BACKUP_PASSPHRASE")?
973 .map(|p| p.trim_end_matches(['\r', '\n']).to_string())
974 .filter(|p| !p.is_empty());
975 if backup_passphrase
976 .as_ref()
977 .is_some_and(|p| p.chars().count() < 12)
978 {
979 bail!("TEAMCRAFT_BACKUP_PASSPHRASE must have at least 12 characters");
980 }
981
982 let session_ttl_hours = env.parse_or("TEAMCRAFT_SESSION_TTL_HOURS", 72u64)?;
983 if session_ttl_hours == 0 {
984 bail!("TEAMCRAFT_SESSION_TTL_HOURS must be at least 1");
985 }
986
987 let signin_max_failures = env.parse_or("TEAMCRAFT_SIGNIN_MAX_FAILURES", 10u32)?;
988 let metrics_token = env
989 .get("TEAMCRAFT_METRICS_TOKEN")?
990 .map(|t| t.trim().to_string())
991 .filter(|t| !t.is_empty());
992 if metrics_token.as_ref().is_some_and(|t| t.len() < 16) {
993 bail!("TEAMCRAFT_METRICS_TOKEN must be at least 16 characters");
994 }
995
996 let approval_reauth = match env.get("TEAMCRAFT_APPROVAL_REAUTH")? {
997 None => crate::domain::ApprovalReauth::Off,
998 Some(raw) => crate::domain::ApprovalReauth::parse(&raw).ok_or_else(|| {
999 anyhow::anyhow!(
1000 "TEAMCRAFT_APPROVAL_REAUTH must be off, release or every_decision (got '{raw}')"
1001 )
1002 })?,
1003 };
1004
1005 let oidc_token_idle_days = env.parse_or("TEAMCRAFT_OIDC_TOKEN_IDLE_DAYS", 0u32)?;
1006 if oidc_token_idle_days > 3650 {
1007 bail!("TEAMCRAFT_OIDC_TOKEN_IDLE_DAYS must be between 0 (off) and 3650");
1008 }
1009
1010 let audit_retention_days = env.parse_or("TEAMCRAFT_AUDIT_RETENTION_DAYS", 0u32)?;
1011 if audit_retention_days != 0
1012 && !(MIN_AUDIT_RETENTION_DAYS..=36_500).contains(&audit_retention_days)
1013 {
1014 bail!(
1015 "TEAMCRAFT_AUDIT_RETENTION_DAYS must be 0 (keep for ever) or between \
1016 {MIN_AUDIT_RETENTION_DAYS} and 36500"
1017 );
1018 }
1019
1020 let retention_latest_grace_days = env.parse_or(
1021 "TEAMCRAFT_RETENTION_LATEST_GRACE_DAYS",
1022 crate::services::retention::DEFAULT_LATEST_GRACE_DAYS,
1023 )?;
1024 if retention_latest_grace_days > crate::services::retention::MAX_LATEST_GRACE_DAYS {
1025 bail!(
1026 "TEAMCRAFT_RETENTION_LATEST_GRACE_DAYS must be between 0 (no automatic removal) and {}",
1027 crate::services::retention::MAX_LATEST_GRACE_DAYS
1028 );
1029 }
1030
1031 let cookie_secure = match env.get("TEAMCRAFT_COOKIE_SECURE")? {
1032 Some(v) => parse_bool(&v).context("TEAMCRAFT_COOKIE_SECURE must be true or false")?,
1033 None => public_url.starts_with("https://"),
1034 };
1035
1036 let log_format = match env
1037 .get("TEAMCRAFT_LOG_FORMAT")?
1038 .unwrap_or_else(|| "text".into())
1039 .to_ascii_lowercase()
1040 .as_str()
1041 {
1042 "text" => LogFormat::Text,
1043 "json" => LogFormat::Json,
1044 other => bail!("TEAMCRAFT_LOG_FORMAT must be 'text' or 'json', got '{other}'"),
1045 };
1046
1047 let bootstrap_admin = env
1048 .get("TEAMCRAFT_BOOTSTRAP_ADMIN_PASSWORD")?
1049 .map(|password| -> Result<BootstrapAdmin> {
1050 let username = env
1051 .get("TEAMCRAFT_BOOTSTRAP_ADMIN_USERNAME")?
1052 .unwrap_or_else(|| "admin".to_string());
1053 Ok(BootstrapAdmin { username, password })
1054 })
1055 .transpose()?;
1056
1057 let oidc = oidc_config(&env)?;
1058 let local_login = match env.get("TEAMCRAFT_LOCAL_LOGIN")? {
1059 Some(v) => parse_bool(&v).context("TEAMCRAFT_LOCAL_LOGIN must be true or false")?,
1060 None => oidc.is_none(),
1061 };
1062 if oidc.is_none() && !local_login {
1063 bail!("no login method enabled: configure TEAMCRAFT_OIDC_ISSUER_URL or set TEAMCRAFT_LOCAL_LOGIN=true");
1064 }
1065
1066 let mattermost_error_webhook = env.get("MATTERMOST_ERROR_WEBHOOK")?;
1067 if let Some(url) = &mattermost_error_webhook {
1068 if !(url.starts_with("https://") || url.starts_with("http://")) {
1069 bail!("MATTERMOST_ERROR_WEBHOOK must be an http(s) URL");
1070 }
1071 }
1072
1073 let smtp = match env.get("TEAMCRAFT_SMTP_URL")? {
1074 Some(url) => {
1075 if !(url.starts_with("smtp://") || url.starts_with("smtps://")) {
1076 bail!("TEAMCRAFT_SMTP_URL must start with smtp:// or smtps://");
1077 }
1078 let from = env.get("TEAMCRAFT_MAIL_FROM")?.context(
1079 "TEAMCRAFT_MAIL_FROM (e.g. TeamCraft <teamcraft@example.org>) is required when TEAMCRAFT_SMTP_URL is set",
1080 )?;
1081 if from.parse::<lettre::message::Mailbox>().is_err() {
1082 bail!("TEAMCRAFT_MAIL_FROM is not a valid address: use 'Name <address>' or 'address'");
1083 }
1084 Some(SmtpConfig { url, from })
1085 }
1086 None => None,
1087 };
1088 let request_digest_hours = env.parse_or("TEAMCRAFT_REQUEST_DIGEST_HOURS", 24u64)?;
1089 if request_digest_hours > 24 * 30 {
1090 bail!("TEAMCRAFT_REQUEST_DIGEST_HOURS must be between 0 (off) and 720");
1091 }
1092 let webhook = match env.get("TEAMCRAFT_MATTERMOST_WEBHOOK")? {
1093 Some(webhook) => {
1094 if !(webhook.starts_with("https://") || webhook.starts_with("http://")) {
1095 bail!("TEAMCRAFT_MATTERMOST_WEBHOOK must be an http(s) URL");
1096 }
1097 Some(webhook)
1098 }
1099 None => None,
1100 };
1101 let bot = match (
1102 env.get("TEAMCRAFT_MATTERMOST_URL")?,
1103 env.get("TEAMCRAFT_MATTERMOST_BOT_TOKEN")?,
1104 ) {
1105 (Some(url), Some(token)) => {
1106 if !(url.starts_with("https://") || url.starts_with("http://")) {
1107 bail!("TEAMCRAFT_MATTERMOST_URL must be an http(s) URL");
1108 }
1109 Some(MattermostBot {
1110 url: url.trim().trim_end_matches('/').to_string(),
1111 token: token.trim().to_string(),
1112 })
1113 }
1114 (None, None) => None,
1115 _ => bail!(
1116 "TEAMCRAFT_MATTERMOST_URL and TEAMCRAFT_MATTERMOST_BOT_TOKEN must be set together"
1117 ),
1118 };
1119 let direct = match env.get("TEAMCRAFT_MATTERMOST_DIRECT")? {
1120 Some(v) => {
1121 parse_bool(&v).context("TEAMCRAFT_MATTERMOST_DIRECT must be true or false")?
1122 }
1123 None => false,
1124 };
1125 let mattermost = (bot.is_some() || webhook.is_some()).then_some(MattermostConfig {
1126 bot,
1127 webhook,
1128 direct,
1129 });
1130 let assistant = assistant_config(&env)?;
1131 let local_agents = match env.get("TEAMCRAFT_LOCAL_AGENTS")? {
1132 Some(raw) => LocalAgents::parse(&raw)?,
1133 None => LocalAgents::Allowed,
1134 };
1135
1136 let webhooks = WebhookConfig {
1137 allowed_hosts: match env.get("TEAMCRAFT_WEBHOOK_ALLOWED_HOSTS")? {
1138 Some(raw) => parse_allowed_hosts(&raw)?,
1139 None => Vec::new(),
1140 },
1141 allow_private: match env.get("TEAMCRAFT_WEBHOOK_ALLOW_PRIVATE")? {
1142 Some(v) => parse_bool(&v)
1143 .context("TEAMCRAFT_WEBHOOK_ALLOW_PRIVATE must be true or false")?,
1144 None => false,
1145 },
1146 retention_days: env.parse_or(
1147 "TEAMCRAFT_WEBHOOK_RETENTION_DAYS",
1148 DEFAULT_WEBHOOK_RETENTION_DAYS,
1149 )?,
1150 };
1151 if !(1..=3650).contains(&webhooks.retention_days) {
1152 bail!("TEAMCRAFT_WEBHOOK_RETENTION_DAYS must be between 1 and 3650");
1153 }
1154
1155 Ok(Config {
1156 bind_addr,
1157 public_url,
1158 instance_name,
1159 database,
1160 database_password,
1161 database_display,
1162 db_max_connections,
1163 vault_dir,
1164 max_upload_bytes: max_upload_mb * 1024 * 1024,
1165 preview,
1166 preview_cache_max_bytes: preview_cache_max_mb * 1024 * 1024,
1167 upload_chunk_bytes: upload_chunk_mb * 1024 * 1024,
1168 clamd,
1169 backup_passphrase,
1170 session_ttl: Duration::from_secs(session_ttl_hours * 3600),
1171 approval_reauth,
1172 audit_retention_days,
1173 retention_latest_grace_days,
1174 signin_max_failures,
1175 oidc_token_idle_days,
1176 metrics_token,
1177 cookie_secure,
1178 log_format,
1179 bootstrap_admin,
1180 oidc,
1181 local_login,
1182 setup_without_code: false,
1183 mattermost_error_webhook,
1184 smtp,
1185 request_digest_hours,
1186 mattermost,
1187 assistant,
1188 local_agents,
1189 webhooks,
1190 })
1191 }
1192
1193 pub fn summary(&self) -> String {
1195 format!(
1196 "bind={} public_url={} database={} vault={} max_upload={}MiB upload_chunk={}MiB malware_scan={} session_ttl={}h cookie_secure={} oidc={} local_login={} mattermost_errors={} smtp={} request_digest={}h mattermost_notifications={} assistant={} local_agents={} webhook_targets={}",
1197 self.bind_addr,
1198 self.public_url,
1199 self.database_display,
1200 self.vault_dir.display(),
1201 self.max_upload_bytes / (1024 * 1024),
1202 self.upload_chunk_bytes / (1024 * 1024),
1203 self.clamd.as_ref().map_or("off", |c| c.addr.as_str()),
1204 self.session_ttl.as_secs() / 3600,
1205 self.cookie_secure,
1206 self.oidc.as_ref().map(|o| o.issuer_url.as_str()).unwrap_or("disabled"),
1207 self.local_login,
1208 self.mattermost_error_webhook.is_some(),
1209 self.smtp.is_some(),
1210 self.request_digest_hours,
1211 self.mattermost
1212 .as_ref()
1213 .map_or("off", |m| {
1214 if m.bot.is_some() {
1215 "bot"
1216 } else if m.direct {
1217 "direct"
1218 } else {
1219 "channel"
1220 }
1221 }),
1222 self.assistant.as_ref().map_or_else(|| "off".to_string(), |a| a.label()),
1223 self.local_agents.as_str(),
1224 match (
1225 self.webhooks.allowed_hosts.is_empty(),
1226 self.webhooks.allow_private
1227 ) {
1228 (true, false) => "public",
1229 (true, true) => "any",
1230 (false, false) => "allow-list",
1231 (false, true) => "allow-list+private",
1232 },
1233 )
1234 }
1235}
1236
1237fn oidc_config<F: Fn(&str) -> Option<String>>(env: &Env<F>) -> Result<Option<OidcConfig>> {
1238 let Some(issuer_url) = env.get("TEAMCRAFT_OIDC_ISSUER_URL")? else {
1239 return Ok(None);
1240 };
1241 if !(issuer_url.starts_with("https://") || issuer_url.starts_with("http://")) {
1242 bail!("TEAMCRAFT_OIDC_ISSUER_URL must be an http(s) URL");
1243 }
1244 let client_id = env
1245 .get("TEAMCRAFT_OIDC_CLIENT_ID")?
1246 .context("TEAMCRAFT_OIDC_CLIENT_ID is required when OIDC is enabled")?;
1247 let client_secret = env.get("TEAMCRAFT_OIDC_CLIENT_SECRET")?.context(
1248 "TEAMCRAFT_OIDC_CLIENT_SECRET (or TEAMCRAFT_OIDC_CLIENT_SECRET_FILE) is required when OIDC is enabled",
1249 )?;
1250 Ok(Some(OidcConfig {
1251 issuer_url: issuer_url.trim().to_string(),
1252 client_id,
1253 client_secret,
1254 scopes: env
1255 .get("TEAMCRAFT_OIDC_SCOPES")?
1256 .unwrap_or_else(|| "openid profile email".into()),
1257 display_name: env
1258 .get("TEAMCRAFT_OIDC_DISPLAY_NAME")?
1259 .unwrap_or_else(|| "Single Sign-On".into()),
1260 groups_claim: env
1261 .get("TEAMCRAFT_OIDC_GROUPS_CLAIM")?
1262 .unwrap_or_else(|| "groups".into()),
1263 username_claim: env
1264 .get("TEAMCRAFT_OIDC_USERNAME_CLAIM")?
1265 .unwrap_or_else(|| "preferred_username".into()),
1266 admin_group: env
1267 .get("TEAMCRAFT_OIDC_ADMIN_GROUP")?
1268 .unwrap_or_else(|| "teamcraft-admins".into()),
1269 editor_group: env
1270 .get("TEAMCRAFT_OIDC_EDITOR_GROUP")?
1271 .unwrap_or_else(|| "teamcraft-editors".into()),
1272 viewer_group: env.get("TEAMCRAFT_OIDC_VIEWER_GROUP")?,
1273 }))
1274}
1275
1276struct Env<F: Fn(&str) -> Option<String>> {
1277 lookup: F,
1278}
1279
1280impl<F: Fn(&str) -> Option<String>> Env<F> {
1281 fn get(&self, key: &str) -> Result<Option<String>> {
1284 if let Some(path) = (self.lookup)(&format!("{key}_FILE")).filter(|p| !p.trim().is_empty()) {
1285 let content = std::fs::read_to_string(path.trim())
1286 .with_context(|| format!("cannot read {key}_FILE ({path})"))?;
1287 let value = content.trim_end_matches(['\n', '\r']).to_string();
1288 return Ok(Some(value).filter(|v| !v.is_empty()));
1289 }
1290 Ok((self.lookup)(key).filter(|v| !v.trim().is_empty()))
1291 }
1292
1293 fn parse_or<T>(&self, key: &str, default: T) -> Result<T>
1294 where
1295 T: FromStr,
1296 T::Err: std::fmt::Display,
1297 {
1298 match self.get(key)? {
1299 Some(raw) => raw
1300 .trim()
1301 .parse::<T>()
1302 .map_err(|e| anyhow!("{key}: invalid value '{raw}': {e}")),
1303 None => Ok(default),
1304 }
1305 }
1306}
1307
1308fn parse_bool(raw: &str) -> Result<bool> {
1309 match raw.trim().to_ascii_lowercase().as_str() {
1310 "1" | "true" | "yes" | "on" => Ok(true),
1311 "0" | "false" | "no" | "off" => Ok(false),
1312 other => bail!("not a boolean: '{other}'"),
1313 }
1314}
1315
1316fn percent_decode(component: &str) -> String {
1324 let bytes = component.as_bytes();
1325 let mut out = Vec::with_capacity(bytes.len());
1326 let hex = |b: Option<&u8>| b.and_then(|b| (*b as char).to_digit(16));
1327 let mut i = 0;
1328 while let Some(&b) = bytes.get(i) {
1329 match (b, hex(bytes.get(i + 1)), hex(bytes.get(i + 2))) {
1330 (b'%', Some(h), Some(l)) => {
1331 out.push((h * 16 + l) as u8);
1332 i += 3;
1333 }
1334 (b, _, _) => {
1335 out.push(b);
1336 i += 1;
1337 }
1338 }
1339 }
1340 String::from_utf8(out).unwrap_or_else(|_| component.to_string())
1341}
1342
1343fn database_options<F: Fn(&str) -> Option<String>>(
1344 env: &Env<F>,
1345) -> Result<(PgConnectOptions, String, Option<String>)> {
1346 let url = match env.get("TEAMCRAFT_DATABASE_URL")? {
1347 Some(url) => Some(url),
1348 None => env.get("DATABASE_URL")?,
1349 };
1350 if let Some(url) = url {
1351 let options = PgConnectOptions::from_str(&url)
1352 .context("TEAMCRAFT_DATABASE_URL is not a valid postgres:// URL")?
1353 .application_name("teamcraft");
1354 let display = format!(
1355 "{}:{}/{} (from URL)",
1356 options.get_host(),
1357 options.get_port(),
1358 options.get_database().unwrap_or("?")
1359 );
1360 let password = reqwest::Url::parse(&url)
1364 .ok()
1365 .and_then(|parsed| parsed.password().map(percent_decode))
1366 .filter(|password| !password.is_empty());
1367 return Ok((options, display, password));
1368 }
1369
1370 let host = env
1371 .get("TEAMCRAFT_DB_HOST")?
1372 .unwrap_or_else(|| "localhost".into());
1373 let port: u16 = env.parse_or("TEAMCRAFT_DB_PORT", 5432u16)?;
1374 let name = env
1375 .get("TEAMCRAFT_DB_NAME")?
1376 .unwrap_or_else(|| "teamcraft".into());
1377 let user = env
1378 .get("TEAMCRAFT_DB_USER")?
1379 .unwrap_or_else(|| "teamcraft".into());
1380 let password = env.get("TEAMCRAFT_DB_PASSWORD")?;
1383 let ssl_mode = match env.get("TEAMCRAFT_DB_SSLMODE")? {
1384 Some(mode) => {
1385 PgSslMode::from_str(&mode).map_err(|e| anyhow!("TEAMCRAFT_DB_SSLMODE: {e}"))?
1386 }
1387 None => PgSslMode::Prefer,
1388 };
1389
1390 let mut options = PgConnectOptions::new()
1391 .host(&host)
1392 .port(port)
1393 .username(&user)
1394 .database(&name)
1395 .ssl_mode(ssl_mode)
1396 .application_name("teamcraft");
1397 if let Some(password) = &password {
1398 options = options.password(password);
1399 }
1400 if host.starts_with('/') {
1403 options = options.socket(&host);
1404 }
1405 let display = format!("{user}@{host}:{port}/{name}");
1406 Ok((options, display, password))
1407}
1408
1409#[cfg(test)]
1410mod tests {
1411 use super::*;
1412 use std::collections::HashMap;
1413
1414 fn config_from(pairs: &[(&str, &str)]) -> Result<Config> {
1415 let map: HashMap<String, String> = pairs
1416 .iter()
1417 .map(|(k, v)| (k.to_string(), v.to_string()))
1418 .collect();
1419 Config::from_lookup(move |k| map.get(k).cloned())
1420 }
1421
1422 #[test]
1423 fn defaults_with_password() {
1424 let cfg = config_from(&[("TEAMCRAFT_DB_PASSWORD", "secret")]).unwrap();
1425 assert_eq!(cfg.bind_addr.to_string(), "127.0.0.1:8080");
1426 assert_eq!(cfg.public_url, "http://localhost:8080");
1427 assert_eq!(cfg.max_upload_bytes, 512 * 1024 * 1024);
1428 assert_eq!(cfg.upload_chunk_bytes, 16 * 1024 * 1024);
1429 assert!(cfg.clamd.is_none(), "no malware scan by default");
1430 assert_eq!(cfg.request_digest_hours, 24, "daily digests");
1431 assert!(!cfg.cookie_secure);
1432 assert_eq!(cfg.log_format, LogFormat::Text);
1433 assert!(cfg.bootstrap_admin.is_none());
1434 assert_eq!(cfg.database_display, "teamcraft@localhost:5432/teamcraft");
1435 assert_eq!(cfg.database_password.as_deref(), Some("secret"));
1436 assert!(!cfg.summary().contains("secret"));
1437 }
1438
1439 #[test]
1440 fn malware_scanner_settings() {
1441 let cfg = config_from(&[
1442 ("TEAMCRAFT_DB_PASSWORD", "secret"),
1443 ("TEAMCRAFT_CLAMD_ADDR", "clamav:3310"),
1444 ("TEAMCRAFT_CLAMD_MAX_MB", "100"),
1445 ])
1446 .unwrap();
1447 let clamd = cfg.clamd.as_ref().unwrap();
1448 assert_eq!(clamd.addr, "clamav:3310");
1449 assert_eq!(clamd.max_bytes, 100 * 1024 * 1024);
1450 assert!(cfg.summary().contains("malware_scan=clamav:3310"));
1451 let unix = config_from(&[
1452 ("TEAMCRAFT_DB_PASSWORD", "secret"),
1453 ("TEAMCRAFT_CLAMD_ADDR", "unix:/run/clamav/clamd.ctl"),
1454 ])
1455 .unwrap();
1456 assert_eq!(unix.clamd.unwrap().max_bytes, 25 * 1024 * 1024);
1457 for bad in ["clamav", "unix:relative.sock"] {
1458 assert!(
1459 config_from(&[
1460 ("TEAMCRAFT_DB_PASSWORD", "secret"),
1461 ("TEAMCRAFT_CLAMD_ADDR", bad)
1462 ])
1463 .is_err(),
1464 "{bad}"
1465 );
1466 }
1467 assert!(config_from(&[
1468 ("TEAMCRAFT_DB_PASSWORD", "secret"),
1469 ("TEAMCRAFT_CLAMD_MAX_MB", "0")
1470 ])
1471 .is_err());
1472 }
1473
1474 #[test]
1475 fn database_url_password_is_decoded_for_the_client_tools() {
1476 let cfg = config_from(&[(
1477 "TEAMCRAFT_DATABASE_URL",
1478 "postgres://tc:p%40ss%3Aw%25rd%2F1@db:5432/teamcraft",
1479 )])
1480 .unwrap();
1481 assert_eq!(cfg.database_password.as_deref(), Some("p@ss:w%rd/1"));
1482 assert!(!cfg.summary().contains("p@ss") && !cfg.summary().contains("p%40ss"));
1483 let cfg = config_from(&[("TEAMCRAFT_DATABASE_URL", "postgres://tc:plain@db/x")]).unwrap();
1484 assert_eq!(cfg.database_password.as_deref(), Some("plain"));
1485 let cfg = config_from(&[("TEAMCRAFT_DATABASE_URL", "postgres://tc@db/x")]).unwrap();
1486 assert!(cfg.database_password.is_none());
1487
1488 assert_eq!(percent_decode("%C3%A4%20x"), "ä x");
1489 assert_eq!(percent_decode("100%"), "100%", "a trailing % stays");
1490 assert_eq!(percent_decode("%zz%4"), "%zz%4", "malformed escapes stay");
1491 assert_eq!(percent_decode("%FF"), "%FF", "no valid UTF-8: undecoded");
1492 }
1493
1494 #[test]
1495 fn notification_channels() {
1496 let base = [
1497 ("TEAMCRAFT_DB_PASSWORD", "secret"),
1498 ("TEAMCRAFT_LOCAL_LOGIN", "true"),
1499 ];
1500 let cfg = config_from(&base).unwrap();
1501 assert!(cfg.smtp.is_none() && cfg.mattermost.is_none(), "optional");
1502
1503 let with = |extra: &[(&'static str, &'static str)]| {
1504 let mut pairs = base.to_vec();
1505 pairs.extend_from_slice(extra);
1506 config_from(&pairs)
1507 };
1508 let cfg = with(&[
1509 (
1510 "TEAMCRAFT_SMTP_URL",
1511 "smtps://tc:mailpass@mail.example.org:465",
1512 ),
1513 ("TEAMCRAFT_MAIL_FROM", "TeamCraft <teamcraft@example.org>"),
1514 (
1515 "TEAMCRAFT_MATTERMOST_WEBHOOK",
1516 "https://chat.example.org/hooks/abc",
1517 ),
1518 ("TEAMCRAFT_MATTERMOST_DIRECT", "true"),
1519 ])
1520 .unwrap();
1521 assert_eq!(
1522 cfg.smtp.as_ref().unwrap().from,
1523 "TeamCraft <teamcraft@example.org>"
1524 );
1525 assert!(cfg.mattermost.as_ref().unwrap().direct);
1526 let summary = cfg.summary();
1527 assert!(
1528 summary.contains("smtp=true") && summary.contains("mattermost_notifications=direct")
1529 );
1530 assert!(
1531 !summary.contains("mailpass") && !summary.contains("hooks/abc"),
1532 "no secrets in the log"
1533 );
1534
1535 let err = with(&[("TEAMCRAFT_SMTP_URL", "smtp://mail.example.org")])
1536 .err()
1537 .unwrap();
1538 assert!(err.to_string().contains("TEAMCRAFT_MAIL_FROM"), "{err}");
1539 let err = with(&[
1540 ("TEAMCRAFT_SMTP_URL", "http://mail.example.org"),
1541 ("TEAMCRAFT_MAIL_FROM", "a@b.de"),
1542 ])
1543 .err()
1544 .unwrap();
1545 assert!(err.to_string().contains("smtp://"), "{err}");
1546 let err = with(&[
1547 ("TEAMCRAFT_SMTP_URL", "smtp://mail.example.org"),
1548 ("TEAMCRAFT_MAIL_FROM", "not an address"),
1549 ])
1550 .err()
1551 .unwrap();
1552 assert!(err.to_string().contains("TEAMCRAFT_MAIL_FROM"), "{err}");
1553 let cfg = with(&[
1554 ("TEAMCRAFT_MATTERMOST_URL", "https://chat.example.org/"),
1555 ("TEAMCRAFT_MATTERMOST_BOT_TOKEN", "bot-token-value"),
1556 ])
1557 .unwrap();
1558 let m = cfg.mattermost.as_ref().unwrap();
1559 assert!(m.is_direct() && !m.is_legacy_webhook());
1560 assert_eq!(m.bot.as_ref().unwrap().url, "https://chat.example.org");
1561 let summary = cfg.summary();
1562 assert!(summary.contains("mattermost_notifications=bot"));
1563 assert!(
1564 !summary.contains("bot-token-value"),
1565 "no secrets in the log"
1566 );
1567 assert!(with(&[("TEAMCRAFT_MATTERMOST_URL", "https://chat.example.org")]).is_err());
1568 assert!(with(&[("TEAMCRAFT_MATTERMOST_BOT_TOKEN", "x")]).is_err());
1569 assert!(with(&[
1570 ("TEAMCRAFT_MATTERMOST_URL", "chat.example.org"),
1571 ("TEAMCRAFT_MATTERMOST_BOT_TOKEN", "x"),
1572 ])
1573 .is_err());
1574 let legacy = with(&[(
1575 "TEAMCRAFT_MATTERMOST_WEBHOOK",
1576 "https://chat.example.org/hooks/x",
1577 )])
1578 .unwrap();
1579 assert!(legacy.mattermost.as_ref().unwrap().is_legacy_webhook());
1580 assert!(with(&[("TEAMCRAFT_MATTERMOST_WEBHOOK", "chat.example.org/hooks/x")]).is_err());
1581 assert!(with(&[
1582 (
1583 "TEAMCRAFT_MATTERMOST_WEBHOOK",
1584 "https://chat.example.org/hooks/x"
1585 ),
1586 ("TEAMCRAFT_MATTERMOST_DIRECT", "maybe"),
1587 ])
1588 .is_err());
1589 }
1590
1591 #[test]
1592 fn webhook_targets() {
1593 let cfg = config_from(&[]).unwrap();
1594 assert_eq!(cfg.webhooks, WebhookConfig::default());
1595 assert!(cfg.summary().contains("webhook_targets=public"));
1596 let cfg = config_from(&[
1597 (
1598 "TEAMCRAFT_WEBHOOK_ALLOWED_HOSTS",
1599 "ERP.internal.example.org., *.ci.example.org [fd00::1] 10.0.0.5,erp.internal.example.org",
1600 ),
1601 ("TEAMCRAFT_WEBHOOK_RETENTION_DAYS", "7"),
1602 ])
1603 .unwrap();
1604 assert_eq!(
1605 cfg.webhooks.allowed_hosts,
1606 [
1607 "erp.internal.example.org",
1608 "*.ci.example.org",
1609 "fd00::1",
1610 "10.0.0.5"
1611 ]
1612 );
1613 assert_eq!(cfg.webhooks.retention_days, 7);
1614 assert!(cfg.summary().contains("webhook_targets=allow-list"));
1615 let cfg = config_from(&[("TEAMCRAFT_WEBHOOK_ALLOW_PRIVATE", "yes")]).unwrap();
1616 assert!(cfg.webhooks.allow_private);
1617 for (key, value) in [
1618 ("TEAMCRAFT_WEBHOOK_ALLOWED_HOSTS", "a.*.example.org"),
1619 ("TEAMCRAFT_WEBHOOK_ALLOWED_HOSTS", "http://erp/x"),
1620 ("TEAMCRAFT_WEBHOOK_ALLOW_PRIVATE", "sometimes"),
1621 ("TEAMCRAFT_WEBHOOK_RETENTION_DAYS", "0"),
1622 ] {
1623 assert!(config_from(&[(key, value)]).is_err(), "{key}={value}");
1624 }
1625 }
1626
1627 #[test]
1628 fn metrics_token_is_optional_trimmed_and_not_too_short() {
1629 assert!(config_from(&[]).unwrap().metrics_token.is_none());
1630 assert!(config_from(&[("TEAMCRAFT_METRICS_TOKEN", " ")])
1631 .unwrap()
1632 .metrics_token
1633 .is_none());
1634 let cfg = config_from(&[("TEAMCRAFT_METRICS_TOKEN", " 0123456789abcdef ")]).unwrap();
1635 assert_eq!(cfg.metrics_token.as_deref(), Some("0123456789abcdef"));
1636 assert!(config_from(&[("TEAMCRAFT_METRICS_TOKEN", "short")]).is_err());
1637 }
1638
1639 #[test]
1642 fn zero_configuration_uses_the_local_database() {
1643 let cfg = config_from(&[]).expect("no configuration needed");
1644 assert_eq!(cfg.database_display, "teamcraft@localhost:5432/teamcraft");
1645 assert!(cfg.local_login);
1646 assert_eq!(cfg.vault_dir, PathBuf::from("./data/vault"));
1647 assert!(cfg.database_password.is_none());
1648 }
1649
1650 #[test]
1652 fn unix_socket_database() {
1653 let cfg = config_from(&[
1654 ("TEAMCRAFT_DB_HOST", "/run/postgresql"),
1655 ("TEAMCRAFT_DB_USER", "teamcraft"),
1656 ])
1657 .unwrap();
1658 assert_eq!(
1659 cfg.database.get_socket().map(|p| p.display().to_string()),
1660 Some("/run/postgresql".to_string())
1661 );
1662 assert_eq!(
1663 cfg.database_display,
1664 "teamcraft@/run/postgresql:5432/teamcraft"
1665 );
1666 let file = include_str!("../packaging/linux/teamcraft.env");
1668 let vars: std::collections::HashMap<String, String> =
1669 dotenvy::from_read_iter(file.as_bytes())
1670 .map(|r| r.expect("valid line"))
1671 .collect();
1672 assert_eq!(vars["TEAMCRAFT_VAULT_DIR"], "/var/lib/teamcraft/vault");
1673 let packaged = Config::from_lookup(|k| vars.get(k).cloned()).expect("packaged config");
1674 assert!(
1675 packaged.bind_addr.ip().is_loopback(),
1676 "first-start setup works"
1677 );
1678 assert!(packaged.database.get_socket().is_some());
1679 }
1680
1681 #[test]
1684 fn docker_deployment_configuration() {
1685 let dir = std::env::temp_dir().join(format!("teamcraft-cfg-{}", uuid::Uuid::new_v4()));
1686 std::fs::create_dir_all(&dir).unwrap();
1687 let secret = dir.join("db_password");
1688 std::fs::write(&secret, "generated-password\n").unwrap();
1689
1690 let example = include_str!("../deploy/teamcraft.env.example");
1691 let mut vars: HashMap<String, String> = dotenvy::from_read_iter(example.as_bytes())
1692 .map(|r| r.expect("valid line"))
1693 .collect();
1694 let compose = include_str!("../deploy/docker-compose.yml");
1695 let mut from_compose = 0;
1696 for line in compose.lines().map(str::trim) {
1697 if let Some((key, value)) = line.split_once(": ") {
1698 if key.starts_with("TEAMCRAFT_") {
1699 vars.insert(key.to_string(), value.trim_matches('"').to_string());
1700 from_compose += 1;
1701 }
1702 }
1703 }
1704 assert!(from_compose >= 5, "compose environment found");
1705 assert_eq!(
1706 vars["TEAMCRAFT_DB_PASSWORD_FILE"], "/run/secrets/db_password",
1707 "the password comes from the Docker secret"
1708 );
1709 vars.insert(
1710 "TEAMCRAFT_DB_PASSWORD_FILE".into(),
1711 secret.to_str().unwrap().into(),
1712 );
1713
1714 let cfg = Config::from_lookup(|k| vars.get(k).cloned()).expect("docker config");
1715 assert_eq!(cfg.bind_addr.to_string(), "0.0.0.0:8080");
1716 assert_eq!(cfg.database_display, "teamcraft@db:5432/teamcraft");
1717 assert_eq!(cfg.vault_dir, PathBuf::from("/var/lib/teamcraft/vault"));
1718 assert!(cfg.local_login);
1719 assert!(!cfg.summary().contains("generated-password"));
1720 std::fs::remove_dir_all(dir).ok();
1721 }
1722
1723 #[test]
1724 fn url_and_https_detection() {
1725 let cfg = config_from(&[
1726 ("TEAMCRAFT_DATABASE_URL", "postgres://u:p@db:5433/plm"),
1727 ("TEAMCRAFT_PUBLIC_URL", "https://plm.example.org/"),
1728 ("TEAMCRAFT_LOG_FORMAT", "JSON"),
1729 ])
1730 .unwrap();
1731 assert_eq!(cfg.public_url, "https://plm.example.org");
1732 assert!(cfg.cookie_secure);
1733 assert_eq!(cfg.log_format, LogFormat::Json);
1734 assert_eq!(cfg.database_display, "db:5433/plm (from URL)");
1735 assert_eq!(cfg.database_password.as_deref(), Some("p"));
1736 }
1737
1738 #[test]
1739 fn secrets_from_files() {
1740 let dir = std::env::temp_dir().join(format!("teamcraft-cfg-{}", uuid::Uuid::new_v4()));
1741 std::fs::create_dir_all(&dir).unwrap();
1742 let file = dir.join("admin_pw");
1743 std::fs::write(&file, "from-file-password\n").unwrap();
1744 let cfg = config_from(&[
1745 ("TEAMCRAFT_DB_PASSWORD", "x"),
1746 (
1747 "TEAMCRAFT_BOOTSTRAP_ADMIN_PASSWORD_FILE",
1748 file.to_str().unwrap(),
1749 ),
1750 ])
1751 .unwrap();
1752 let admin = cfg.bootstrap_admin.expect("bootstrap admin");
1753 assert_eq!(admin.username, "admin");
1754 assert_eq!(admin.password, "from-file-password");
1755 std::fs::remove_dir_all(dir).ok();
1756 }
1757
1758 #[test]
1759 fn oidc_settings() {
1760 let cfg = config_from(&[
1761 ("TEAMCRAFT_DB_PASSWORD", "x"),
1762 (
1763 "TEAMCRAFT_OIDC_ISSUER_URL",
1764 "https://auth.example.org/application/o/teamcraft/",
1765 ),
1766 ("TEAMCRAFT_OIDC_CLIENT_ID", "client"),
1767 ("TEAMCRAFT_OIDC_CLIENT_SECRET", "s3cret"),
1768 ])
1769 .unwrap();
1770 let oidc = cfg.oidc.as_ref().expect("oidc enabled");
1771 assert_eq!(oidc.admin_group, "teamcraft-admins");
1772 assert_eq!(oidc.editor_group, "teamcraft-editors");
1773 assert!(oidc.viewer_group.is_none());
1774 assert_eq!(
1775 oidc.redirect_uri(&cfg.public_url),
1776 "http://localhost:8080/auth/oidc/callback"
1777 );
1778 assert!(!cfg.local_login);
1780 assert!(!cfg.summary().contains("s3cret"));
1781
1782 assert!(config_from(&[
1784 ("TEAMCRAFT_DB_PASSWORD", "x"),
1785 ("TEAMCRAFT_OIDC_ISSUER_URL", "https://auth.example.org/"),
1786 ("TEAMCRAFT_OIDC_CLIENT_ID", "client"),
1787 ])
1788 .is_err());
1789 }
1790
1791 #[test]
1792 fn some_login_method_is_required() {
1793 let defaults = config_from(&[("TEAMCRAFT_DB_PASSWORD", "x")]).unwrap();
1794 assert!(defaults.local_login);
1795 assert!(config_from(&[
1796 ("TEAMCRAFT_DB_PASSWORD", "x"),
1797 ("TEAMCRAFT_LOCAL_LOGIN", "false")
1798 ])
1799 .is_err());
1800 }
1801
1802 #[test]
1803 fn invalid_values_are_rejected() {
1804 assert!(config_from(&[
1805 ("TEAMCRAFT_DB_PASSWORD", "x"),
1806 ("TEAMCRAFT_BIND_ADDR", "nope")
1807 ])
1808 .is_err());
1809 assert!(config_from(&[
1810 ("TEAMCRAFT_DB_PASSWORD", "x"),
1811 ("TEAMCRAFT_PUBLIC_URL", "ftp://x")
1812 ])
1813 .is_err());
1814 assert!(config_from(&[
1815 ("TEAMCRAFT_DB_PASSWORD", "x"),
1816 ("TEAMCRAFT_MAX_UPLOAD_MB", "0")
1817 ])
1818 .is_err());
1819 assert!(config_from(&[
1820 ("TEAMCRAFT_DB_PASSWORD", "x"),
1821 ("TEAMCRAFT_UPLOAD_CHUNK_MB", "0")
1822 ])
1823 .is_err());
1824 assert!(config_from(&[
1825 ("TEAMCRAFT_DB_PASSWORD", "x"),
1826 ("TEAMCRAFT_COOKIE_SECURE", "maybe")
1827 ])
1828 .is_err());
1829 assert!(config_from(&[
1830 ("TEAMCRAFT_DB_PASSWORD", "x"),
1831 ("TEAMCRAFT_REQUEST_DIGEST_HOURS", "721")
1832 ])
1833 .is_err());
1834 let off = config_from(&[
1835 ("TEAMCRAFT_DB_PASSWORD", "x"),
1836 ("TEAMCRAFT_REQUEST_DIGEST_HOURS", "0"),
1837 ])
1838 .unwrap();
1839 assert_eq!(off.request_digest_hours, 0, "0 switches the digest off");
1840 }
1841
1842 #[test]
1843 fn preview_limits_from_the_environment() {
1844 let d = config_from(&[("TEAMCRAFT_DB_PASSWORD", "x")])
1845 .unwrap()
1846 .preview;
1847 assert_eq!(d, crate::preview::PreviewLimits::default());
1848 assert_eq!(d.max_result_bytes, 64 * 1024 * 1024);
1849 assert_eq!(d.max_memory_bytes, 1024 * 1024 * 1024);
1850 let c = config_from(&[
1851 ("TEAMCRAFT_DB_PASSWORD", "x"),
1852 ("TEAMCRAFT_PREVIEW_MAX_RESULT_MB", "8"),
1853 ("TEAMCRAFT_PREVIEW_MAX_MEMORY_MB", "0"),
1854 ])
1855 .unwrap()
1856 .preview;
1857 assert_eq!(c.max_result_bytes, 8 * 1024 * 1024);
1858 assert_eq!(c.max_memory_bytes, 0, "0 = no limit");
1859 for bad in [
1860 ("TEAMCRAFT_PREVIEW_MAX_RESULT_MB", "0"),
1861 ("TEAMCRAFT_PREVIEW_MAX_MESH_MB", "x"),
1862 ("TEAMCRAFT_PREVIEW_MAX_STEP_MB", "0"),
1863 ] {
1864 assert!(config_from(&[("TEAMCRAFT_DB_PASSWORD", "x"), bad]).is_err());
1865 }
1866 }
1867
1868 #[test]
1869 fn latest_retention_grace_days() {
1870 let d = config_from(&[("TEAMCRAFT_DB_PASSWORD", "x")]).unwrap();
1871 assert_eq!(d.retention_latest_grace_days, 7);
1872 for (raw, want) in [("0", 0), ("1", 1), ("3650", 3650)] {
1873 let c = config_from(&[
1874 ("TEAMCRAFT_DB_PASSWORD", "x"),
1875 ("TEAMCRAFT_RETENTION_LATEST_GRACE_DAYS", raw),
1876 ])
1877 .unwrap();
1878 assert_eq!(c.retention_latest_grace_days, want, "{raw}");
1879 }
1880 for bad in ["3651", "-1", "x"] {
1881 assert!(
1882 config_from(&[
1883 ("TEAMCRAFT_DB_PASSWORD", "x"),
1884 ("TEAMCRAFT_RETENTION_LATEST_GRACE_DAYS", bad)
1885 ])
1886 .is_err(),
1887 "{bad}"
1888 );
1889 }
1890 }
1891
1892 #[test]
1893 fn retention_settings() {
1894 let d = config_from(&[("TEAMCRAFT_DB_PASSWORD", "x")]).unwrap();
1895 assert_eq!(d.audit_retention_days, 0, "the audit log is kept for ever");
1896 assert_eq!(
1897 d.preview_cache_max_bytes, 0,
1898 "the preview cache has no limit"
1899 );
1900 let c = config_from(&[
1901 ("TEAMCRAFT_DB_PASSWORD", "x"),
1902 ("TEAMCRAFT_AUDIT_RETENTION_DAYS", "3650"),
1903 ("TEAMCRAFT_PREVIEW_CACHE_MAX_MB", "2048"),
1904 ])
1905 .unwrap();
1906 assert_eq!(c.audit_retention_days, 3650);
1907 assert_eq!(c.preview_cache_max_bytes, 2048 * 1024 * 1024);
1908 for bad in [
1909 ("TEAMCRAFT_AUDIT_RETENTION_DAYS", "1"),
1910 ("TEAMCRAFT_AUDIT_RETENTION_DAYS", "29"),
1911 ("TEAMCRAFT_AUDIT_RETENTION_DAYS", "36501"),
1912 ("TEAMCRAFT_AUDIT_RETENTION_DAYS", "-1"),
1913 ("TEAMCRAFT_PREVIEW_CACHE_MAX_MB", "x"),
1914 ("TEAMCRAFT_PREVIEW_CACHE_MAX_MB", "16777217"),
1915 ] {
1916 assert!(
1917 config_from(&[("TEAMCRAFT_DB_PASSWORD", "x"), bad]).is_err(),
1918 "{bad:?}"
1919 );
1920 }
1921 }
1922
1923 #[test]
1924 fn local_agents_switch() {
1925 let base = ("TEAMCRAFT_DB_PASSWORD", "x");
1926 let cfg = config_from(&[base]).unwrap();
1928 assert_eq!(cfg.local_agents, LocalAgents::Allowed);
1929 assert!(cfg.summary().contains("local_agents=allowed"));
1930 for (raw, want) in [
1931 ("allowed", LocalAgents::Allowed),
1932 ("off", LocalAgents::Off),
1933 (" OFF ", LocalAgents::Off),
1934 ("Allowed", LocalAgents::Allowed),
1935 ("", LocalAgents::Allowed),
1937 ] {
1938 let cfg = config_from(&[base, ("TEAMCRAFT_LOCAL_AGENTS", raw)]).unwrap();
1939 assert_eq!(cfg.local_agents, want, "{raw:?}");
1940 }
1941 let off = config_from(&[base, ("TEAMCRAFT_LOCAL_AGENTS", "off")]).unwrap();
1942 assert!(!off.local_agents.allowed());
1943 assert!(off.summary().contains("local_agents=off"));
1944 for bad in ["false", "no", "disabled", "on", "of"] {
1946 let err = config_from(&[base, ("TEAMCRAFT_LOCAL_AGENTS", bad)])
1947 .err()
1948 .unwrap_or_else(|| panic!("{bad:?} accepted"));
1949 assert!(err.to_string().contains("TEAMCRAFT_LOCAL_AGENTS"), "{err}");
1950 }
1951 }
1952
1953 #[test]
1954 fn local_agents_file_variant() {
1955 let dir = std::env::temp_dir().join(format!("tc-local-agents-{}", std::process::id()));
1956 std::fs::create_dir_all(&dir).unwrap();
1957 let file = dir.join("local_agents");
1958 std::fs::write(&file, "off\n").unwrap();
1959 let path = file.to_string_lossy().to_string();
1960 let cfg = config_from(&[
1961 ("TEAMCRAFT_DB_PASSWORD", "x"),
1962 ("TEAMCRAFT_LOCAL_AGENTS_FILE", &path),
1963 ])
1964 .unwrap();
1965 assert_eq!(cfg.local_agents, LocalAgents::Off);
1966 let _ = std::fs::remove_dir_all(&dir);
1967 }
1968
1969 fn assistant_from(pairs: &[(&str, &str)]) -> Result<Option<AssistantConfig>> {
1970 let mut all = vec![("TEAMCRAFT_DB_PASSWORD", "x")];
1971 all.extend_from_slice(pairs);
1972 config_from(&all).map(|c| c.assistant)
1973 }
1974
1975 #[test]
1976 fn assistant_providers() {
1977 use AssistantProvider::*;
1978 let a = assistant_from(&[("TEAMCRAFT_ANTHROPIC_API_KEY", "k")])
1980 .unwrap()
1981 .unwrap();
1982 assert_eq!(a.provider, Anthropic);
1983 assert_eq!(a.base_url, "https://api.anthropic.com/v1");
1984 assert_eq!(a.api_key.as_deref(), Some("k"));
1985 assert_eq!(a.model, DEFAULT_ASSISTANT_MODEL);
1986 assert_eq!(a.max_tokens, 16_000);
1987 assert_eq!(a.request_timeout, Duration::from_secs(180));
1988 assert_eq!(a.run_timeout, Duration::from_secs(240));
1989 assert_eq!(a.max_concurrent, 4);
1990 assert_eq!(a.label(), "anthropic:claude-opus-5-5@api.anthropic.com");
1991
1992 let new = [("TEAMCRAFT_ASSISTANT_API_KEY", "k")];
1994 assert_eq!(assistant_from(&new).unwrap().unwrap().provider, Anthropic);
1995 assert!(assistant_from(&[
1996 ("TEAMCRAFT_ASSISTANT_API_KEY", "k"),
1997 ("TEAMCRAFT_ANTHROPIC_API_KEY", "k"),
1998 ])
1999 .unwrap()
2000 .is_some());
2001 let conflict = assistant_from(&[
2002 ("TEAMCRAFT_ASSISTANT_API_KEY", "one"),
2003 ("TEAMCRAFT_ANTHROPIC_API_KEY", "two"),
2004 ])
2005 .unwrap_err()
2006 .to_string();
2007 assert!(conflict.contains("different values"));
2008 assert!(
2009 !conflict.contains("one") && !conflict.contains("two"),
2010 "no key in the error"
2011 );
2012
2013 assert!(assistant_from(&[
2015 ("TEAMCRAFT_ASSISTANT_PROVIDER", "openai"),
2016 ("TEAMCRAFT_ASSISTANT_API_KEY", "k"),
2017 ])
2018 .is_err());
2019 let a = assistant_from(&[
2020 ("TEAMCRAFT_ASSISTANT_PROVIDER", "OpenAI"),
2021 ("TEAMCRAFT_ASSISTANT_API_KEY", "k"),
2022 ("TEAMCRAFT_ASSISTANT_MODEL", "gpt-5.4"),
2023 ])
2024 .unwrap()
2025 .unwrap();
2026 assert_eq!(
2027 (a.provider, a.base_url.as_str()),
2028 (OpenAi, "https://api.openai.com/v1")
2029 );
2030 assert!(
2031 assistant_from(&[
2032 ("TEAMCRAFT_ASSISTANT_PROVIDER", "openai"),
2033 ("TEAMCRAFT_ASSISTANT_MODEL", "gpt-5.4"),
2034 ])
2035 .unwrap()
2036 .is_none(),
2037 "no key: disabled"
2038 );
2039
2040 let local = [
2042 ("TEAMCRAFT_ASSISTANT_PROVIDER", "openai-compatible"),
2043 (
2044 "TEAMCRAFT_ASSISTANT_BASE_URL",
2045 "http://ollama.internal:11434/v1/",
2046 ),
2047 ("TEAMCRAFT_ASSISTANT_MODEL", "llama3.1:8b"),
2048 ];
2049 let a = assistant_from(&local).unwrap().unwrap();
2050 assert_eq!(a.provider, OpenAiCompatible);
2051 assert_eq!(
2052 a.base_url, "http://ollama.internal:11434/v1",
2053 "trailing slash dropped"
2054 );
2055 assert!(a.api_key.is_none());
2056 assert_eq!(a.label(), "openai-compatible:llama3.1:8b@ollama.internal");
2057 assert!(
2058 a.insecure_key_warning().is_none(),
2059 "no key, nothing to leak"
2060 );
2061 assert!(
2062 assistant_from(&[local[0], ("TEAMCRAFT_ASSISTANT_API_KEY", "k"), local[2]]).is_err(),
2063 "base URL required"
2064 );
2065 assert!(assistant_from(&local[..2]).is_err(), "model required");
2066 assert!(
2067 assistant_from(&[
2068 ("TEAMCRAFT_ASSISTANT_PROVIDER", "openai-compatible"),
2069 ("TEAMCRAFT_ASSISTANT_MODEL", "m")
2070 ])
2071 .unwrap()
2072 .is_none(),
2073 "neither key nor URL: disabled"
2074 );
2075 assert!(assistant_from(&[("TEAMCRAFT_ASSISTANT_PROVIDER", "gemini")]).is_err());
2076
2077 let a = assistant_from(&[
2079 ("TEAMCRAFT_ASSISTANT_API_KEY", "k"),
2080 ("TEAMCRAFT_ASSISTANT_MAX_TOKENS", "4000"),
2081 ("TEAMCRAFT_ASSISTANT_REQUEST_TIMEOUT", "600"),
2082 ("TEAMCRAFT_ASSISTANT_MAX_CONCURRENT", "2"),
2083 ("TEAMCRAFT_ASSISTANT_RETENTION_DAYS", "7"),
2084 ])
2085 .unwrap()
2086 .unwrap();
2087 assert_eq!(a.max_tokens, 4000);
2088 assert_eq!(a.request_timeout, Duration::from_secs(600));
2089 assert_eq!(a.run_timeout, Duration::from_secs(600));
2090 assert_eq!(a.max_concurrent, 2);
2091 assert_eq!(a.retention_days, 7);
2092 for (key, value) in [
2093 ("TEAMCRAFT_ASSISTANT_MAX_TOKENS", "10"),
2094 ("TEAMCRAFT_ASSISTANT_REQUEST_TIMEOUT", "1"),
2095 ("TEAMCRAFT_ASSISTANT_RUN_TIMEOUT", "100"), ("TEAMCRAFT_ASSISTANT_MAX_CONCURRENT", "0"),
2097 ("TEAMCRAFT_ASSISTANT_RETENTION_DAYS", "0"),
2098 ("TEAMCRAFT_ASSISTANT_RETENTION_DAYS", "366"),
2099 ] {
2100 assert!(
2101 assistant_from(&[("TEAMCRAFT_ASSISTANT_API_KEY", "k"), (key, value)]).is_err(),
2102 "{key}={value}"
2103 );
2104 }
2105 }
2106
2107 #[test]
2108 fn internal_urls_are_parsed_and_matched() {
2109 let base = [
2110 ("TEAMCRAFT_ASSISTANT_API_KEY", "k"),
2111 ("TEAMCRAFT_ASSISTANT_PROVIDER", "openai-compatible"),
2112 ("TEAMCRAFT_ASSISTANT_MODEL", "m"),
2113 (
2114 "TEAMCRAFT_ASSISTANT_BASE_URL",
2115 "http://ollama.internal:11434/v1",
2116 ),
2117 ];
2118 let a = assistant_from(&base).unwrap().unwrap();
2119 assert!(a.internal_urls.is_empty() && !a.is_internal());
2120 let mut with = base.to_vec();
2121 with.push((
2122 "TEAMCRAFT_ASSISTANT_INTERNAL_URLS",
2123 "https://other.example, http://OLLAMA.internal:11434/",
2124 ));
2125 let a = assistant_from(&with).unwrap().unwrap();
2126 assert_eq!(a.internal_urls.len(), 2);
2127 assert!(a.is_internal());
2128 let mut elsewhere = base.to_vec();
2129 elsewhere.push((
2130 "TEAMCRAFT_ASSISTANT_INTERNAL_URLS",
2131 "http://ollama.internal:9999",
2132 ));
2133 assert!(!assistant_from(&elsewhere).unwrap().unwrap().is_internal());
2134 for bad in [
2135 "not a url",
2136 "ftp://x.internal",
2137 "https://u:p@x.internal",
2138 "https://x.internal/?q=1",
2139 ] {
2140 let mut v = base.to_vec();
2141 v.push(("TEAMCRAFT_ASSISTANT_INTERNAL_URLS", bad));
2142 assert!(assistant_from(&v).is_err(), "{bad}");
2143 }
2144 }
2145
2146 #[test]
2147 fn url_prefix_matching_respects_segments_scheme_and_port() {
2148 assert!(url_is_under("https://a.example/v1", "https://a.example"));
2149 assert!(url_is_under(
2150 "https://a.example/v1/x",
2151 "https://a.example/v1/"
2152 ));
2153 assert!(url_is_under(
2154 "https://A.example:443/v1",
2155 "https://a.example/v1"
2156 ));
2157 assert!(!url_is_under(
2158 "https://a.example/v10",
2159 "https://a.example/v1"
2160 ));
2161 assert!(!url_is_under("http://a.example/v1", "https://a.example"));
2162 assert!(!url_is_under(
2163 "https://a.example.evil/v1",
2164 "https://a.example"
2165 ));
2166 assert!(!url_is_under("https://a.example:8443", "https://a.example"));
2167 }
2168
2169 #[test]
2170 fn assistant_base_urls_are_checked() {
2171 let with = |url: &str| {
2172 assistant_from(&[
2173 ("TEAMCRAFT_ASSISTANT_API_KEY", "k"),
2174 ("TEAMCRAFT_ASSISTANT_BASE_URL", url),
2175 ])
2176 };
2177 assert!(with("https://api.example.com/v1").is_ok());
2178 for bad in [
2179 "ftp://example.com",
2180 "file:///etc/passwd",
2181 "https://user:pass@example.com/v1",
2182 "https://user@example.com/v1",
2183 "https://example.com/v1?key=1",
2184 "not a url",
2185 "https://",
2186 ] {
2187 let e = with(bad);
2188 assert!(e.is_err(), "{bad}");
2189 assert!(
2190 !e.unwrap_err().to_string().contains("pass@"),
2191 "no credentials in the error"
2192 );
2193 }
2194
2195 let warn = |url: &str| with(url).unwrap().unwrap().insecure_key_warning();
2197 assert!(warn("https://llm.example.com/v1").is_none());
2198 assert!(warn("http://localhost:11434/v1").is_none());
2199 assert!(warn("http://127.0.0.1:8000/v1").is_none());
2200 assert!(warn("http://[::1]:8000/v1").is_none());
2201 let w = warn("http://llm.example.com/v1").unwrap();
2202 assert!(w.contains("plain http") && w.contains("llm.example.com"));
2203 assert!(!w.contains("k "), "no key in the warning");
2204 assert!(
2205 warn("http://10.0.0.5:8000/v1").is_some(),
2206 "private is not loopback"
2207 );
2208 }
2209
2210 #[test]
2211 fn assistant_settings() {
2212 let cfg = config_from(&[("TEAMCRAFT_DB_PASSWORD", "x")]).unwrap();
2213 assert!(cfg.assistant.is_none(), "disabled without a key");
2214 assert!(cfg.summary().contains("assistant=off"));
2215
2216 let cfg = config_from(&[
2217 ("TEAMCRAFT_DB_PASSWORD", "x"),
2218 ("TEAMCRAFT_ANTHROPIC_API_KEY", "sk-test-key-123"),
2219 ])
2220 .unwrap();
2221 let a = cfg.assistant.as_ref().unwrap();
2222 assert_eq!(a.model, DEFAULT_ASSISTANT_MODEL);
2223 assert_eq!(a.max_steps, DEFAULT_ASSISTANT_MAX_STEPS);
2224 assert_eq!(a.retention_days, DEFAULT_ASSISTANT_RETENTION_DAYS);
2225 assert!(
2226 !cfg.summary().contains("sk-test-key-123"),
2227 "no key in the log"
2228 );
2229 assert!(
2230 !format!("{a:?}").contains("sk-test-key-123"),
2231 "no key in Debug"
2232 );
2233
2234 let cfg = config_from(&[
2235 ("TEAMCRAFT_DB_PASSWORD", "x"),
2236 ("TEAMCRAFT_ANTHROPIC_API_KEY", "k"),
2237 ("TEAMCRAFT_ASSISTANT_MODEL", "claude-sonnet-5-5"),
2238 ("TEAMCRAFT_ASSISTANT_MAX_STEPS", "5"),
2239 ])
2240 .unwrap();
2241 let a = cfg.assistant.unwrap();
2242 assert_eq!((a.model.as_str(), a.max_steps), ("claude-sonnet-5-5", 5));
2243
2244 let dir = std::env::temp_dir().join(format!("teamcraft-cfg-{}", uuid::Uuid::new_v4()));
2246 std::fs::create_dir_all(&dir).unwrap();
2247 let blank = dir.join("blank");
2248 std::fs::write(&blank, " \n").unwrap();
2249 let cfg = config_from(&[
2250 ("TEAMCRAFT_DB_PASSWORD", "x"),
2251 ("TEAMCRAFT_ANTHROPIC_API_KEY_FILE", blank.to_str().unwrap()),
2252 ])
2253 .unwrap();
2254 assert!(cfg.assistant.is_none(), "blank key file = disabled");
2255 let cfg = config_from(&[
2256 ("TEAMCRAFT_DB_PASSWORD", "x"),
2257 ("TEAMCRAFT_ANTHROPIC_API_KEY", "k"),
2258 ("TEAMCRAFT_ASSISTANT_MODEL_FILE", blank.to_str().unwrap()),
2259 ])
2260 .unwrap();
2261 assert_eq!(cfg.assistant.unwrap().model, DEFAULT_ASSISTANT_MODEL);
2262 std::fs::remove_dir_all(dir).ok();
2263
2264 for (key, value) in [
2265 ("TEAMCRAFT_ASSISTANT_MAX_STEPS", "0"),
2266 ("TEAMCRAFT_ASSISTANT_RETENTION_DAYS", "0"),
2267 ("TEAMCRAFT_ASSISTANT_RETENTION_DAYS", "400"),
2268 ("TEAMCRAFT_ASSISTANT_MAX_STEPS", "500"),
2269 ("TEAMCRAFT_ASSISTANT_MODEL", "claude opus"),
2270 ] {
2271 assert!(
2272 config_from(&[
2273 ("TEAMCRAFT_DB_PASSWORD", "x"),
2274 ("TEAMCRAFT_ANTHROPIC_API_KEY", "k"),
2275 (key, value),
2276 ])
2277 .is_err(),
2278 "{key}={value}"
2279 );
2280 }
2281 }
2282
2283 fn names(list: &[&str]) -> Vec<String> {
2284 list.iter().map(|s| s.to_string()).collect()
2285 }
2286
2287 #[test]
2288 fn unknown_variables_are_found_with_a_suggestion() {
2289 let found = unknown_variables(names(&[
2290 "TEAMCRAFT_PUBLIC_URL",
2291 "TEAMCRAFT_PUBLIC_URL_FILE",
2292 "TEAMCRAFT_PUBLC_URL",
2293 "TEAMCRAFT_DB_PASSWORD_FIL",
2294 "TEAMCRAFT_TOTALLY_DIFFERENT_THING_X",
2295 "TEAMCRAFT_REQUIRE_DB_TESTS",
2296 "TEAMCRAFT_ENV_FILE",
2297 "PATH",
2298 "MATTERMOST_ERROR_WEBHOK",
2299 ]));
2300 let get = |n: &str| found.iter().find(|(k, _)| k == n).map(|(_, h)| h.clone());
2301 assert_eq!(found.len(), 4, "{found:?}");
2302 assert_eq!(
2303 get("TEAMCRAFT_PUBLC_URL"),
2304 Some(Some("TEAMCRAFT_PUBLIC_URL".into()))
2305 );
2306 assert_eq!(
2307 get("TEAMCRAFT_DB_PASSWORD_FIL"),
2308 Some(Some("TEAMCRAFT_DB_PASSWORD".into()))
2309 );
2310 assert_eq!(
2311 get("MATTERMOST_ERROR_WEBHOK"),
2312 Some(Some("MATTERMOST_ERROR_WEBHOOK".into()))
2313 );
2314 assert_eq!(get("TEAMCRAFT_TOTALLY_DIFFERENT_THING_X"), Some(None));
2315 assert_eq!(get("TEAMCRAFT_PUBLIC_URL_FILE"), None);
2317 assert_eq!(get("TEAMCRAFT_REQUIRE_DB_TESTS"), None);
2318 assert_eq!(get("TEAMCRAFT_ENV_FILE"), None);
2319 assert_eq!(get("PATH"), None);
2320 }
2321
2322 #[test]
2323 fn unknown_file_variable_suggests_the_file_form() {
2324 assert_eq!(
2325 unknown_variables(names(&["TEAMCRAFT_DB_PASWORD_FILE"])),
2326 vec![(
2327 "TEAMCRAFT_DB_PASWORD_FILE".to_string(),
2328 Some("TEAMCRAFT_DB_PASSWORD_FILE".to_string())
2329 )]
2330 );
2331 }
2332
2333 #[test]
2334 fn edit_distance_basics() {
2335 assert_eq!(edit_distance("", ""), 0);
2336 assert_eq!(edit_distance("abc", "abc"), 0);
2337 assert_eq!(edit_distance("abc", ""), 3);
2338 assert_eq!(edit_distance("", "abc"), 3);
2339 assert_eq!(edit_distance("kitten", "sitting"), 3);
2340 }
2341
2342 fn variable_words(text: &str, quoted: bool) -> std::collections::BTreeSet<String> {
2345 let is_word = |c: char| c.is_ascii_alphanumeric() || c == '_';
2346 let mut out = std::collections::BTreeSet::new();
2347 let mut word_start: Option<usize> = None;
2348 for (pos, c) in text.char_indices().chain([(text.len(), ' ')]) {
2350 if is_word(c) {
2351 word_start.get_or_insert(pos);
2352 continue;
2353 }
2354 let Some(start) = word_start.take() else {
2355 continue;
2356 };
2357 let word = text.get(start..pos).unwrap_or("");
2358 let before = text.get(..start).and_then(|t| t.chars().last());
2359 let named = word.starts_with("TEAMCRAFT_")
2360 || word.starts_with("MATTERMOST_")
2361 || word == "DATABASE_URL";
2362 let literal = before == Some('"') && c == '"';
2363 if named && (literal || !quoted) && !word.chars().any(|c| c.is_ascii_lowercase()) {
2364 out.insert(word.to_string());
2365 }
2366 }
2367 out
2368 }
2369
2370 #[test]
2371 fn variable_words_scanner() {
2372 let words = variable_words("a \"TEAMCRAFT_A\" `TEAMCRAFT_B_*` TEAMCRAFT_c x", false);
2373 assert_eq!(
2374 words.into_iter().collect::<Vec<_>>(),
2375 vec!["TEAMCRAFT_A".to_string(), "TEAMCRAFT_B_".to_string()]
2376 );
2377 let words = variable_words("\"TEAMCRAFT_A\" TEAMCRAFT_B TEAMCRAFT_C", true);
2378 assert_eq!(words.into_iter().collect::<Vec<_>>(), vec!["TEAMCRAFT_A"]);
2379 }
2380
2381 #[test]
2382 fn known_variables_match_the_source() {
2383 let source = include_str!("config.rs");
2384 let production = source.split("mod tests {").next().unwrap_or(source);
2385 let read: std::collections::BTreeSet<String> = variable_words(production, true)
2386 .into_iter()
2387 .filter(|w| !w.ends_with('_') && !TOOLING_VARIABLES.contains(&w.as_str()))
2388 .collect();
2389 let known: std::collections::BTreeSet<String> =
2390 KNOWN_VARIABLES.iter().map(|s| s.to_string()).collect();
2391 let cli_only = ["TEAMCRAFT_SERVER", "TEAMCRAFT_TOKEN"];
2393 let missing: Vec<_> = read.difference(&known).collect();
2394 assert!(
2395 missing.is_empty(),
2396 "read by config.rs, not in KNOWN_VARIABLES: {missing:?}"
2397 );
2398 let stale: Vec<_> = known
2399 .difference(&read)
2400 .filter(|k| !cli_only.contains(&k.as_str()))
2401 .collect();
2402 assert!(
2403 stale.is_empty(),
2404 "in KNOWN_VARIABLES, not read by config.rs: {stale:?}"
2405 );
2406 assert!(
2407 KNOWN_VARIABLES.windows(2).all(|w| w[0] < w[1]),
2408 "keep KNOWN_VARIABLES sorted"
2409 );
2410 for tool in TOOLING_VARIABLES {
2411 assert!(!known.contains(*tool), "{tool} is in both lists");
2412 }
2413 }
2414
2415 #[test]
2416 fn documentation_and_known_variables_agree() {
2417 let docs = include_str!("../docs/src/admin/configuration.md");
2418 let words = variable_words(docs, false);
2419 let (prefixes, full): (Vec<_>, Vec<_>) = words.iter().partition(|w| w.ends_with('_'));
2420 let undocumented: Vec<_> = KNOWN_VARIABLES
2421 .iter()
2422 .filter(|k| {
2423 !full.iter().any(|w| w.as_str() == **k)
2424 && !prefixes.iter().any(|p| k.starts_with(p.as_str()))
2425 })
2426 .collect();
2427 assert!(
2428 undocumented.is_empty(),
2429 "not in configuration.md: {undocumented:?}"
2430 );
2431 let real =
2432 |name: &str| KNOWN_VARIABLES.contains(&name) || TOOLING_VARIABLES.contains(&name);
2433 let stale: Vec<_> = full
2434 .iter()
2435 .filter(|w| !real(w) && !real(w.strip_suffix("_FILE").unwrap_or(w.as_str())))
2436 .collect();
2437 assert!(stale.is_empty(), "documented, but unknown: {stale:?}");
2438 let stale_prefixes: Vec<_> = prefixes
2439 .iter()
2440 .filter(|p| {
2441 !KNOWN_VARIABLES
2442 .iter()
2443 .chain(TOOLING_VARIABLES)
2444 .any(|k| k.starts_with(p.as_str()))
2445 })
2446 .collect();
2447 assert!(
2448 stale_prefixes.is_empty(),
2449 "documented prefix matches nothing: {stale_prefixes:?}"
2450 );
2451 }
2452}