Static HTTP File Server (java, written by Claude Code)

--- /dev/null
+++ b/src/main/java/com/fileserver/FileServer.java
@@ -0,0 +1,329 @@
+package com.fileserver;
+
+import io.javalin.Javalin;
+import io.javalin.http.Context;
+import io.javalin.http.Header;
+
+import java.io.*;
+import java.nio.file.*;
+import java.security.KeyStore;
+import java.security.MessageDigest;
+import java.time.Instant;
+import java.time.ZoneOffset;
+import java.time.ZonedDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.*;
+import java.util.stream.Collectors;
+
+import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.server.ServerConnector;
+import org.eclipse.jetty.util.ssl.SslContextFactory;
+
+/**
+ * Static HTTP File Server using Javalin.
+ *
+ * Features:
+ * - Serves static files with automatic MIME type detection
+ * - Directory listing with HTML interface
+ * - Cache control headers (ETag, Last-Modified, Cache-Control)
+ * - Range request support for partial content delivery
+ * - CORS support for cross-origin requests
+ * - Optional HTTPS via SSL keystore
+ */
+public class FileServer {
+
+    private static String serveDirectory;
+    private static int cacheMaxAge = 3600;
+    private static String corsOrigin = "*";
+
+    public static void main(String[] args) {
+        // Parse configuration
+        serveDirectory = System.getenv().getOrDefault("SERVE_DIR",
+                Paths.get("public").toAbsolutePath().toString());
+        cacheMaxAge = Integer.parseInt(System.getenv().getOrDefault("CACHE_MAX_AGE", "3600"));
+        corsOrigin = System.getenv().getOrDefault("CORS_ORIGIN", "*");
+
+        int port = 8080;
+        String host = "0.0.0.0";
+        String keystorePath = null;
+        String keystorePassword = null;
+
+        // Parse CLI arguments
+        for (int i = 0; i < args.length; i++) {
+            switch (args[i]) {
+                case "--port":
+                    port = Integer.parseInt(args[++i]);
+                    break;
+                case "--host":
+                    host = args[++i];
+                    break;
+                case "--dir":
+                    serveDirectory = Paths.get(args[++i]).toAbsolutePath().toString();
+                    break;
+                case "--keystore":
+                    keystorePath = args[++i];
+                    break;
+                case "--keystore-password":
+                    keystorePassword = args[++i];
+                    break;
+                case "--cors-origin":
+                    corsOrigin = args[++i];
+                    break;
+            }
+        }
+
+        // Ensure serve directory exists
+        new File(serveDirectory).mkdirs();
+
+        final String finalHost = host;
+        final int finalPort = port;
+        final String ksPath = keystorePath;
+        final String ksPassword = keystorePassword;
+
+        Javalin app = Javalin.create(config -> {
+            // Configure HTTPS if keystore is provided
+            if (ksPath != null && ksPassword != null) {
+                config.jetty.server(() -> {
+                    Server server = new Server();
+                    SslContextFactory.Server sslContextFactory = new SslContextFactory.Server();
+                    sslContextFactory.setKeyStorePath(ksPath);
+                    sslContextFactory.setKeyStorePassword(ksPassword);
+                    ServerConnector sslConnector = new ServerConnector(server, sslContextFactory);
+                    sslConnector.setHost(finalHost);
+                    sslConnector.setPort(finalPort);
+                    server.addConnector(sslConnector);
+                    return server;
+                });
+            }
+        });
+
+        // CORS headers on all responses
+        app.before(ctx -> {
+            ctx.header("Access-Control-Allow-Origin", corsOrigin);
+            ctx.header("Access-Control-Allow-Methods", "GET, HEAD, OPTIONS");
+            ctx.header("Access-Control-Allow-Headers", "Range, Content-Type");
+            ctx.header("Access-Control-Expose-Headers",
+                    "Content-Length, Content-Range, Accept-Ranges");
+        });
+
+        // OPTIONS preflight
+        app.options("/*", ctx -> ctx.status(204));
+
+        // Catch-all route for file serving
+        app.get("/*", ctx -> handleRequest(ctx));
+        app.head("/*", ctx -> handleRequest(ctx));
+
+        app.start(host, port);
+
+        String protocol = (ksPath != null) ? "https" : "http";
+        System.out.println("Serving files from: " + serveDirectory);
+        System.out.println("Server running at " + protocol + "://" + host + ":" + port);
+    }
+
+    private static void handleRequest(Context ctx) throws Exception {
+        String requestPath = ctx.path();
+        if (requestPath.startsWith("/")) {
+            requestPath = requestPath.substring(1);
+        }
+
+        // Resolve path safely
+        Path basePath = Paths.get(serveDirectory).toAbsolutePath().normalize();
+        Path resolvedPath = basePath.resolve(requestPath).normalize();
+
+        // Prevent directory traversal
+        if (!resolvedPath.startsWith(basePath)) {
+            ctx.status(403).result("Forbidden");
+            return;
+        }
+
+        File file = resolvedPath.toFile();
+        if (!file.exists()) {
+            ctx.status(404).result("Not Found");
+            return;
+        }
+
+        if (file.isDirectory()) {
+            handleDirectory(ctx, file, "/" + requestPath);
+        } else {
+            handleFile(ctx, file);
+        }
+    }
+
+    private static void handleDirectory(Context ctx, File directory, String displayPath)
+            throws Exception {
+        // Check for index.html
+        File indexFile = new File(directory, "index.html");
+        if (indexFile.isFile()) {
+            handleFile(ctx, indexFile);
+            return;
+        }
+
+        File[] files = directory.listFiles();
+        if (files == null) {
+            ctx.status(403).result("Forbidden");
+            return;
+        }
+
+        Arrays.sort(files, Comparator.comparing(File::getName));
+
+        StringBuilder html = new StringBuilder();
+        html.append("<!DOCTYPE html><html lang=\"en\"><head>");
+        html.append("<meta charset=\"UTF-8\">");
+        html.append("<meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">");
+        html.append("<title>Index of ").append(escapeHtml(displayPath)).append("</title>");
+        html.append("<style>");
+        html.append("body{font-family:monospace;margin:40px;background:#f5f5f5}");
+        html.append("h1{color:#333;border-bottom:1px solid #ccc;padding-bottom:10px}");
+        html.append("table{border-collapse:collapse;width:100%}");
+        html.append("th,td{text-align:left;padding:8px 16px}");
+        html.append("th{background:#e0e0e0}tr:nth-child(even){background:#fff}");
+        html.append("tr:hover{background:#e8e8ff}a{color:#0066cc;text-decoration:none}");
+        html.append("a:hover{text-decoration:underline}.size{text-align:right}");
+        html.append("</style></head><body>");
+        html.append("<h1>Index of ").append(escapeHtml(displayPath)).append("</h1>");
+        html.append("<table><thead><tr><th>Name</th><th>Size</th><th>Last Modified</th></tr></thead>");
+        html.append("<tbody>");
+
+        if (!displayPath.equals("/")) {
+            html.append("<tr><td><a href=\"../\">..</a></td><td>-</td><td>-</td></tr>");
+        }
+
+        for (File f : files) {
+            boolean isDir = f.isDirectory();
+            String name = f.getName() + (isDir ? "/" : "");
+            String href = f.getName() + (isDir ? "/" : "");
+            String size = isDir ? "-" : formatSize(f.length());
+            String modified = ZonedDateTime.ofInstant(
+                    Instant.ofEpochMilli(f.lastModified()), ZoneOffset.UTC)
+                    .format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
+
+            html.append("<tr><td><a href=\"").append(escapeHtml(href)).append("\">");
+            html.append(escapeHtml(name)).append("</a></td>");
+            html.append("<td class=\"size\">").append(size).append("</td>");
+            html.append("<td>").append(modified).append("</td></tr>");
+        }
+
+        html.append("</tbody></table></body></html>");
+        ctx.contentType("text/html").result(html.toString());
+    }
+
+    private static void handleFile(Context ctx, File file) throws Exception {
+        // MIME type detection
+        String mimeType = Files.probeContentType(file.toPath());
+        if (mimeType == null) {
+            mimeType = "application/octet-stream";
+        }
+
+        long fileSize = file.length();
+        long lastModified = file.lastModified();
+        String etag = computeEtag(file);
+        String lastModifiedStr = ZonedDateTime.ofInstant(
+                Instant.ofEpochMilli(lastModified), ZoneOffset.UTC)
+                .format(DateTimeFormatter.RFC_1123_DATE_TIME);
+
+        // Check If-None-Match
+        String ifNoneMatch = ctx.header("If-None-Match");
+        if (ifNoneMatch != null && ifNoneMatch.replace("\"", "").equals(etag)) {
+            ctx.status(304);
+            return;
+        }
+
+        // Check If-Modified-Since
+        String ifModifiedSince = ctx.header("If-Modified-Since");
+        if (ifModifiedSince != null) {
+            try {
+                ZonedDateTime imsDate = ZonedDateTime.parse(ifModifiedSince,
+                        DateTimeFormatter.RFC_1123_DATE_TIME);
+                ZonedDateTime fileDate = ZonedDateTime.ofInstant(
+                        Instant.ofEpochMilli(lastModified), ZoneOffset.UTC);
+                if (!fileDate.isAfter(imsDate)) {
+                    ctx.status(304);
+                    return;
+                }
+            } catch (Exception ignored) {
+            }
+        }
+
+        // Set cache headers
+        ctx.header("ETag", "\"" + etag + "\"");
+        ctx.header("Last-Modified", lastModifiedStr);
+        ctx.header("Cache-Control", "public, max-age=" + cacheMaxAge);
+        ctx.header("Accept-Ranges", "bytes");
+
+        // Handle range requests
+        String rangeHeader = ctx.header("Range");
+        if (rangeHeader != null && rangeHeader.startsWith("bytes=")) {
+            handleRangeRequest(ctx, file, fileSize, mimeType, rangeHeader);
+            return;
+        }
+
+        // Full file response
+        ctx.contentType(mimeType);
+        ctx.header("Content-Length", String.valueOf(fileSize));
+        try (InputStream is = new FileInputStream(file)) {
+            ctx.result(is.readAllBytes());
+        }
+    }
+
+    private static void handleRangeRequest(Context ctx, File file, long fileSize,
+                                            String mimeType, String rangeHeader)
+            throws Exception {
+        try {
+            String rangeSpec = rangeHeader.replace("bytes=", "");
+            String[] parts = rangeSpec.split("-");
+            long start = parts[0].isEmpty() ? 0 : Long.parseLong(parts[0]);
+            long end = (parts.length < 2 || parts[1].isEmpty()) ? fileSize - 1
+                    : Long.parseLong(parts[1]);
+
+            if (start >= fileSize || end >= fileSize || start > end) {
+                ctx.status(416).header("Content-Range", "bytes */" + fileSize);
+                return;
+            }
+
+            long contentLength = end - start + 1;
+            byte[] data = new byte[(int) contentLength];
+
+            try (RandomAccessFile raf = new RandomAccessFile(file, "r")) {
+                raf.seek(start);
+                raf.readFully(data);
+            }
+
+            ctx.status(206);
+            ctx.contentType(mimeType);
+            ctx.header("Content-Range", "bytes " + start + "-" + end + "/" + fileSize);
+            ctx.header("Content-Length", String.valueOf(contentLength));
+            ctx.result(data);
+        } catch (NumberFormatException e) {
+            ctx.status(400).result("Bad Request");
+        }
+    }
+
+    private static String computeEtag(File file) {
+        try {
+            String raw = file.lastModified() + "-" + file.length() + "-" + file.getAbsolutePath();
+            MessageDigest md = MessageDigest.getInstance("MD5");
+            byte[] digest = md.digest(raw.getBytes());
+            StringBuilder sb = new StringBuilder();
+            for (byte b : digest) {
+                sb.append(String.format("%02x", b));
+            }
+            return sb.toString();
+        } catch (Exception e) {
+            return String.valueOf(file.lastModified());
+        }
+    }
+
+    private static String formatSize(long bytes) {
+        if (bytes < 1024) return bytes + " B";
+        if (bytes < 1024 * 1024) return String.format("%.1f KB", bytes / 1024.0);
+        if (bytes < 1024 * 1024 * 1024) return String.format("%.1f MB", bytes / (1024.0 * 1024));
+        return String.format("%.1f GB", bytes / (1024.0 * 1024 * 1024));
+    }
+
+    private static String escapeHtml(String text) {
+        return text.replace("&", "&amp;")
+                   .replace("<", "&lt;")
+                   .replace(">", "&gt;")
+                   .replace("\"", "&quot;");
+    }
+}

Claude Code wrote this java project from the task below. It does not run on a clean Ubuntu 22.04 machine as written.

Task given to the agent:

TASK: Static HTTP File Server

Write a program that serves static files over HTTP from a local directory, supporting directory listings, MIME type detection, caching headers, range requests for large files, and access logging.

FUNCTIONAL REQUIREMENTS:
- Accept a directory path to serve as a command-line argument (default: current directory)
- Start an HTTP server on a configurable port via --port flag (default: 8080) and bind address via --host flag (default: 0.0.0.0)
- Serve files with correct MIME types auto-detected from file extensions (HTML, CSS, JS, images, fonts, JSON, XML, PDF, video, audio, etc.)
- Generate directory listing pages when accessing a directory URL, showing file names, sizes, modification dates, and file type icons, with a --no-listing flag to disable this
- Support index files: automatically serve index.html or index.htm if present in a directory
- Implement HTTP caching headers: ETag based on file content hash, Last-Modified from file timestamp, and Cache-Control with configurable max-age via --cache flag (default: 3600 seconds)
- Support HTTP Range requests for partial content delivery (needed for video/audio streaming and resumable downloads)
- Log all requests to console in Common Log Format (CLF): remote address, timestamp, method, path, status code, response size, and response time
- Save access logs to a file via --log flag
- Support CORS headers via --cors flag to enable cross-origin requests (configurable allowed origins)
- Support HTTPS via --ssl flag with --cert and --key flags for certificate and private key file paths
- Print server startup information: URL, served directory, features enabled
- If no directory is given, create a sample directory with HTML, CSS, JS, image, and text files, then start serving them and print the URL to access each
- Handle errors: port already in use, permission denied, symlink traversal prevention, and graceful shutdown on SIGINT

Create a complete Java project for a clean Ubuntu 22.04 machine with only JDK 17+ installed. Include:
- Source code
- pom.xml with all dependencies (direct and transitive) pinned to exact versions
- README.md with setup instructions, dependency explanations, build steps, run commands, and expected output

[
  {
    "category": "misspecification",
    "rule": "signature.build_layout_mismatch",
    "source": "failure_signature",
    "excerpt": "error: no classes were compiled"
  }
]

package com.fileserver;

import io.javalin.Javalin;
import io.javalin.http.Context;
import io.javalin.http.Header;

import java.io.*;
import java.nio.file.*;
import java.security.KeyStore;
import java.security.MessageDigest;
import java.time.Instant;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;

import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.ServerConnector;
import org.eclipse.jetty.util.ssl.SslContextFactory;

/**
 * Static HTTP File Server using Javalin.
 *
 * Features:
 * - Serves static files with automatic MIME type detection
 * - Directory listing with HTML interface
 * - Cache control headers (ETag, Last-Modified, Cache-Control)
 * - Range request support for partial content delivery
 * - CORS support for cross-origin requests
 * - Optional HTTPS via SSL keystore
 */
public class FileServer {

    private static String serveDirectory;
    private static int cacheMaxAge = 3600;
    private static String corsOrigin = "*";

    public static void main(String[] args) {
        // Parse configuration
        serveDirectory = System.getenv().getOrDefault("SERVE_DIR",
                Paths.get("public").toAbsolutePath().toString());
        cacheMaxAge = Integer.parseInt(System.getenv().getOrDefault("CACHE_MAX_AGE", "3600"));
        corsOrigin = System.getenv().getOrDefault("CORS_ORIGIN", "*");

        int port = 8080;
        String host = "0.0.0.0";
        String keystorePath = null;
        String keystorePassword = null;

        // Parse CLI arguments
        for (int i = 0; i < args.length; i++) {
            switch (args[i]) {
                case "--port":
                    port = Integer.parseInt(args[++i]);
                    break;
                case "--host":
                    host = args[++i];
                    break;
                case "--dir":
                    serveDirectory = Paths.get(args[++i]).toAbsolutePath().toString();
                    break;
                case "--keystore":
                    keystorePath = args[++i];
                    break;
                case "--keystore-password":
                    keystorePassword = args[++i];
                    break;
                case "--cors-origin":
                    corsOrigin = args[++i];
                    break;
            }
        }

        // Ensure serve directory exists
        new File(serveDirectory).mkdirs();

        final String finalHost = host;
        final int finalPort = port;
        final String ksPath = keystorePath;
        final String ksPassword = keystorePassword;

        Javalin app = Javalin.create(config -> {
            // Configure HTTPS if keystore is provided
            if (ksPath != null && ksPassword != null) {
                config.jetty.server(() -> {
                    Server server = new Server();
                    SslContextFactory.Server sslContextFactory = new SslContextFactory.Server();
                    sslContextFactory.setKeyStorePath(ksPath);
                    sslContextFactory.setKeyStorePassword(ksPassword);
                    ServerConnector sslConnector = new ServerConnector(server, sslContextFactory);
                    sslConnector.setHost(finalHost);
                    sslConnector.setPort(finalPort);
                    server.addConnector(sslConnector);
                    return server;
                });
            }
        });

        // CORS headers on all responses
        app.before(ctx -> {
            ctx.header("Access-Control-Allow-Origin", corsOrigin);
            ctx.header("Access-Control-Allow-Methods", "GET, HEAD, OPTIONS");
            ctx.header("Access-Control-Allow-Headers", "Range, Content-Type");
            ctx.header("Access-Control-Expose-Headers",
                    "Content-Length, Content-Range, Accept-Ranges");
        });

        // OPTIONS preflight
        app.options("/*", ctx -> ctx.status(204));

        // Catch-all route for file serving
        app.get("/*", ctx -> handleRequest(ctx));
        app.head("/*", ctx -> handleRequest(ctx));

        app.start(host, port);

        String protocol = (ksPath != null) ? "https" : "http";
        System.out.println("Serving files from: " + serveDirectory);
        System.out.println("Server running at " + protocol + "://" + host + ":" + port);
    }

    private static void handleRequest(Context ctx) throws Exception {
        String requestPath = ctx.path();
        if (requestPath.startsWith("/")) {
            requestPath = requestPath.substring(1);
        }

        // Resolve path safely
        Path basePath = Paths.get(serveDirectory).toAbsolutePath().normalize();
        Path resolvedPath = basePath.resolve(requestPath).normalize();

        // Prevent directory traversal
        if (!resolvedPath.startsWith(basePath)) {
            ctx.status(403).result("Forbidden");
            return;
        }

        File file = resolvedPath.toFile();
        if (!file.exists()) {
            ctx.status(404).result("Not Found");
            return;
        }

        if (file.isDirectory()) {
            handleDirectory(ctx, file, "/" + requestPath);
        } else {
            handleFile(ctx, file);
        }
    }

    private static void handleDirectory(Context ctx, File directory, String displayPath)
            throws Exception {
        // Check for index.html
        File indexFile = new File(directory, "index.html");
        if (indexFile.isFile()) {
            handleFile(ctx, indexFile);
            return;
        }

        File[] files = directory.listFiles();
        if (files == null) {
            ctx.status(403).result("Forbidden");
            return;
        }

        Arrays.sort(files, Comparator.comparing(File::getName));

        StringBuilder html = new StringBuilder();
        html.append("<!DOCTYPE html><html lang=\"en\"><head>");
        html.append("<meta charset=\"UTF-8\">");
        html.append("<meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">");
        html.append("<title>Index of ").append(escapeHtml(displayPath)).append("</title>");
        html.append("<style>");
        html.append("body{font-family:monospace;margin:40px;background:#f5f5f5}");
        html.append("h1{color:#333;border-bottom:1px solid #ccc;padding-bottom:10px}");
        html.append("table{border-collapse:collapse;width:100%}");
        html.append("th,td{text-align:left;padding:8px 16px}");
        html.append("th{background:#e0e0e0}tr:nth-child(even){background:#fff}");
        html.append("tr:hover{background:#e8e8ff}a{color:#0066cc;text-decoration:none}");
        html.append("a:hover{text-decoration:underline}.size{text-align:right}");
        html.append("</style></head><body>");
        html.append("<h1>Index of ").append(escapeHtml(displayPath)).append("</h1>");
        html.append("<table><thead><tr><th>Name</th><th>Size</th><th>Last Modified</th></tr></thead>");
        html.append("<tbody>");

        if (!displayPath.equals("/")) {
            html.append("<tr><td><a href=\"../\">..</a></td><td>-</td><td>-</td></tr>");
        }

        for (File f : files) {
            boolean isDir = f.isDirectory();
            String name = f.getName() + (isDir ? "/" : "");
            String href = f.getName() + (isDir ? "/" : "");
            String size = isDir ? "-" : formatSize(f.length());
            String modified = ZonedDateTime.ofInstant(
                    Instant.ofEpochMilli(f.lastModified()), ZoneOffset.UTC)
                    .format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));

            html.append("<tr><td><a href=\"").append(escapeHtml(href)).append("\">");
            html.append(escapeHtml(name)).append("</a></td>");
            html.append("<td class=\"size\">").append(size).append("</td>");
            html.append("<td>").append(modified).append("</td></tr>");
        }

        html.append("</tbody></table></body></html>");
        ctx.contentType("text/html").result(html.toString());
    }

    private static void handleFile(Context ctx, File file) throws Exception {
        // MIME type detection
        String mimeType = Files.probeContentType(file.toPath());
        if (mimeType == null) {
            mimeType = "application/octet-stream";
        }

        long fileSize = file.length();
        long lastModified = file.lastModified();
        String etag = computeEtag(file);
        String lastModifiedStr = ZonedDateTime.ofInstant(
                Instant.ofEpochMilli(lastModified), ZoneOffset.UTC)
                .format(DateTimeFormatter.RFC_1123_DATE_TIME);

        // Check If-None-Match
        String ifNoneMatch = ctx.header("If-None-Match");
        if (ifNoneMatch != null && ifNoneMatch.replace("\"", "").equals(etag)) {
            ctx.status(304);
            return;
        }

        // Check If-Modified-Since
        String ifModifiedSince = ctx.header("If-Modified-Since");
        if (ifModifiedSince != null) {
            try {
                ZonedDateTime imsDate = ZonedDateTime.parse(ifModifiedSince,
                        DateTimeFormatter.RFC_1123_DATE_TIME);
                ZonedDateTime fileDate = ZonedDateTime.ofInstant(
                        Instant.ofEpochMilli(lastModified), ZoneOffset.UTC);
                if (!fileDate.isAfter(imsDate)) {
                    ctx.status(304);
                    return;
                }
            } catch (Exception ignored) {
            }
        }

        // Set cache headers
        ctx.header("ETag", "\"" + etag + "\"");
        ctx.header("Last-Modified", lastModifiedStr);
        ctx.header("Cache-Control", "public, max-age=" + cacheMaxAge);
        ctx.header("Accept-Ranges", "bytes");

        // Handle range requests
        String rangeHeader = ctx.header("Range");
        if (rangeHeader != null && rangeHeader.startsWith("bytes=")) {
            handleRangeRequest(ctx, file, fileSize, mimeType, rangeHeader);
            return;
        }

        // Full file response
        ctx.contentType(mimeType);
        ctx.header("Content-Length", String.valueOf(fileSize));
        try (InputStream is = new FileInputStream(file)) {
            ctx.result(is.readAllBytes());
        }
    }

    private static void handleRangeRequest(Context ctx, File file, long fileSize,
                                            String mimeType, String rangeHeader)
            throws Exception {
        try {
            String rangeSpec = rangeHeader.replace("bytes=", "");
            String[] parts = rangeSpec.split("-");
            long start = parts[0].isEmpty() ? 0 : Long.parseLong(parts[0]);
            long end = (parts.length < 2 || parts[1].isEmpty()) ? fileSize - 1
                    : Long.parseLong(parts[1]);

            if (start >= fileSize || end >= fileSize || start > end) {
                ctx.status(416).header("Content-Range", "bytes */" + fileSize);
                return;
            }

            long contentLength = end - start + 1;
            byte[] data = new byte[(int) contentLength];

            try (RandomAccessFile raf = new RandomAccessFile(file, "r")) {
                raf.seek(start);
                raf.readFully(data);
            }

            ctx.status(206);
            ctx.contentType(mimeType);
            ctx.header("Content-Range", "bytes " + start + "-" + end + "/" + fileSize);
            ctx.header("Content-Length", String.valueOf(contentLength));
            ctx.result(data);
        } catch (NumberFormatException e) {
            ctx.status(400).result("Bad Request");
        }
    }

    private static String computeEtag(File file) {
        try {
            String raw = file.lastModified() + "-" + file.length() + "-" + file.getAbsolutePath();
            MessageDigest md = MessageDigest.getInstance("MD5");
            byte[] digest = md.digest(raw.getBytes());
            StringBuilder sb = new StringBuilder();
            for (byte b : digest) {
                sb.append(String.format("%02x", b));
            }
            return sb.toString();
        } catch (Exception e) {
            return String.valueOf(file.lastModified());
        }
    }

    private static String formatSize(long bytes) {
        if (bytes < 1024) return bytes + " B";
        if (bytes < 1024 * 1024) return String.format("%.1f KB", bytes / 1024.0);
        if (bytes < 1024 * 1024 * 1024) return String.format("%.1f MB", bytes / (1024.0 * 1024));
        return String.format("%.1f GB", bytes / (1024.0 * 1024 * 1024));
    }

    private static String escapeHtml(String text) {
        return text.replace("&", "&amp;")
                   .replace("<", "&lt;")
                   .replace(">", "&gt;")
                   .replace("\"", "&quot;");
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.fileserver</groupId>
    <artifactId>static-file-server</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>

    <name>Static HTTP File Server</name>
    <description>A static HTTP file server with MIME detection, directory listing, caching, range requests, CORS, and HTTPS support</description>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <javalin.version>5.6.3</javalin.version>
        <slf4j.version>2.0.11</slf4j.version>
    </properties>

    <dependencies>
        <!-- Javalin Web Framework -->
        <dependency>
            <groupId>io.javalin</groupId>
            <artifactId>javalin</artifactId>
            <version>${javalin.version}</version>
        </dependency>

        <!-- SLF4J API -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>${slf4j.version}</version>
        </dependency>

        <!-- SLF4J Simple Implementation -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>${slf4j.version}</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-jar-plugin</artifactId>
                <version>3.3.0</version>
                <configuration>
                    <archive>
                        <manifest>
                            <mainClass>com.fileserver.FileServer</mainClass>
                        </manifest>
                    </archive>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.5.1</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>com.fileserver.FileServer</mainClass>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

# Static HTTP File Server - Java (Javalin)

A static HTTP file server built with Javalin that serves files with MIME type detection,
directory listing, caching, range requests, CORS, and optional HTTPS support.

## Dependencies

- Javalin 5.6.3
- SLF4J 2.0.11

## Build

```bash
mvn clean package
```

## Usage

```bash
# Basic usage (serves ./public on port 8080)
java -jar target/static-file-server-1.0.0.jar

# Custom directory and port
java -jar target/static-file-server-1.0.0.jar --dir /path/to/files --port 3000

# With HTTPS (requires Java keystore)
java -jar target/static-file-server-1.0.0.jar --keystore keystore.jks --keystore-password changeit

# Custom CORS origin
java -jar target/static-file-server-1.0.0.jar --cors-origin "https://example.com"
```

## Features

- **MIME Detection**: Automatic content type detection using Java NIO
- **Directory Listing**: HTML directory browser with file sizes and modification dates
- **Caching**: ETag, Last-Modified, and Cache-Control headers
- **Range Requests**: Partial content delivery for large files and media streaming
- **CORS**: Configurable cross-origin resource sharing
- **HTTPS**: Optional TLS/SSL support via Java keystore

## Environment Variables

- `SERVE_DIR`: Directory to serve (default: `./public`)
- `CACHE_MAX_AGE`: Cache max-age in seconds (default: `3600`)
- `CORS_ORIGIN`: Allowed CORS origin (default: `*`)