Skip to main content

teamcraft/
config.rs

1//! Runtime configuration, read from environment variables.
2//!
3//! Every variable can alternatively be provided as a file by appending
4//! `_FILE` to its name (e.g. `TEAMCRAFT_DB_PASSWORD_FILE=/run/secrets/db_password`),
5//! which is how container secrets are consumed. Reference:
6//! `docs/src/admin/configuration.md`.
7//!
8//! Files that are read on start (variables already set take precedence):
9//! `TEAMCRAFT_ENV_FILE` if set, the local development file [`LOCAL_ENV_FILE`]
10//! (`secrets/.env`, git-ignored) and – only in package builds – the system
11//! file [`SYSTEM_ENV_FILE`].
12#![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
25/// Local configuration file, relative to the working directory (the repository root).
26pub const LOCAL_ENV_FILE: &str = "secrets/.env";
27
28/// Configuration file of a system installation. Set at build time by the
29/// distribution packages (`TEAMCRAFT_SYSTEM_CONFIG=/etc/teamcraft/teamcraft.env`),
30/// so development builds never read a system file.
31pub const SYSTEM_ENV_FILE: Option<&str> = option_env!("TEAMCRAFT_SYSTEM_CONFIG");
32
33/// Loads [`LOCAL_ENV_FILE`] into the process environment if it exists.
34/// Variables that are already set take precedence. Returns whether a file was loaded.
35pub 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
47/// Loads every configuration file (see the module documentation). Errors are
48/// returned with the path; the remaining files are still loaded.
49pub 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
66/// Every variable the configuration (and the command line) reads, also as
67/// `<NAME>_FILE`. Sorted; guarded by tests against the string literals of
68/// this file and against `docs/src/admin/configuration.md`.
69pub 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
144/// Variables of the build and the test tooling: documented and never warned
145/// about, but not part of the server configuration.
146pub 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
154/// Edit distance of two names (insertions, deletions, substitutions).
155fn 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
178/// The known name closest to `base`, if it is close enough to be a likely typo.
179fn 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
189/// `TEAMCRAFT_*` (and `MATTERMOST_*`) names that TeamCraft does not know,
190/// each with the nearest known name. `<NAME>_FILE` is checked as `NAME`.
191pub 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            // TEAMCRAFT_ENV_FILE is a name of its own, not a `_FILE` form
204            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
222/// Logs a warning for every unknown `TEAMCRAFT_*` variable of the process
223/// environment (a typo would otherwise silently leave the default in place).
224/// Call after the tracing subscriber is installed.
225pub 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    /// Socket address the HTTP server binds to.
246    pub bind_addr: SocketAddr,
247    /// Externally visible base URL without trailing slash, e.g. `https://plm.example.org`.
248    pub public_url: String,
249    /// Name shown in the UI header and page titles.
250    pub instance_name: String,
251    /// PostgreSQL connection options (contains the password – never log it).
252    pub database: PgConnectOptions,
253    /// Password of the database connection, for tools that receive it in
254    /// their environment (`PGPASSWORD` of `pg_dump`/`pg_restore`).
255    /// Secret – never log it.
256    pub database_password: Option<String>,
257    /// Human readable, password-free description of the database target.
258    pub database_display: String,
259    pub db_max_connections: u32,
260    /// Root directory of the file vault (and of the cached 3D previews).
261    pub vault_dir: PathBuf,
262    pub max_upload_bytes: u64,
263    /// Size and memory limits of the 3D preview (`TEAMCRAFT_PREVIEW_MAX_*`).
264    pub preview: crate::preview::PreviewLimits,
265    /// Size the preview cache (`<vault>/previews`) is trimmed to by the
266    /// hourly housekeeping, least recently used first
267    /// (`TEAMCRAFT_PREVIEW_CACHE_MAX_MB`; 0 = no limit).
268    pub preview_cache_max_bytes: u64,
269    /// Largest chunk of a chunked, resumable upload (`PATCH /api/v1/uploads/{id}`).
270    pub upload_chunk_bytes: u64,
271    /// Malware scan of uploads with a ClamAV daemon (`TEAMCRAFT_CLAMD_ADDR`,
272    /// `TEAMCRAFT_CLAMD_MAX_MB`); `None` = no scan.
273    pub clamd: Option<crate::malware::ScannerConfig>,
274    /// Passphrase of encrypted backups (`TEAMCRAFT_BACKUP_PASSPHRASE`, used by
275    /// `teamcraft backup --encrypt` and the restore). Secret – never log it.
276    pub backup_passphrase: Option<String>,
277    pub session_ttl: Duration,
278    /// Whether review decisions in the browser need a fresh sign-in
279    /// (`TEAMCRAFT_APPROVAL_REAUTH`: `off`, `release`, `every_decision`).
280    pub approval_reauth: crate::domain::ApprovalReauth,
281    /// Days the audit log is kept (`TEAMCRAFT_AUDIT_RETENTION_DAYS`; 0 = for
282    /// ever). Older entries are removed by the hourly housekeeping, which
283    /// records the removal as one entry.
284    pub audit_retention_days: u32,
285    /// Days after which the old versions of files with the retention `latest`
286    /// are removed by the hourly housekeeping
287    /// (`TEAMCRAFT_RETENTION_LATEST_GRACE_DAYS`; 0 = only the CLI removes
288    /// them). Files keep every version unless someone sets `latest`.
289    pub retention_latest_grace_days: u32,
290    /// Failed password sign-ins per username within 15 minutes before sign-in
291    /// is refused (`TEAMCRAFT_SIGNIN_MAX_FAILURES`; five times as many per
292    /// client address; 0 = off). See [`crate::auth::SignInThrottle`].
293    pub signin_max_failures: u32,
294    /// Idle lifetime in days of new API and desktop tokens of single sign-on
295    /// users (`TEAMCRAFT_OIDC_TOKEN_IDLE_DAYS`; 0 = off, the default): a token
296    /// without an expiry or with a longer one expires after that many days
297    /// without use, so a leaver removed only at the identity provider does
298    /// not keep a working token (issue #173).
299    pub oidc_token_idle_days: u32,
300    /// Bearer token of `GET /metrics`; `None` = the endpoint is off.
301    pub metrics_token: Option<String>,
302    /// Adds the `Secure` attribute to cookies (required when served via HTTPS).
303    pub cookie_secure: bool,
304    pub log_format: LogFormat,
305    /// Initial administrator that is created when the database has no users.
306    pub bootstrap_admin: Option<BootstrapAdmin>,
307    /// Single sign-on via OpenID Connect (Authentik). `None` = disabled.
308    pub oidc: Option<OidcConfig>,
309    /// Whether username/password login for local accounts is offered.
310    pub local_login: bool,
311    /// The first-start setup works without the one-time code of the server
312    /// log. Only `teamcraft local` sets it (not an environment variable): its
313    /// server runs on a fresh private port no reverse proxy points to, and
314    /// the desktop app opens the setup page itself.
315    pub setup_without_code: bool,
316    /// Mattermost incoming webhook that receives internal server errors.
317    pub mattermost_error_webhook: Option<String>,
318    /// E-mail notifications via SMTP. `None` = no e-mails.
319    pub smtp: Option<SmtpConfig>,
320    /// Hours between two e-mail digests of the change requests waiting for
321    /// triage (per user and project group); `0` = no digests.
322    pub request_digest_hours: u64,
323    /// Notifications to Mattermost. `None` = disabled.
324    pub mattermost: Option<MattermostConfig>,
325    /// The built-in assistant (Anthropic or an OpenAI-compatible API). `None` = disabled.
326    pub assistant: Option<AssistantConfig>,
327    /// Whether users may connect their own local agents (the desktop app's
328    /// *Agent* view, ACP) to TeamCraft's tools (`TEAMCRAFT_LOCAL_AGENTS`).
329    /// `Off` leaves only the server-side assistant. See [`LocalAgents`].
330    pub local_agents: LocalAgents,
331    /// Which targets outgoing event webhooks may reach.
332    pub webhooks: WebhookConfig,
333}
334
335/// Shortest audit log retention (`TEAMCRAFT_AUDIT_RETENTION_DAYS`): a typo
336/// must not empty the audit trail.
337pub const MIN_AUDIT_RETENTION_DAYS: u32 = 30;
338
339/// Largest preview cache limit in MiB (`TEAMCRAFT_PREVIEW_CACHE_MAX_MB`, 16 TiB).
340const MAX_PREVIEW_CACHE_MB: u64 = 16 * 1024 * 1024;
341
342/// Default for how long finished webhook deliveries are kept.
343pub const DEFAULT_WEBHOOK_RETENTION_DAYS: u32 = 30;
344
345/// Target rules of outgoing event webhooks (the SSRF guard in
346/// `crate::webhooks`).
347#[derive(Clone, Debug, PartialEq, Eq)]
348pub struct WebhookConfig {
349    /// `TEAMCRAFT_WEBHOOK_ALLOWED_HOSTS`: when not empty, webhooks may only
350    /// target these hosts (exact names, IP addresses or `*.example.org`), and
351    /// these hosts may resolve to private addresses (an on-premises ERP).
352    pub allowed_hosts: Vec<String>,
353    /// `TEAMCRAFT_WEBHOOK_ALLOW_PRIVATE`: every host may resolve to private,
354    /// loopback and link-local addresses.
355    pub allow_private: bool,
356    /// Days after which sent and failed deliveries are removed.
357    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/// `TEAMCRAFT_LOCAL_AGENTS`: may users connect their own local AI agents
371/// (the desktop app's *Agent* view, an ACP client for Claude Code, Gemini
372/// CLI …) to TeamCraft's tools?
373///
374/// `Off` turns `POST /api/v1/mcp` off for every token (the built-in assistant
375/// calls the tools in-process, so it is not affected) and is reported to
376/// clients (`GET /api/v1/me` → `capabilities.local_agents` and `mcp`), so the
377/// desktop app's Agent view runs on the server-side assistant (or shows that
378/// AI is off without one). [`LOCAL_AGENT_HEADER`], which the desktop
379/// adds to the MCP connection it hands to an agent, only picks the refusal
380/// message. The REST API stays open to a user's own token – limiting that
381/// needs scoped tokens.
382#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
383pub enum LocalAgents {
384    /// The default: the desktop app's *Agent* view may run a local agent.
385    #[default]
386    Allowed,
387    /// Only the server-side assistant (*Ask TeamCraft*; in the desktop app
388    /// the *Agent* view's company AI).
389    Off,
390}
391
392/// Header the desktop app adds to the MCP connection it hands to a local
393/// agent (value [`LOCAL_AGENT_HEADER_VALUE`]).
394pub const LOCAL_AGENT_HEADER: &str = "x-teamcraft-client";
395/// Value of [`LOCAL_AGENT_HEADER`] on a local agent's MCP calls.
396pub const LOCAL_AGENT_HEADER_VALUE: &str = "desktop-agent";
397
398impl LocalAgents {
399    /// Parses `allowed` or `off` (case-insensitive, surrounding blanks ignored).
400    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
420/// Parses `TEAMCRAFT_WEBHOOK_ALLOWED_HOSTS` (comma or space separated).
421fn 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        // IP addresses in the form the URL parser prints them.
444        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
455/// Default model of the `anthropic` provider.
456pub const DEFAULT_ASSISTANT_MODEL: &str = "claude-opus-5-5";
457/// Default for the most model calls of one assistant run.
458pub const DEFAULT_ASSISTANT_MAX_STEPS: u32 = 12;
459/// Default output tokens per model call.
460pub const DEFAULT_ASSISTANT_MAX_TOKENS: u32 = 16_000;
461/// Default time limit of one HTTP call to the AI service, in seconds.
462pub const DEFAULT_ASSISTANT_REQUEST_TIMEOUT: u64 = 180;
463/// Default time limit of a whole run, in seconds.
464pub const DEFAULT_ASSISTANT_RUN_TIMEOUT: u64 = 240;
465/// Default number of runs at the same time.
466pub const DEFAULT_ASSISTANT_MAX_CONCURRENT: usize = 4;
467/// Default for how long an idle assistant conversation is kept (days).
468pub const DEFAULT_ASSISTANT_RETENTION_DAYS: u32 = 30;
469
470/// Which wire format the assistant speaks.
471#[derive(Clone, Copy, Debug, PartialEq, Eq)]
472pub enum AssistantProvider {
473    /// Anthropic Messages API.
474    Anthropic,
475    /// OpenAI and Azure OpenAI (v1): Chat Completions, `max_completion_tokens`.
476    OpenAi,
477    /// Any other Chat Completions server (Ollama, vLLM, Mistral, OpenRouter,
478    /// Groq, LM Studio): `max_tokens`, key optional.
479    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    /// The API base when `TEAMCRAFT_ASSISTANT_BASE_URL` is not set.
501    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    /// API base without a trailing slash; no user name or password in it.
514    pub base_url: String,
515    /// API key (secret – never log it). Optional for `openai-compatible`.
516    pub api_key: Option<String>,
517    /// Model id (or Azure deployment name), e.g. `claude-opus-5-5`.
518    pub model: String,
519    /// Most model calls (tool-use rounds) of one run.
520    pub max_steps: u32,
521    /// Output tokens per model call.
522    pub max_tokens: u32,
523    /// Time limit of one HTTP call.
524    pub request_timeout: Duration,
525    /// Time limit of a whole run.
526    pub run_timeout: Duration,
527    /// Runs at the same time on this server.
528    pub max_concurrent: usize,
529    /// Days an idle conversation (thread) is kept before it is deleted.
530    pub retention_days: u32,
531    /// Base URLs the administrator marked as internal / self-hosted (without a
532    /// trailing slash). Groups that switched `external_llm` off allow the
533    /// assistant only when [`AssistantConfig::is_internal`].
534    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    /// The host of the API base (never the key or a path).
557    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    /// `provider:model@host` for logs and the startup summary.
565    pub fn label(&self) -> String {
566        format!("{}:{}@{}", self.provider.as_str(), self.model, self.host())
567    }
568
569    /// Whether the provider base URL is on the administrator's internal list.
570    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    /// A warning when the key would travel over plain `http` to a host that
577    /// is not this computer.
578    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
599/// Reads the assistant settings (see `docs/src/admin/configuration.md`).
600/// `None` = disabled.
601fn assistant_config<F: Fn(&str) -> Option<String>>(
602    env: &Env<F>,
603) -> Result<Option<AssistantConfig>> {
604    // A key file with only blanks counts as "not set", like an empty variable.
605    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    // Enabled: a key, or `openai-compatible` with a base URL (local servers
641    // need no key).
642    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
739/// Whether `base_url` is `listed` or below it: same scheme, host and port, and
740/// the path of `listed` is a prefix at a segment boundary.
741pub 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
758/// `TEAMCRAFT_ASSISTANT_INTERNAL_URLS`: comma or space separated base URLs of
759/// internal / self-hosted model servers.
760fn 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    /// `smtps://user:password@host:465` or `smtp://host:587?tls=required`
792    /// (lettre syntax) – contains the password, never log it.
793    pub url: String,
794    /// Sender, e.g. `TeamCraft <teamcraft@example.org>`.
795    pub from: String,
796}
797
798#[derive(Clone)]
799pub struct MattermostConfig {
800    /// Bot account of the REST API: direct messages to the person only.
801    pub bot: Option<MattermostBot>,
802    /// Deprecated: incoming webhook URL (secret). Ignored when `bot` is set.
803    pub webhook: Option<String>,
804    /// Webhook only. `true`: direct message to each user (`"channel": "@username"`);
805    /// `false`: post in the webhook's channel and @-mention the user.
806    pub direct: bool,
807}
808
809impl MattermostConfig {
810    /// Whether a notification reaches only its recipient (never a channel).
811    pub fn is_direct(&self) -> bool {
812        self.bot.is_some() || self.direct
813    }
814
815    /// Only the deprecated incoming webhook is configured.
816    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    /// Server URL, e.g. `https://chat.example.org` (no trailing slash).
824    pub url: String,
825    /// Access token of the bot account (secret).
826    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    /// Issuer URL, e.g. `https://auth.example.org/application/o/teamcraft/`.
838    pub issuer_url: String,
839    pub client_id: String,
840    pub client_secret: String,
841    /// Space separated scopes requested at the authorization endpoint.
842    pub scopes: String,
843    /// Label of the login button, e.g. "Single Sign-On".
844    pub display_name: String,
845    /// Claim that carries the list of group names.
846    pub groups_claim: String,
847    /// Claim used as username for newly provisioned users.
848    pub username_claim: String,
849    /// Members of this group become administrators.
850    pub admin_group: String,
851    /// Members of this group become CAD editors.
852    pub editor_group: String,
853    /// If set, users must be member of this group (or of the admin/editor
854    /// group) to log in at all; they get the viewer role.
855    /// If unset, every user of the IdP application gets at least viewer access.
856    pub viewer_group: Option<String>,
857}
858
859impl OidcConfig {
860    /// The redirect URI that must be registered at the identity provider.
861    pub fn redirect_uri(&self, public_url: &str) -> String {
862        format!("{public_url}/auth/oidc/callback")
863    }
864}
865
866impl Config {
867    /// Reads the configuration from the process environment.
868    pub fn from_env() -> Result<Self> {
869        Self::from_lookup(|key| std::env::var(key).ok())
870    }
871
872    /// Reads the configuration through an arbitrary lookup function (used by tests).
873    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                // 0 = no limit
931                max_memory_bytes: mb(
932                    "TEAMCRAFT_PREVIEW_MAX_MEMORY_MB",
933                    defaults.max_memory_bytes,
934                    0,
935                )?,
936            }
937        };
938        // 0 = no limit; at most 16 TiB
939        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    /// Password-free summary for the startup log.
1194    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    /// Returns the value of `key`, or the contents of the file named by `key_FILE`.
1282    /// Empty values are treated as unset.
1283    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
1316/// Builds the PostgreSQL options either from `TEAMCRAFT_DATABASE_URL`
1317/// (falling back to `DATABASE_URL`) or from the individual `TEAMCRAFT_DB_*`
1318/// variables. The latter avoids URL-encoding problems with special characters
1319/// in passwords and works nicely with secret files.
1320/// Decodes `%XX` escapes of a URL component (the user info of the database
1321/// URL). Malformed escapes stay as they are; bytes that do not form UTF-8
1322/// keep the component undecoded.
1323fn 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        // The client tools (pg_dump, pg_restore) get the same password as the
1361        // server. The URL keeps it percent-encoded (`p%40ss` for `p@ss`);
1362        // sqlx decodes it, so decode it here as well.
1363        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    // No password: the local development database of docker-compose.yml
1381    // (trust authentication on 127.0.0.1) or a password from ~/.pgpass.
1382    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    // A directory as host: PostgreSQL's local socket (e.g. /run/postgresql)
1401    // with peer authentication as the operating-system user.
1402    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    /// Without any configuration TeamCraft uses the local development
1640    /// database of docker-compose.yml (no password, trust authentication).
1641    #[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    /// The packaged configuration: the local PostgreSQL socket, peer authentication.
1651    #[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        // the packaged system configuration parses
1667        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    /// The Docker installation: deploy/teamcraft.env.example plus the
1682    /// `environment` of deploy/docker-compose.yml give a valid configuration.
1683    #[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        // Local login is off by default once SSO is configured.
1779        assert!(!cfg.local_login);
1780        assert!(!cfg.summary().contains("s3cret"));
1781
1782        // OIDC without a client secret is a configuration error.
1783        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        // the default changes nothing: local agents are allowed
1927        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            // an empty value counts as unset, like for every variable
1936            ("", 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        // a typo must not silently leave agents allowed: refused at start
1945        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        // the old variable alone: the Anthropic defaults, as before
1979        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        // the new key variable, the alias with the same value, a conflict
1993        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        // OpenAI: model required, default base, key required
2014        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        // openai-compatible: a base URL is enough, no key
2041        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        // every setting; the run timeout follows the request timeout by default
2078        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"), // below the request timeout of 180
2096            ("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        // the key over plain http: a warning unless the host is this computer
2196        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        // key and model files with only blanks: "not set", not an empty key
2245        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        // known, file form of a known, tooling, foreign: no warning
2316        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    /// Variable-like words (`TEAMCRAFT_…`, `MATTERMOST_…`, `DATABASE_URL`) of
2343    /// `text`; with `quoted` only those that are a whole string literal.
2344    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        // a sentinel space flushes a word at the end of the text
2349        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        // the command line reads these two itself (src/main.rs)
2392        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}