itsi 0.1.14 → 0.1.18

data/crates/itsi_server/src/{server → services}/static_file_server.rs

@@ -1,25 +1,42 @@
-use super::{
-    middleware_stack::ErrorResponse,
-    types::{HttpRequest, HttpResponse},
+use crate::{
+    default_responses::{INTERNAL_SERVER_ERROR_RESPONSE, NOT_FOUND_RESPONSE},
+    prelude::*,
+    server::{
+        http_message_types::{HttpRequest, HttpResponse, RequestExt, ResponseFormat},
+        middleware_stack::ErrorResponse,
+    },
 };
+use base64::{engine::general_purpose, Engine};
 use bytes::Bytes;
 use chrono::{DateTime, Utc};
-use http::{header, Response, StatusCode};
+use http::{
+    header::{
+        self, CONTENT_ENCODING, CONTENT_LENGTH, CONTENT_RANGE, CONTENT_TYPE, ETAG, LAST_MODIFIED,
+    },
+    HeaderValue, Response, StatusCode,
+};
 use http_body_util::{combinators::BoxBody, Full};
 use itsi_error::Result;
 use moka::sync::Cache;
+use percent_encoding::{percent_decode_str, utf8_percent_encode, NON_ALPHANUMERIC};
 use serde::Deserialize;
+use serde_json::json;
+use sha2::{Digest, Sha256};
 use std::{
+    borrow::Cow,
+    cmp::Ordering,
     collections::HashMap,
     convert::Infallible,
     fs::Metadata,
+    ops::Deref,
     path::{Path, PathBuf},
     sync::{Arc, LazyLock},
     time::{Duration, Instant, SystemTime},
 };
 use tokio::sync::Mutex;
 use tokio::{fs::File, io::AsyncReadExt};
-use tracing::{info, warn};
+
+use super::mime_types::get_mime_type;
 
 pub static ROOT_STATIC_FILE_SERVER: LazyLock<StaticFileServer> = LazyLock::new(|| {
     StaticFileServer::new(StaticFileServerConfig {
@@ -29,7 +46,9 @@ pub static ROOT_STATIC_FILE_SERVER: LazyLock<StaticFileServer> = LazyLock::new(|
         recheck_interval: Duration::from_secs(1),
         try_html_extension: true,
         auto_index: true,
-        not_found_behavior: NotFoundBehavior::Error(ErrorResponse::default()),
+        not_found_behavior: NotFoundBehavior::Error(ErrorResponse::not_found()),
+        serve_hidden_files: false,
+        allowed_extensions: vec!["html".to_string(), "css".to_string(), "js".to_string()],
     })
 });
 
@@ -61,6 +80,8 @@ pub struct StaticFileServerConfig {
     pub try_html_extension: bool,
     pub auto_index: bool,
     pub not_found_behavior: NotFoundBehavior,
+    pub serve_hidden_files: bool,
+    pub allowed_extensions: Vec<String>,
 }
 
 #[derive(Debug, Clone)]
@@ -70,13 +91,55 @@ pub struct StaticFileServer {
     cache: Cache<PathBuf, CacheEntry>,
 }
 
+impl Deref for StaticFileServer {
+    type Target = StaticFileServerConfig;
+
+    fn deref(&self) -> &Self::Target {
+        &self.config
+    }
+}
+
 #[derive(Clone, Debug)]
 struct CacheEntry {
     content: Arc<Bytes>,
+    br_encoded: Option<Arc<Bytes>>,
+    zstd_encoded: Option<Arc<Bytes>>,
+    gzip_encoded: Option<Arc<Bytes>>,
+    deflate_encoded: Option<Arc<Bytes>>,
+    etag: String,
     last_modified: SystemTime,
     last_checked: Instant,
 }
 
+impl CacheEntry {
+    pub fn suggest_content_for(&self, supported_encodings: &[HeaderValue]) -> (Arc<Bytes>, &str) {
+        for encoding_header in supported_encodings {
+            if let Ok(header_value) = encoding_header.to_str() {
+                for header_value in header_value.split(",").map(|hv| hv.trim()) {
+                    for algo in header_value.split(";").map(|hv| hv.trim()) {
+                        match algo {
+                            "zstd" if self.zstd_encoded.is_some() => {
+                                return (self.zstd_encoded.clone().unwrap(), "zstd")
+                            }
+                            "gzip" if self.gzip_encoded.is_some() => {
+                                return (self.gzip_encoded.clone().unwrap(), "gzip")
+                            }
+                            "br" if self.br_encoded.is_some() => {
+                                return (self.br_encoded.clone().unwrap(), "br")
+                            }
+                            "deflate" if self.deflate_encoded.is_some() => {
+                                return (self.deflate_encoded.clone().unwrap(), "deflate")
+                            }
+                            _ => {}
+                        }
+                    }
+                }
+            }
+        }
+        (self.content.clone(), "identity")
+    }
+}
+
 #[derive(Debug, Clone)]
 pub enum ServeRange {
     Range(u64, u64),
@@ -86,21 +149,48 @@ pub enum ServeRange {
 impl CacheEntry {
     async fn new(path: PathBuf) -> Result<Self> {
         let (bytes, last_modified) = read_entire_file(&path).await?;
+        let etag = {
+            let mut hasher = Sha256::new();
+            hasher.update(&bytes);
+            let result = hasher.finalize();
+            general_purpose::STANDARD.encode(result)
+        };
         Ok(CacheEntry {
             content: Arc::new(bytes),
+            gzip_encoded: read_variant(&path, "gz").await.map(Arc::new),
+            br_encoded: read_variant(&path, "br").await.map(Arc::new),
+            zstd_encoded: read_variant(&path, "zstd").await.map(Arc::new),
+            deflate_encoded: read_variant(&path, "deflate").await.map(Arc::new),
             last_modified,
+            etag,
             last_checked: Instant::now(),
         })
     }
 
-    async fn new_virtual_listing(path: PathBuf, root_dir: &Path) -> Self {
-        let directory_listing: Bytes = generate_directory_listing(path.parent().unwrap(), root_dir)
-            .await
-            .unwrap_or("".to_owned())
-            .into();
+    async fn new_virtual_listing(
+        path: PathBuf,
+        config: &StaticFileServerConfig,
+        accept: ResponseFormat,
+    ) -> Self {
+        let directory_listing: Bytes =
+            generate_directory_listing(path.parent().unwrap(), config, accept)
+                .await
+                .unwrap_or("".to_owned())
+                .into();
+        let etag = {
+            let mut hasher = Sha256::new();
+            hasher.update(&directory_listing);
+            let result = hasher.finalize();
+            general_purpose::STANDARD.encode(result)
+        };
         CacheEntry {
             content: Arc::new(directory_listing),
+            gzip_encoded: None,
+            br_encoded: None,
+            zstd_encoded: None,
+            deflate_encoded: None,
             last_modified: SystemTime::now(),
+            etag,
             last_checked: Instant::now(),
         }
     }
@@ -115,6 +205,7 @@ struct ServeCacheArgs<'a>(
     Option<SystemTime>,
     bool,
     &'a Path,
+    &'a [HeaderValue],
 );
 
 impl StaticFileServer {
@@ -128,6 +219,7 @@ impl StaticFileServer {
         }
     }
 
+    #[allow(clippy::too_many_arguments)]
     pub async fn serve(
         &self,
         request: &HttpRequest,
@@ -136,8 +228,11 @@ impl StaticFileServer {
         serve_range: ServeRange,
         if_modified_since: Option<SystemTime>,
         is_head_request: bool,
+        supported_encodings: &[HeaderValue],
     ) -> Option<HttpResponse> {
-        let resolved = self.resolve(path, abs_path).await;
+        let accept: ResponseFormat = request.accept().into();
+        let resolved = self.resolve(path, abs_path, accept.clone()).await;
+
         Some(match resolved {
             Ok(ResolvedAsset {
                 path,
@@ -160,6 +255,7 @@ impl StaticFileServer {
                         if_modified_since,
                         is_head_request,
                         &path,
+                        supported_encodings,
                     ))
                 } else {
                     self.serve_stream_content(ServeStreamArgs(
@@ -184,27 +280,58 @@ impl StaticFileServer {
                 .unwrap(),
             Err(not_found_behavior) => match not_found_behavior {
                 NotFoundBehavior::Error(error_response) => {
-                    error_response.to_http_response(request).await
+                    error_response
+                        .to_http_response(request.accept().into())
+                        .await
                 }
                 NotFoundBehavior::FallThrough => return None,
                 NotFoundBehavior::IndexFile(index_file) => {
-                    self.serve_single(index_file.to_str().unwrap()).await
+                    self.serve_single(index_file.to_str().unwrap(), accept, supported_encodings)
+                        .await
                 }
                 NotFoundBehavior::Redirect(redirect) => Response::builder()
                     .status(StatusCode::MOVED_PERMANENTLY)
                     .header(header::LOCATION, redirect.to)
                     .body(BoxBody::new(Full::new(Bytes::new())))
                     .unwrap(),
-                NotFoundBehavior::InternalServerError => Response::builder()
-                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                    .body(BoxBody::new(Full::new(Bytes::new())))
-                    .unwrap(),
+                NotFoundBehavior::InternalServerError => {
+                    INTERNAL_SERVER_ERROR_RESPONSE
+                        .to_http_response(request.accept().into())
+                        .await
+                }
             },
         })
     }
 
-    pub async fn serve_single(&self, path: &str) -> HttpResponse {
-        let resolved = self.resolve(path, path).await;
+    pub async fn serve_single_abs(
+        &self,
+        path: &str,
+        accept: ResponseFormat,
+        supported_encodings: &[HeaderValue],
+    ) -> HttpResponse {
+        if let (Ok(root), Ok(path_buf)) = (
+            self.root_dir.canonicalize(),
+            PathBuf::from(path).canonicalize(),
+        ) {
+            // Check that the path is under root.
+            if let Ok(stripped) = path_buf.strip_prefix(root) {
+                if let Some(stripped_str) = stripped.to_str() {
+                    return self
+                        .serve_single(stripped_str, accept, supported_encodings)
+                        .await;
+                }
+            }
+        }
+        NOT_FOUND_RESPONSE.to_http_response(accept).await
+    }
+
+    pub async fn serve_single(
+        &self,
+        path: &str,
+        accept: ResponseFormat,
+        supported_encodings: &[HeaderValue],
+    ) -> HttpResponse {
+        let resolved = self.resolve(path, path, accept).await;
         if let Ok(ResolvedAsset {
             path,
             cache_entry: Some(cache_entry),
@@ -219,6 +346,7 @@ impl StaticFileServer {
                 None,
                 false,
                 &path,
+                supported_encodings,
             ));
         } else if let Ok(ResolvedAsset { path, metadata, .. }) = resolved {
             return self
@@ -245,6 +373,7 @@ impl StaticFileServer {
         &self,
         key: &str,
         abs_path: &str,
+        accept: ResponseFormat,
     ) -> std::result::Result<ResolvedAsset, NotFoundBehavior> {
         // First check if we have a cached mapping for this key
         if let Some(path) = self.key_to_path.lock().await.get(key) {
@@ -290,7 +419,20 @@ impl StaticFileServer {
         }
 
         // No valid cached entry, resolve the key to a file path
-        let normalized_path = normalize_path(key).ok_or(NotFoundBehavior::InternalServerError)?;
+        let decoded_key = percent_decode_str(key).decode_utf8_lossy();
+        let normalized_path =
+            normalize_path(decoded_key).ok_or(NotFoundBehavior::InternalServerError)?;
+
+        if !self.config.serve_hidden_files
+            && normalized_path
+                .file_name()
+                .and_then(|f| f.to_str())
+                .unwrap_or("")
+                .starts_with('.')
+        {
+            return Err(self.config.not_found_behavior.clone());
+        }
+
         let mut full_path = self.config.root_dir.clone();
         full_path.push(normalized_path);
         // Check if path exists and is a file
@@ -368,14 +510,17 @@ impl StaticFileServer {
                         });
                     }
 
-                    // No index.html, check if auto_index is enabled
                     if self.config.auto_index {
-                        // Create a virtual path for the directory listing
-                        let virtual_path = full_path.join(".directory_listing.dir_list");
+                        let virtual_path = if matches!(accept, ResponseFormat::JSON) {
+                            full_path.join(".directory_listing.dir_list_json")
+                        } else {
+                            full_path.join(".directory_listing.dir_list")
+                        };
 
                         let cache_entry = CacheEntry::new_virtual_listing(
                             virtual_path.clone(),
-                            &self.config.root_dir,
+                            &self.config,
+                            accept,
                         )
                         .await;
                         self.key_to_path
@@ -584,6 +729,8 @@ impl StaticFileServer {
 
             build_file_response(
                 status,
+                None,
+                None,
                 get_mime_type(&file),
                 (end_idx - start) as usize,
                 last_modified,
@@ -593,6 +740,8 @@ impl StaticFileServer {
         } else {
             build_file_response(
                 status,
+                None,
+                None,
                 get_mime_type(&file),
                 content_length as usize,
                 last_modified,
@@ -614,11 +763,11 @@ impl StaticFileServer {
             if_modified_since,
             is_head_request,
             path,
+            supported_encodings,
         ) = serve_cache_args;
 
         let content_length = cache_entry.content.len() as u64;
 
-        // Handle If-Modified-Since header
         if is_not_modified(cache_entry.last_modified, if_modified_since) {
             return build_not_modified_response();
         }
@@ -677,15 +826,20 @@ impl StaticFileServer {
             return builder.body(BoxBody::new(Full::new(Bytes::new()))).unwrap();
         }
 
-        // For GET requests, prepare the actual content
         if is_range_request {
-            // Extract the requested range from the cached content
             let start_idx = start as usize;
             let end_idx = std::cmp::min((adjusted_end + 1) as usize, cache_entry.content.len());
             let range_bytes = cache_entry.content.slice(start_idx..end_idx);
-
+            let etag = {
+                let mut hasher = Sha256::new();
+                hasher.update(&range_bytes);
+                let result = hasher.finalize();
+                general_purpose::STANDARD.encode(result)
+            };
             build_file_response(
                 status,
+                None,
+                Some(&etag),
                 get_mime_type(path),
                 range_bytes.len(),
                 cache_entry.last_modified,
@@ -694,10 +848,12 @@ impl StaticFileServer {
             )
         } else {
             // Return the full content
-            let content_clone = cache_entry.content.clone();
-            let body = build_ok_body(content_clone);
+            let (content, encoding) = cache_entry.suggest_content_for(supported_encodings);
+            let body = build_ok_body(content);
             build_file_response(
                 status,
+                Some(encoding),
+                Some(&cache_entry.etag),
                 get_mime_type(path),
                 content_length as usize,
                 cache_entry.last_modified,
@@ -728,38 +884,31 @@ async fn read_entire_file(path: &Path) -> std::io::Result<(Bytes, SystemTime)> {
     Ok((Bytes::from(buf), last_modified))
 }
 
-fn build_ok_body(bytes: Arc<Bytes>) -> BoxBody<Bytes, Infallible> {
-    BoxBody::new(Full::new(bytes.as_ref().clone()))
+fn with_added_extension(path: &Path, ext: &str) -> PathBuf {
+    let mut new_path = path.to_path_buf();
+    if new_path.file_name().is_some() {
+        // Append the dot and extension in place.
+        new_path.as_mut_os_string().push(".");
+        new_path.as_mut_os_string().push(ext);
+    }
+    new_path
 }
 
-// Helper for mime type mapping from file extension
-fn get_mime_type(path: &Path) -> &'static str {
-    match path.extension().and_then(|e| e.to_str()) {
-        Some("html") | Some("htm") => "text/html",
-        Some("css") => "text/css",
-        Some("js") => "application/javascript",
-        Some("json") => "application/json",
-        Some("txt") => "text/plain",
-        Some("png") => "image/png",
-        Some("jpg") | Some("jpeg") => "image/jpeg",
-        Some("gif") => "image/gif",
-        Some("svg") => "image/svg+xml",
-        Some("ico") => "image/x-icon",
-        Some("webp") => "image/webp",
-        Some("pdf") => "application/pdf",
-        Some("xml") => "application/xml",
-        Some("zip") => "application/zip",
-        Some("gz") => "application/gzip",
-        Some("mp3") => "audio/mpeg",
-        Some("mp4") => "video/mp4",
-        Some("webm") => "video/webm",
-        Some("woff") => "font/woff",
-        Some("woff2") => "font/woff2",
-        Some("ttf") => "font/ttf",
-        Some("otf") => "font/otf",
-        Some("dir_list") => "text/html",
-        _ => "application/octet-stream",
+async fn read_variant(path: &Path, ext: &str) -> Option<Bytes> {
+    let variant = with_added_extension(path, ext);
+    if let Ok(metadata) = tokio::fs::metadata(&variant).await {
+        if let Ok(mut file) = File::open(&variant).await {
+            let mut buf = Vec::with_capacity(metadata.len().try_into().unwrap_or(4096));
+            if file.read_to_end(&mut buf).await.is_ok() {
+                return Some(Bytes::from(buf));
+            }
+        }
     }
+    None
+}
+
+fn build_ok_body(bytes: Arc<Bytes>) -> BoxBody<Bytes, Infallible> {
+    BoxBody::new(Full::new(bytes.as_ref().clone()))
 }
 
 // Helper function to handle not modified responses
@@ -770,9 +919,11 @@ fn build_not_modified_response() -> http::Response<BoxBody<Bytes, Infallible>> {
         .unwrap()
 }
 
-// Helper function to build a file response with common headers
+#[allow(clippy::too_many_arguments)]
 fn build_file_response(
     status: StatusCode,
+    content_encoding: Option<&str>,
+    etag: Option<&str>,
     content_type: &str,
     content_length: usize,
     last_modified: SystemTime,
@@ -781,12 +932,20 @@ fn build_file_response(
 ) -> http::Response<BoxBody<Bytes, Infallible>> {
     let mut builder = Response::builder()
         .status(status)
-        .header("Content-Type", content_type)
-        .header("Content-Length", content_length)
-        .header("Last-Modified", format_http_date(last_modified));
+        .header(CONTENT_TYPE, content_type)
+        .header(CONTENT_LENGTH, content_length)
+        .header(LAST_MODIFIED, format_http_date(last_modified));
+
+    if let Some(etag) = etag {
+        builder = builder.header(ETAG, etag);
+    }
+
+    if let Some(content_encoding) = content_encoding {
+        builder = builder.header(CONTENT_ENCODING, content_encoding);
+    }
 
     if let Some(range) = range_header {
-        builder = builder.header("Content-Range", range);
+        builder = builder.header(CONTENT_RANGE, range);
     }
 
     builder.body(body).unwrap()
@@ -802,7 +961,7 @@ fn is_not_modified(last_modified: SystemTime, if_modified_since: Option<SystemTi
     false
 }
 
-fn normalize_path(path: &str) -> Option<PathBuf> {
+fn normalize_path(path: Cow<'_, str>) -> Option<PathBuf> {
     let mut normalized = PathBuf::new();
     let path = path.trim_start_matches('/');
 
@@ -849,136 +1008,317 @@ impl Default for StaticFileServer {
             recheck_interval: Duration::from_secs(60),
             try_html_extension: true,
             auto_index: true,
-            not_found_behavior: NotFoundBehavior::Error(ErrorResponse::default()),
+            not_found_behavior: NotFoundBehavior::Error(ErrorResponse::not_found()),
+            serve_hidden_files: false,
+            allowed_extensions: vec!["html".to_string(), "css".to_string(), "js".to_string()],
         };
         Self::new(config)
     }
 }
 
-async fn generate_directory_listing(dir_path: &Path, root_dir: &Path) -> std::io::Result<String> {
-    let mut html = String::new();
-
-    html.push_str("<!DOCTYPE html>\n<html>\n<head>\n");
-    html.push_str("<title>Directory listing for ");
-    html.push_str(
-        dir_path
-            .strip_prefix(root_dir)
-            .unwrap_or(Path::new(""))
-            .to_str()
-            .unwrap_or(""),
-    );
-    html.push_str("</title>\n");
-    html.push_str("<meta charset=\"UTF-8\">\n");
-    html.push_str("<meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">\n");
-    html.push_str("<style>\n");
-    html.push_str("  body { font-family: sans-serif; margin: 0; padding: 20px; }\n");
-    html.push_str("  h1 { border-bottom: 1px solid #ccc; margin-top: 0; padding-bottom: 5px; }\n");
-    html.push_str("  table { border-collapse: collapse; width: 100%; }\n");
-    html.push_str("  th, td { text-align: left; padding: 8px; }\n");
-    html.push_str("  tr:nth-child(even) { background-color: #f2f2f2; }\n");
-    html.push_str("  th { background-color: #4CAF50; color: white; }\n");
-    html.push_str("  a { text-decoration: none; color: #0366d6; }\n");
-    html.push_str("  a:hover { text-decoration: underline; }\n");
-    html.push_str("  .size { text-align: right; }\n");
-    html.push_str("  .date { white-space: nowrap; }\n");
-    html.push_str("</style>\n");
-    html.push_str("</head>\n<body>\n");
-
-    html.push_str("<h1>Directory listing for ");
-    html.push_str(&dir_path.display().to_string());
-    html.push_str("</h1>\n");
-
-    html.push_str("<table>\n");
-    html.push_str("<tr><th>Name</th><th>Size</th><th>Last Modified</th></tr>\n");
-
-    // Add parent directory link if not in root
-
-    if dir_path != root_dir {
-        info!("{} != {}", dir_path.display(), root_dir.display());
-        html.push_str("<tr><td><a href=\"..\">..</a></td><td class=\"size\">-</td><td class=\"date\">-</td></tr>\n");
-    }
+async fn generate_directory_listing(
+    dir_path: &Path,
+    config: &StaticFileServerConfig,
+    accept: ResponseFormat,
+) -> std::io::Result<String> {
+    match accept {
+        ResponseFormat::JSON => {
+            let directory_display = {
+                let display = dir_path
+                    .strip_prefix(&config.root_dir)
+                    .unwrap_or(Path::new(""))
+                    .to_string_lossy();
+                if display.is_empty() {
+                    Cow::Borrowed(".")
+                } else {
+                    display
+                }
+            };
+
+            let mut items = Vec::new();
+
+            // Add a parent directory entry if not at the root.
+            if dir_path != config.root_dir {
+                items.push(json!({
+                    "name": "..",
+                    "path": "..",
+                    "is_dir": true,
+                    "size": null,
+                    "modified": null,
+                }));
+            }
 
-    // Read the directory entries
-    let mut entries = tokio::fs::read_dir(dir_path).await.unwrap();
-    let mut files = Vec::new();
-    let mut dirs = Vec::new();
+            // Read directory entries.
+            let mut entries = tokio::fs::read_dir(dir_path).await?;
+            let mut dirs = Vec::new();
+            let mut files = Vec::new();
+
+            while let Some(entry) = entries.next_entry().await? {
+                let entry_path = entry.path();
+                let metadata = entry.metadata().await?;
+                let name = entry_path
+                    .file_name()
+                    .unwrap()
+                    .to_string_lossy()
+                    .into_owned();
+
+                if !config.serve_hidden_files && name.starts_with('.') {
+                    continue;
+                }
 
-    while let Some(entry) = entries.next_entry().await? {
-        let entry_path = entry.path();
-        let metadata = entry.metadata().await?;
-        let name = entry_path.file_name().unwrap().to_string_lossy();
+                let ext = entry_path
+                    .extension()
+                    .and_then(|s| s.to_str())
+                    .unwrap_or("");
+
+                if metadata.is_dir() {
+                    dirs.push((name, metadata));
+                } else if config.allowed_extensions.is_empty()
+                    || config.allowed_extensions.iter().any(|e| e == ext)
+                {
+                    files.push((name, metadata));
+                }
+            }
 
-        if metadata.is_dir() {
-            dirs.push((name.to_string(), metadata));
-        } else {
-            files.push((name.to_string(), metadata));
-        }
-    }
+            // Sort directories alphabetically with dot directories pushed to the bottom.
+            dirs.sort_by(|(name_a, _), (name_b, _)| {
+                let a_is_dot = name_a.starts_with('.');
+                let b_is_dot = name_b.starts_with('.');
+                if a_is_dot != b_is_dot {
+                    if a_is_dot {
+                        Ordering::Greater
+                    } else {
+                        Ordering::Less
+                    }
+                } else {
+                    name_a.cmp(name_b)
+                }
+            });
 
-    // Sort directories and files
-    dirs.sort_by(|a, b| a.0.cmp(&b.0));
-    files.sort_by(|a, b| a.0.cmp(&b.0));
-
-    // Add directories to HTML
-    for (name, metadata) in dirs {
-        html.push_str("<tr>");
-        html.push_str("<td><a href=\"");
-        html.push_str(&name);
-        html.push_str("/\">");
-        html.push_str(&name);
-        html.push_str("/</a></td>");
-        html.push_str("<td class=\"size\">-</td>");
-
-        if let Ok(modified) = metadata.modified() {
-            let formatted_time = DateTime::<Utc>::from(modified)
-                .format("%Y-%m-%d %H:%M:%S")
-                .to_string();
-            html.push_str(&format!("<td class=\"date\">{}</td>", formatted_time));
-        } else {
-            html.push_str("<td class=\"date\">-</td>");
-        }
+            // Sort files so that dot files appear last.
+            files.sort_by(|(name_a, _), (name_b, _)| {
+                let a_is_dot = name_a.starts_with('.');
+                let b_is_dot = name_b.starts_with('.');
+                if a_is_dot != b_is_dot {
+                    if a_is_dot {
+                        Ordering::Greater
+                    } else {
+                        Ordering::Less
+                    }
+                } else {
+                    name_a.cmp(name_b)
+                }
+            });
 
-        html.push_str("</tr>\n");
-    }
+            // Generate JSON entries for directories.
+            for (name, metadata) in dirs {
+                let encoded = utf8_percent_encode(&name, NON_ALPHANUMERIC).to_string();
+                let modified = metadata
+                    .modified()
+                    .ok()
+                    .map(|m| {
+                        DateTime::<Utc>::from(m)
+                            .format("%Y-%m-%d %H:%M:%S")
+                            .to_string()
+                    })
+                    .unwrap_or_else(|| "-".to_string());
+
+                items.push(json!({
+                    "name": format!("{}/", name),
+                    "path": format!("{}/", encoded),
+                    "is_dir": true,
+                    "size": null,
+                    "modified": modified,
+                }));
+            }
 
-    // Add files to HTML
-    for (name, metadata) in files {
-        html.push_str("<tr>");
-        html.push_str("<td><a href=\"");
-        html.push_str(&name);
-        html.push_str("\">");
-        html.push_str(&name);
-        html.push_str("</a></td>");
-
-        // Format file size
-        let file_size = metadata.len();
-        let formatted_size = if file_size < 1024 {
-            format!("{} B", file_size)
-        } else if file_size < 1024 * 1024 {
-            format!("{:.1} KB", file_size as f64 / 1024.0)
-        } else if file_size < 1024 * 1024 * 1024 {
-            format!("{:.1} MB", file_size as f64 / (1024.0 * 1024.0))
-        } else {
-            format!("{:.1} GB", file_size as f64 / (1024.0 * 1024.0 * 1024.0))
-        };
+            // Generate JSON entries for files.
+            for (name, metadata) in files {
+                let encoded = utf8_percent_encode(&name, NON_ALPHANUMERIC).to_string();
+                let file_size = metadata.len();
+                let formatted_size = if file_size < 1024 {
+                    format!("{} B", file_size)
+                } else if file_size < 1024 * 1024 {
+                    format!("{:.1} KB", file_size as f64 / 1024.0)
+                } else if file_size < 1024 * 1024 * 1024 {
+                    format!("{:.1} MB", file_size as f64 / (1024.0 * 1024.0))
+                } else {
+                    format!("{:.1} GB", file_size as f64 / (1024.0 * 1024.0 * 1024.0))
+                };
 
-        html.push_str(&format!("<td class=\"size\">{}</td>", formatted_size));
+                let modified_str = metadata
+                    .modified()
+                    .ok()
+                    .map(|m| {
+                        DateTime::<Utc>::from(m)
+                            .format("%Y-%m-%d %H:%M:%S")
+                            .to_string()
+                    })
+                    .unwrap_or_else(|| "-".to_string());
+
+                items.push(json!({
+                    "name": name,
+                    "path": encoded,
+                    "is_dir": false,
+                    "size": formatted_size,
+                    "modified": modified_str,
+                }));
+            }
 
-        if let Ok(modified) = metadata.modified() {
-            let formatted_time = DateTime::<Utc>::from(modified)
-                .format("%Y-%m-%d %H:%M:%S")
-                .to_string();
-            html.push_str(&format!("<td class=\"date\">{}</td>", formatted_time));
-        } else {
-            html.push_str("<td class=\"date\">-</td>");
+            // Build the final JSON object.
+            let json_obj = json!({
+                "title": format!("Directory listing for {}", directory_display),
+                "directory": directory_display,
+                "items": items,
+            });
+
+            // Serialize the JSON object to a pretty-printed string.
+            let json_string = serde_json::to_string_pretty(&json_obj)
+                .map_err(|e| std::io::Error::new(std::io::ErrorKind::Other, e))?;
+
+            Ok(json_string)
         }
+        ResponseFormat::HTML | ResponseFormat::TEXT | ResponseFormat::UNKNOWN => {
+            let template = include_str!("../default_responses/html/index.html");
+
+            let directory_display = {
+                let display = dir_path
+                    .strip_prefix(&config.root_dir)
+                    .unwrap_or(Path::new(""))
+                    .to_string_lossy();
+                if display.is_empty() {
+                    Cow::Borrowed(".")
+                } else {
+                    display
+                }
+            };
+
+            let mut rows = String::new();
+            if dir_path != config.root_dir {
+                rows.push_str(
+            r#"<tr><td><a href="..">..</a></td><td class="size">-</td><td class="date">-</td></tr>"#,
+        );
+                rows.push('\n');
+            }
 
-        html.push_str("</tr>\n");
-    }
+            // Read directory entries.
+            let mut entries = tokio::fs::read_dir(dir_path).await?;
+            let mut dirs = Vec::new();
+            let mut files = Vec::new();
+
+            while let Some(entry) = entries.next_entry().await? {
+                let entry_path = entry.path();
+                let metadata = entry.metadata().await?;
+                let name = entry_path
+                    .file_name()
+                    .unwrap()
+                    .to_string_lossy()
+                    .into_owned();
+
+                if !config.serve_hidden_files && name.starts_with('.') {
+                    continue;
+                }
+
+                let ext = entry_path
+                    .extension()
+                    .and_then(|s| s.to_str())
+                    .unwrap_or("");
+
+                if metadata.is_dir() {
+                    dirs.push((name, metadata));
+                } else if config.allowed_extensions.is_empty()
+                    || config.allowed_extensions.iter().any(|e| e == ext)
+                {
+                    files.push((name, metadata));
+                }
+            }
 
-    html.push_str("</table>\n");
-    html.push_str("<hr><p>Served by Itsi Static Assets</p>\n");
-    html.push_str("</body>\n</html>");
+            // Sort directories and files alphabetically.
+            dirs.sort_by(|(name_a, _), (name_b, _)| {
+                let a_is_dot = name_a.starts_with('.');
+                let b_is_dot = name_b.starts_with('.');
+                if a_is_dot != b_is_dot {
+                    if a_is_dot {
+                        Ordering::Greater
+                    } else {
+                        Ordering::Less
+                    }
+                } else {
+                    name_a.cmp(name_b)
+                }
+            });
 
-    Ok(html)
+            // Sort files so that dot files are at the bottom.
+            files.sort_by(|(name_a, _), (name_b, _)| {
+                let a_is_dot = name_a.starts_with('.');
+                let b_is_dot = name_b.starts_with('.');
+                if a_is_dot != b_is_dot {
+                    if a_is_dot {
+                        Ordering::Greater
+                    } else {
+                        Ordering::Less
+                    }
+                } else {
+                    name_a.cmp(name_b)
+                }
+            });
+
+            // Generate rows for directories.
+            for (name, metadata) in dirs {
+                let encoded = utf8_percent_encode(&name, NON_ALPHANUMERIC).to_string();
+
+                rows.push_str(&format!(
+            r#"<tr><td><a href="{0}/">{1}/</a></td><td class="size">-</td><td class="date">{2}</td></tr>"#,
+            encoded,
+            name,
+            metadata.modified().ok().map(|m| DateTime::<Utc>::from(m).format("%Y-%m-%d %H:%M:%S").to_string())
+                .unwrap_or_else(|| "-".to_string())
+        ));
+                rows.push('\n');
+            }
+
+            // Generate rows for files.
+            for (name, metadata) in files {
+                let encoded = utf8_percent_encode(&name, NON_ALPHANUMERIC).to_string();
+
+                let file_size = metadata.len();
+                let formatted_size = if file_size < 1024 {
+                    format!("{} B", file_size)
+                } else if file_size < 1024 * 1024 {
+                    format!("{:.1} KB", file_size as f64 / 1024.0)
+                } else if file_size < 1024 * 1024 * 1024 {
+                    format!("{:.1} MB", file_size as f64 / (1024.0 * 1024.0))
+                } else {
+                    format!("{:.1} GB", file_size as f64 / (1024.0 * 1024.0 * 1024.0))
+                };
+
+                let modified_str = metadata
+                    .modified()
+                    .ok()
+                    .map(|m| {
+                        DateTime::<Utc>::from(m)
+                            .format("%Y-%m-%d %H:%M:%S")
+                            .to_string()
+                    })
+                    .unwrap_or_else(|| "-".to_string());
+
+                rows.push_str(&format!(
+            r#"<tr><td><a href="{0}">{1}</a></td><td class="size">{2}</td><td class="date">{3}</td></tr>"#,
+            encoded, name, formatted_size, modified_str
+        ));
+                rows.push('\n');
+            }
+
+            // Replace the placeholders in our template.
+            let html = template
+                .replace(
+                    "{{title}}",
+                    &format!("Directory listing for {}", directory_display),
+                )
+                .replace("{{directory}}", &directory_display)
+                .replace("{{rows}}", &rows);
+
+            Ok(html)
+        }
+    }
 }