refactor: removing clap dep

Cargo.lock

···
 ]
 
 [[package]]
-name = "anstream"
-version = "0.6.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ae563653d1938f79b1ab1b5e668c87c76a9930414574a6583a7b7e11a8e6192"
-dependencies = [
- "anstyle",
- "anstyle-parse",
- "anstyle-query",
- "anstyle-wincon",
- "colorchoice",
- "is_terminal_polyfill",
- "utf8parse",
-]
-
-[[package]]
-name = "anstyle"
-version = "1.0.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "862ed96ca487e809f1c8e5a8447f6ee2cf102f846893800b20cebdf541fc6bbd"
-
-[[package]]
-name = "anstyle-parse"
-version = "0.2.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2"
-dependencies = [
- "utf8parse",
-]
-
-[[package]]
-name = "anstyle-query"
-version = "1.1.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e231f6134f61b71076a3eab506c379d4f36122f2af15a9ff04415ea4c3339e2"
-dependencies = [
- "windows-sys 0.60.2",
-]
-
-[[package]]
-name = "anstyle-wincon"
-version = "3.0.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e0633414522a32ffaac8ac6cc8f748e090c5717661fddeea04219e2344f5f2a"
-dependencies = [
- "anstyle",
- "once_cell_polyfill",
- "windows-sys 0.60.2",
-]
-
-[[package]]
 name = "anyhow"
 version = "1.0.99"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
-name = "clap"
-version = "4.5.47"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7eac00902d9d136acd712710d71823fb8ac8004ca445a89e73a41d45aa712931"
-dependencies = [
- "clap_builder",
- "clap_derive",
-]
-
-[[package]]
-name = "clap_builder"
-version = "4.5.47"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ad9bbf750e73b5884fb8a211a9424a1906c1e156724260fdae972f31d70e1d6"
-dependencies = [
- "anstream",
- "anstyle",
- "clap_lex",
- "strsim",
-]
-
-[[package]]
-name = "clap_derive"
-version = "4.5.47"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbfd7eae0b0f1a6e63d4b13c9c478de77c2eb546fba158ad50b4203dc24b9f9c"
-dependencies = [
- "heck",
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "clap_lex"
-version = "0.7.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b94f61472cee1439c0b966b47e3aca9ae07e45d070759512cd390ea2bebc6675"
-
-[[package]]
-name = "colorchoice"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
-
-[[package]]
 name = "combine"
 version = "4.6.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
-name = "is_terminal_polyfill"
-version = "1.70.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
-
-[[package]]
 name = "itoa"
 version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 ]
 
 [[package]]
-name = "once_cell_polyfill"
-version = "1.70.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4895175b425cb1f87721b59f0f286c2092bd4af812243672510e1ac53e2e0ad"
-
-[[package]]
 name = "openssl"
 version = "0.10.73"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
  "atproto-identity",
  "axum",
  "bincode",
- "clap",
  "deadpool-redis",
  "metrohash",
  "reqwest",
···
 ]
 
 [[package]]
-name = "strsim"
-version = "0.11.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
-
-[[package]]
 name = "subtle"
 version = "2.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
-
-[[package]]
-name = "utf8parse"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
 [[package]]
 name = "uuid"

Cargo.toml

···
 atproto-identity = { version = "0.11.3" }
 axum = { version = "0.8" }
 bincode = { version = "2.0.1", features = ["serde"] }
-clap = { version = "4", features = ["derive", "env"] }
 deadpool-redis = { version = "0.22", features = ["connection-manager", "tokio-comp", "tokio-rustls-comp"] }
 metrohash = "1.0.7"
 reqwest = { version = "0.12", features = ["json"] }

src/bin/quickdid.rs

···
     key::{identify_key, to_public},
     resolve::HickoryDnsResolver,
 };
-use clap::Parser;
 use quickdid::{
     cache::create_redis_pool,
-    config::{Args, Config},
+    config::Config,
     handle_resolver::{
         create_base_resolver, create_caching_resolver, create_redis_resolver_with_ttl,
         create_sqlite_resolver_with_ttl,
···
     }
 }
 
+/// Simple command-line argument handling for --version and --help
+fn handle_simple_args() -> bool {
+    let args: Vec<String> = std::env::args().collect();
+    
+    if args.len() > 1 {
+        match args[1].as_str() {
+            "--version" | "-V" => {
+                println!("quickdid {}", env!("CARGO_PKG_VERSION"));
+                return true;
+            }
+            "--help" | "-h" => {
+                println!("QuickDID - AT Protocol Identity Resolver Service");
+                println!("Version: {}", env!("CARGO_PKG_VERSION"));
+                println!();
+                println!("USAGE:");
+                println!("    quickdid [OPTIONS]");
+                println!();
+                println!("OPTIONS:");
+                println!("    -h, --help       Print help information");
+                println!("    -V, --version    Print version information");
+                println!();
+                println!("ENVIRONMENT VARIABLES:");
+                println!("    SERVICE_KEY         Private key for service identity (required)");
+                println!("    HTTP_EXTERNAL       External hostname for service endpoints (required)");
+                println!("    HTTP_PORT           HTTP server port (default: 8080)");
+                println!("    PLC_HOSTNAME        PLC directory hostname (default: plc.directory)");
+                println!("    USER_AGENT          HTTP User-Agent header (auto-generated with version)");
+                println!("    DNS_NAMESERVERS     Custom DNS nameservers (comma-separated IPs)");
+                println!("    CERTIFICATE_BUNDLES Additional CA certificates (comma-separated paths)");
+                println!();
+                println!("    CACHING:");
+                println!("    REDIS_URL           Redis URL for handle resolution caching");
+                println!("    SQLITE_URL          SQLite database URL for handle resolution caching");
+                println!("    CACHE_TTL_MEMORY    TTL for in-memory cache in seconds (default: 600)");
+                println!("    CACHE_TTL_REDIS     TTL for Redis cache in seconds (default: 7776000)");
+                println!("    CACHE_TTL_SQLITE    TTL for SQLite cache in seconds (default: 7776000)");
+                println!();
+                println!("    QUEUE CONFIGURATION:");
+                println!("    QUEUE_ADAPTER       Queue adapter: 'mpsc', 'redis', 'sqlite', 'noop' (default: mpsc)");
+                println!("    QUEUE_REDIS_URL     Redis URL for queue adapter");
+                println!("    QUEUE_REDIS_PREFIX  Redis key prefix for queues (default: queue:handleresolver:)");
+                println!("    QUEUE_REDIS_TIMEOUT Queue blocking timeout in seconds (default: 5)");
+                println!("    QUEUE_WORKER_ID     Worker ID for Redis queue (default: worker1)");
+                println!("    QUEUE_BUFFER_SIZE   Buffer size for MPSC queue (default: 1000)");
+                println!("    QUEUE_SQLITE_MAX_SIZE Maximum SQLite queue size (default: 10000)");
+                println!();
+                println!("For more information, visit: https://github.com/smokesignal.events/quickdid");
+                return true;
+            }
+            _ => {}
+        }
+    }
+    
+    false
+}
+
 #[tokio::main]
 async fn main() -> Result<()> {
+    // Handle --version and --help
+    if handle_simple_args() {
+        return Ok(());
+    }
+
     // Initialize tracing
     tracing_subscriber::registry()
         .with(
···
         .with(tracing_subscriber::fmt::layer())
         .init();
 
-    let args = Args::parse();
-    let config = Config::from_args(args)?;
+    let config = Config::from_env()?;
 
     // Validate configuration
     config.validate()?;

src/config.rs

···
 //!
 //! ## Configuration Sources
 //!
-//! Configuration can be provided through:
-//! - Environment variables (highest priority)
-//! - Command-line arguments
-//! - Default values (lowest priority)
+//! Configuration is provided exclusively through environment variables following
+//! the 12-factor app methodology.
 //!
 //! ## Example
 //!
···
 //! quickdid
 //! ```
 
-use atproto_identity::config::optional_env;
-use clap::Parser;
+use std::env;
 use thiserror::Error;
 
 /// Configuration-specific errors following the QuickDID error format
···
     InvalidTimeout(String),
 }
 
-#[derive(Parser, Clone)]
-#[command(
-    name = "quickdid",
-    about = "QuickDID - AT Protocol Identity Resolver Service",
-    long_about = "
-A fast identity resolution service for the AT Protocol ecosystem.
-This service provides identity resolution endpoints and handle resolution
-capabilities with in-memory caching.
-
-FEATURES:
-  - AT Protocol identity resolution and DID document management
-  - Handle resolution with in-memory caching
-  - DID:web identity publishing via .well-known endpoints
-  - Health check endpoint
-
-ENVIRONMENT VARIABLES:
-  SERVICE_KEY         Private key for service identity (required)
-  HTTP_EXTERNAL       External hostname for service endpoints (required)
-  HTTP_PORT           HTTP server port (default: 8080)
-  PLC_HOSTNAME        PLC directory hostname (default: plc.directory)
-  USER_AGENT          HTTP User-Agent header (auto-generated with version)
-  DNS_NAMESERVERS     Custom DNS nameservers (comma-separated IPs)
-  CERTIFICATE_BUNDLES Additional CA certificates (comma-separated paths)
-  
-  CACHING:
-  REDIS_URL           Redis URL for handle resolution caching (optional)
-  SQLITE_URL          SQLite database URL for handle resolution caching (optional)
-  CACHE_TTL_MEMORY    TTL for in-memory cache in seconds (default: 600)
-  CACHE_TTL_REDIS     TTL for Redis cache in seconds (default: 7776000 = 90 days)
-  CACHE_TTL_SQLITE    TTL for SQLite cache in seconds (default: 7776000 = 90 days)
-  
-  QUEUE CONFIGURATION:
-  QUEUE_ADAPTER       Queue adapter: 'mpsc', 'redis', 'sqlite', 'noop', 'none' (default: mpsc)
-  QUEUE_REDIS_URL     Redis URL for queue adapter (uses REDIS_URL if not set)
-  QUEUE_REDIS_PREFIX  Redis key prefix for queues (default: queue:handleresolver:)
-  QUEUE_REDIS_TIMEOUT Queue blocking timeout in seconds (default: 5)
-  QUEUE_WORKER_ID     Worker ID for Redis queue (default: worker1)
-  QUEUE_BUFFER_SIZE   Buffer size for MPSC queue (default: 1000)
-  QUEUE_SQLITE_MAX_SIZE Maximum SQLite queue size for work shedding (default: 10000, 0=unlimited)
-"
-)]
-/// Command-line arguments and environment variables configuration
-pub struct Args {
-    /// HTTP server port to bind to
-    ///
-    /// Examples: "8080", "3000", "80"
-    /// Constraints: Must be a valid port number (1-65535)
-    #[arg(long, env = "HTTP_PORT", default_value = "8080")]
-    pub http_port: String,
-
-    /// PLC directory hostname for DID resolution
-    ///
-    /// Examples: "plc.directory", "test.plc.directory"
-    /// Use "plc.directory" for production
-    #[arg(long, env = "PLC_HOSTNAME", default_value = "plc.directory")]
-    pub plc_hostname: String,
-
-    /// External hostname for service endpoints (REQUIRED)
-    ///
-    /// Examples:
-    /// - "quickdid.example.com" (standard)
-    /// - "quickdid.example.com:8080" (with port)
-    /// - "localhost:3007" (development)
-    #[arg(long, env = "HTTP_EXTERNAL")]
-    pub http_external: Option<String>,
-
-    /// Private key for service identity in DID format (REQUIRED)
-    ///
-    /// Examples:
-    /// - "did:key:z42tmZxD2mi1TfMKSFrsRfednwdaaPNZiiWHP4MPgcvXkDWK"
-    /// - "did:plc:xyz123abc456"
-    ///
-    /// SECURITY: Keep this key secure and never commit to version control
-    #[arg(long, env = "SERVICE_KEY")]
-    pub service_key: Option<String>,
-
-    /// HTTP User-Agent header for outgoing requests
-    ///
-    /// Example: `quickdid/1.0.0 (+https://quickdid.example.com)`
-    /// Default: Auto-generated with current version
-    #[arg(long, env = "USER_AGENT")]
-    pub user_agent: Option<String>,
-
-    /// Custom DNS nameservers (comma-separated IP addresses)
-    ///
-    /// Examples:
-    /// - "8.8.8.8,8.8.4.4" (Google DNS)
-    /// - "1.1.1.1,1.0.0.1" (Cloudflare DNS)
-    /// - "192.168.1.1" (Local DNS)
-    #[arg(long, env = "DNS_NAMESERVERS")]
-    pub dns_nameservers: Option<String>,
-
-    /// Additional CA certificates (comma-separated file paths)
-    ///
-    /// Examples:
-    /// - "/etc/ssl/certs/custom-ca.pem"
-    /// - "/certs/ca1.pem,/certs/ca2.pem"
-    ///
-    /// Use for custom or internal certificate authorities
-    #[arg(long, env = "CERTIFICATE_BUNDLES")]
-    pub certificate_bundles: Option<String>,
+/// Helper function to get an environment variable with an optional default
+fn get_env_or_default(key: &str, default: Option<&str>) -> Option<String> {
+    match env::var(key) {
+        Ok(val) if !val.is_empty() => Some(val),
+        _ => default.map(String::from),
+    }
+}
 
-    /// Redis connection URL for caching
-    ///
-    /// Examples:
-    /// - "redis://localhost:6379/0" (local, no auth)
-    /// - "redis://user:[e-mail]:6379/0" (with auth)
-    /// - "rediss://secure-redis.example.com:6380/0" (TLS)
-    ///
-    /// Benefits: Persistent cache, distributed caching, better performance
-    #[arg(long, env = "REDIS_URL")]
-    pub redis_url: Option<String>,
-
-    /// SQLite database URL for caching
-    ///
-    /// Examples:
-    /// - "sqlite:./quickdid.db" (file-based database)
-    /// - "sqlite::memory:" (in-memory database for testing)
-    /// - "sqlite:/path/to/cache.db" (absolute path)
-    ///
-    /// Benefits: Persistent cache, single-file storage, no external dependencies
-    #[arg(long, env = "SQLITE_URL")]
-    pub sqlite_url: Option<String>,
-
-    /// Queue adapter type for background processing
-    ///
-    /// Values:
-    /// - "mpsc": In-memory multi-producer single-consumer queue
-    /// - "redis": Redis-backed distributed queue
-    /// - "sqlite": SQLite-backed persistent queue
-    /// - "noop": Disable queue processing (for testing)
-    /// - "none": Alias for "noop"
-    ///
-    /// Default: "mpsc" for single-instance deployments
-    #[arg(long, env = "QUEUE_ADAPTER", default_value = "mpsc")]
-    pub queue_adapter: String,
-
-    /// Redis URL specifically for queue operations
-    ///
-    /// Falls back to REDIS_URL if not specified
-    /// Use when separating cache and queue Redis instances
-    #[arg(long, env = "QUEUE_REDIS_URL")]
-    pub queue_redis_url: Option<String>,
-
-    /// Redis key prefix for queue operations
-    ///
-    /// Examples:
-    /// - "queue:handleresolver:" (default)
-    /// - "prod:queue:hr:" (environment-specific)
-    /// - "quickdid:v1:queue:" (version-specific)
-    ///
-    /// Use to namespace queues when sharing Redis
-    #[arg(
-        long,
-        env = "QUEUE_REDIS_PREFIX",
-        default_value = "queue:handleresolver:"
-    )]
-    pub queue_redis_prefix: String,
-
-    /// Worker ID for Redis queue operations
-    ///
-    /// Examples: "worker-001", "prod-us-east-1", "quickdid-1"
-    /// Default: "worker1"
-    ///
-    /// Use for identifying specific workers in logs
-    #[arg(long, env = "QUEUE_WORKER_ID")]
-    pub queue_worker_id: Option<String>,
-
-    /// Buffer size for MPSC queue
-    ///
-    /// Range: 100-100000 (recommended)
-    /// Default: 1000
-    ///
-    /// Increase for high-traffic deployments
-    #[arg(long, env = "QUEUE_BUFFER_SIZE", default_value = "1000")]
-    pub queue_buffer_size: usize,
-
-    /// TTL for in-memory cache in seconds
-    ///
-    /// Range: 60-3600 (recommended)
-    /// Default: 600 (10 minutes)
-    ///
-    /// Lower values = fresher data, more resolution requests
-    /// Higher values = better performance, potentially stale data
-    #[arg(long, env = "CACHE_TTL_MEMORY", default_value = "600")]
-    pub cache_ttl_memory: u64,
-
-    /// TTL for Redis cache in seconds
-    ///
-    /// Range: 3600-31536000 (1 hour to 1 year)
-    /// Default: 7776000 (90 days)
-    ///
-    /// Recommendation: 86400 (1 day) for frequently changing data
-    #[arg(long, env = "CACHE_TTL_REDIS", default_value = "7776000")]
-    pub cache_ttl_redis: u64,
-
-    /// TTL for SQLite cache in seconds
-    ///
-    /// Range: 3600-31536000 (1 hour to 1 year)
-    /// Default: 7776000 (90 days)
-    ///
-    /// Recommendation: 86400 (1 day) for frequently changing data
-    #[arg(long, env = "CACHE_TTL_SQLITE", default_value = "7776000")]
-    pub cache_ttl_sqlite: u64,
-
-    /// Redis blocking timeout for queue operations in seconds
-    ///
-    /// Range: 1-60 (recommended)
-    /// Default: 5
-    ///
-    /// Lower values = more responsive to shutdown
-    /// Higher values = less Redis polling overhead
-    #[arg(long, env = "QUEUE_REDIS_TIMEOUT", default_value = "5")]
-    pub queue_redis_timeout: u64,
-
-    /// Maximum queue size for SQLite adapter (work shedding)
-    ///
-    /// Range: 100-1000000 (recommended)
-    /// Default: 10000
-    ///
-    /// When the SQLite queue exceeds this limit, the oldest entries are deleted
-    /// to maintain the queue size. This prevents unbounded queue growth while
-    /// preserving the most recently queued work items.
-    ///
-    /// Set to 0 to disable work shedding (unlimited queue size)
-    #[arg(long, env = "QUEUE_SQLITE_MAX_SIZE", default_value = "10000")]
-    pub queue_sqlite_max_size: u64,
+/// Helper function to parse an environment variable as a specific type
+fn parse_env<T: std::str::FromStr>(key: &str, default: T) -> Result<T, ConfigError> 
+where
+    T::Err: std::fmt::Display,
+{
+    match env::var(key) {
+        Ok(val) if !val.is_empty() => val.parse::<T>()
+            .map_err(|e| ConfigError::InvalidValue(format!("{}: {}", key, e))),
+        _ => Ok(default),
+    }
 }
 
 /// Validated configuration for QuickDID service
···
 /// ## Example
 ///
 /// ```rust,no_run
-/// use quickdid::config::{Args, Config};
-/// use clap::Parser;
+/// use quickdid::config::Config;
 ///
 /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-/// let args = Args::parse();
-/// let config = Config::from_args(args)?;
+/// let config = Config::from_env()?;
 /// config.validate()?;
 ///
 /// println!("Service running at: {}", config.http_external);
···
 }
 
 impl Config {
-    /// Create a validated Config from command-line arguments and environment variables
+    /// Create a validated Config from environment variables
     ///
     /// This method:
-    /// 1. Processes command-line arguments with environment variable fallbacks
+    /// 1. Reads configuration from environment variables
     /// 2. Validates required fields (HTTP_EXTERNAL and SERVICE_KEY)
     /// 3. Generates derived values (service_did from http_external)
     /// 4. Applies defaults where appropriate
     ///
-    /// ## Priority Order
-    ///
-    /// 1. Command-line arguments (highest priority)
-    /// 2. Environment variables
-    /// 3. Default values (lowest priority)
-    ///
     /// ## Example
     ///
     /// ```rust,no_run
-    /// use quickdid::config::{Args, Config};
-    /// use clap::Parser;
+    /// use quickdid::config::Config;
     ///
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-    /// // Parse from environment and command-line
-    /// let args = Args::parse();
-    /// let config = Config::from_args(args)?;
+    /// // Parse from environment variables
+    /// let config = Config::from_env()?;
     ///
     /// // The service DID is automatically generated from HTTP_EXTERNAL
     /// assert!(config.service_did.starts_with("did:web:"));
···
     /// Returns `ConfigError::MissingRequired` if:
     /// - HTTP_EXTERNAL is not provided
     /// - SERVICE_KEY is not provided
-    pub fn from_args(args: Args) -> Result<Self, ConfigError> {
-        let http_external = args
-            .http_external
-            .or_else(|| {
-                let env_val = optional_env("HTTP_EXTERNAL");
-                if env_val.is_empty() {
-                    None
-                } else {
-                    Some(env_val)
-                }
-            })
+    pub fn from_env() -> Result<Self, ConfigError> {
+        // Required fields
+        let http_external = env::var("HTTP_EXTERNAL")
+            .ok()
+            .filter(|s| !s.is_empty())
             .ok_or_else(|| ConfigError::MissingRequired("HTTP_EXTERNAL".to_string()))?;
 
-        let service_key = args
-            .service_key
-            .or_else(|| {
-                let env_val = optional_env("SERVICE_KEY");
-                if env_val.is_empty() {
-                    None
-                } else {
-                    Some(env_val)
-                }
-            })
+        let service_key = env::var("SERVICE_KEY")
+            .ok()
+            .filter(|s| !s.is_empty())
             .ok_or_else(|| ConfigError::MissingRequired("SERVICE_KEY".to_string()))?;
 
+        // Generate default user agent
         let default_user_agent = format!(
             "quickdid/{} (+https://github.com/smokesignal.events/quickdid)",
             env!("CARGO_PKG_VERSION")
         );
 
-        let user_agent = args
-            .user_agent
-            .or_else(|| {
-                let env_val = optional_env("USER_AGENT");
-                if env_val.is_empty() {
-                    None
-                } else {
-                    Some(env_val)
-                }
-            })
-            .unwrap_or(default_user_agent);
-
+        // Generate service DID from http_external
         let service_did = if http_external.contains(':') {
             let encoded_external = http_external.replace(':', "%3A");
             format!("did:web:{}", encoded_external)
···
         };
 
         Ok(Config {
-            http_port: args.http_port,
-            plc_hostname: args.plc_hostname,
+            http_port: get_env_or_default("HTTP_PORT", Some("8080")).unwrap(),
+            plc_hostname: get_env_or_default("PLC_HOSTNAME", Some("plc.directory")).unwrap(),
             http_external,
             service_key,
-            user_agent,
+            user_agent: get_env_or_default("USER_AGENT", None).unwrap_or(default_user_agent),
             service_did,
-            dns_nameservers: args.dns_nameservers.or_else(|| {
-                let env_val = optional_env("DNS_NAMESERVERS");
-                if env_val.is_empty() {
-                    None
-                } else {
-                    Some(env_val)
-                }
-            }),
-            certificate_bundles: args.certificate_bundles.or_else(|| {
-                let env_val = optional_env("CERTIFICATE_BUNDLES");
-                if env_val.is_empty() {
-                    None
-                } else {
-                    Some(env_val)
-                }
-            }),
-            redis_url: args.redis_url.or_else(|| {
-                let env_val = optional_env("REDIS_URL");
-                if env_val.is_empty() {
-                    None
-                } else {
-                    Some(env_val)
-                }
-            }),
-            sqlite_url: args.sqlite_url.or_else(|| {
-                let env_val = optional_env("SQLITE_URL");
-                if env_val.is_empty() {
-                    None
-                } else {
-                    Some(env_val)
-                }
-            }),
-            queue_adapter: args.queue_adapter,
-            queue_redis_url: args.queue_redis_url.or_else(|| {
-                let env_val = optional_env("QUEUE_REDIS_URL");
-                if env_val.is_empty() {
-                    None
-                } else {
-                    Some(env_val)
-                }
-            }),
-            queue_redis_prefix: args.queue_redis_prefix,
-            queue_worker_id: args.queue_worker_id
-                .or_else(|| {
-                    let env_val = optional_env("QUEUE_WORKER_ID");
-                    if env_val.is_empty() {
-                        None
-                    } else {
-                        Some(env_val)
-                    }
-                })
-                .unwrap_or_else(|| "worker1".to_string()),
-            queue_buffer_size: args.queue_buffer_size,
-            cache_ttl_memory: args.cache_ttl_memory,
-            cache_ttl_redis: args.cache_ttl_redis,
-            cache_ttl_sqlite: args.cache_ttl_sqlite,
-            queue_redis_timeout: args.queue_redis_timeout,
-            queue_sqlite_max_size: args.queue_sqlite_max_size,
+            dns_nameservers: get_env_or_default("DNS_NAMESERVERS", None),
+            certificate_bundles: get_env_or_default("CERTIFICATE_BUNDLES", None),
+            redis_url: get_env_or_default("REDIS_URL", None),
+            sqlite_url: get_env_or_default("SQLITE_URL", None),
+            queue_adapter: get_env_or_default("QUEUE_ADAPTER", Some("mpsc")).unwrap(),
+            queue_redis_url: get_env_or_default("QUEUE_REDIS_URL", None),
+            queue_redis_prefix: get_env_or_default("QUEUE_REDIS_PREFIX", Some("queue:handleresolver:")).unwrap(),
+            queue_worker_id: get_env_or_default("QUEUE_WORKER_ID", Some("worker1")).unwrap(),
+            queue_buffer_size: parse_env("QUEUE_BUFFER_SIZE", 1000)?,
+            cache_ttl_memory: parse_env("CACHE_TTL_MEMORY", 600)?,
+            cache_ttl_redis: parse_env("CACHE_TTL_REDIS", 7776000)?,
+            cache_ttl_sqlite: parse_env("CACHE_TTL_SQLITE", 7776000)?,
+            queue_redis_timeout: parse_env("QUEUE_REDIS_TIMEOUT", 5)?,
+            queue_sqlite_max_size: parse_env("QUEUE_SQLITE_MAX_SIZE", 10000)?,
         })
     }
 
···
     /// ## Example
     ///
     /// ```rust,no_run
-    /// # use quickdid::config::{Args, Config};
-    /// # use clap::Parser;
+    /// # use quickdid::config::Config;
     /// # fn main() -> Result<(), Box<dyn std::error::Error>> {
-    /// # let args = Args::parse();
-    /// let config = Config::from_args(args)?;
+    /// let config = Config::from_env()?;
     /// config.validate()?; // Ensures all values are valid
     /// # Ok(())
     /// # }