kempo-server 1.7.12 → 1.8.0

package/dist/defaultConfig.js

@@ -1 +1 @@
-export default{allowedMimes:{html:"text/html",htm:"text/html",shtml:"text/html",css:"text/css",xml:"text/xml",gif:"image/gif",jpeg:"image/jpeg",jpg:"image/jpeg",js:"application/javascript",mjs:"application/javascript",json:"application/json",webp:"image/webp",png:"image/png",svg:"image/svg+xml",svgz:"image/svg+xml",ico:"image/x-icon",webm:"video/webm",mp4:"video/mp4",m4v:"video/mp4",ogv:"video/ogg",mp3:"audio/mpeg",ogg:"audio/ogg",wav:"audio/wav",woff:"font/woff",woff2:"font/woff2",ttf:"font/ttf",otf:"font/otf",eot:"application/vnd.ms-fontobject",pdf:"application/pdf",txt:"text/plain",webmanifest:"application/manifest+json",md:"text/markdown",csv:"text/csv",doc:"application/msword",docx:"application/vnd.openxmlformats-officedocument.wordprocessingml.document",xls:"application/vnd.ms-excel",xlsx:"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",ppt:"application/vnd.ms-powerpoint",pptx:"application/vnd.openxmlformats-officedocument.presentationml.presentation",avif:"image/avif",wasm:"application/wasm"},disallowedRegex:["^/\\..*","\\.config$","\\.env$","\\.git/","\\.htaccess$","\\.htpasswd$","^/node_modules/","^/vendor/","\\.log$","\\.bak$","\\.sql$","\\.ini$","password","config\\.php$","wp-config\\.php$","\\.DS_Store$"],routeFiles:["GET.js","POST.js","PUT.js","DELETE.js","HEAD.js","OPTIONS.js","PATCH.js","CONNECT.js","TRACE.js","index.js"],noRescanPaths:["^\\.well-known/","/favicon\\.ico$","/robots\\.txt$","/sitemap\\.xml$","/apple-touch-icon","/android-chrome-","/browserconfig\\.xml$","/manifest\\.json$","\\.map$","/__webpack_hmr$","/hot-update\\.","/sockjs-node/"],maxRescanAttempts:3,customRoutes:{},middleware:{cors:{enabled:!1,origin:"*",methods:["GET","POST","PUT","DELETE","OPTIONS"],headers:["Content-Type","Authorization"]},compression:{enabled:!1,threshold:1024},rateLimit:{enabled:!1,maxRequests:100,windowMs:6e4,message:"Too many requests"},security:{enabled:!0,headers:{"X-Content-Type-Options":"nosniff","X-Frame-Options":"DENY","X-XSS-Protection":"1; mode=block"}},logging:{enabled:!0,includeUserAgent:!1,includeResponseTime:!0},custom:[]},cache:{enabled:!1,maxSize:100,maxMemoryMB:50,ttlMs:3e5,maxHeapUsagePercent:70,memoryCheckInterval:3e4,watchFiles:!0,enableMemoryMonitoring:!0}};
+export default{allowedMimes:{html:{mime:"text/html",encoding:"utf8"},htm:{mime:"text/html",encoding:"utf8"},shtml:{mime:"text/html",encoding:"utf8"},css:{mime:"text/css",encoding:"utf8"},xml:{mime:"text/xml",encoding:"utf8"},gif:{mime:"image/gif",encoding:"binary"},jpeg:{mime:"image/jpeg",encoding:"binary"},jpg:{mime:"image/jpeg",encoding:"binary"},js:{mime:"application/javascript",encoding:"utf8"},mjs:{mime:"application/javascript",encoding:"utf8"},json:{mime:"application/json",encoding:"utf8"},webp:{mime:"image/webp",encoding:"binary"},png:{mime:"image/png",encoding:"binary"},svg:{mime:"image/svg+xml",encoding:"utf8"},svgz:{mime:"image/svg+xml",encoding:"utf8"},ico:{mime:"image/x-icon",encoding:"binary"},webm:{mime:"video/webm",encoding:"binary"},mp4:{mime:"video/mp4",encoding:"binary"},m4v:{mime:"video/mp4",encoding:"binary"},ogv:{mime:"video/ogg",encoding:"binary"},mp3:{mime:"audio/mpeg",encoding:"binary"},ogg:{mime:"audio/ogg",encoding:"binary"},wav:{mime:"audio/wav",encoding:"binary"},woff:{mime:"font/woff",encoding:"binary"},woff2:{mime:"font/woff2",encoding:"binary"},ttf:{mime:"font/ttf",encoding:"binary"},otf:{mime:"font/otf",encoding:"binary"},eot:{mime:"application/vnd.ms-fontobject",encoding:"binary"},pdf:{mime:"application/pdf",encoding:"binary"},txt:{mime:"text/plain",encoding:"utf8"},webmanifest:{mime:"application/manifest+json",encoding:"utf8"},md:{mime:"text/markdown",encoding:"utf8"},csv:{mime:"text/csv",encoding:"utf8"},doc:{mime:"application/msword",encoding:"binary"},docx:{mime:"application/vnd.openxmlformats-officedocument.wordprocessingml.document",encoding:"binary"},xls:{mime:"application/vnd.ms-excel",encoding:"binary"},xlsx:{mime:"application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",encoding:"binary"},ppt:{mime:"application/vnd.ms-powerpoint",encoding:"binary"},pptx:{mime:"application/vnd.openxmlformats-officedocument.presentationml.presentation",encoding:"binary"},avif:{mime:"image/avif",encoding:"binary"},wasm:{mime:"application/wasm",encoding:"binary"}},disallowedRegex:["^/\\..*","\\.config$","\\.env$","\\.git/","\\.htaccess$","\\.htpasswd$","^/node_modules/","^/vendor/","\\.log$","\\.bak$","\\.sql$","\\.ini$","password","config\\.php$","wp-config\\.php$","\\.DS_Store$"],routeFiles:["GET.js","POST.js","PUT.js","DELETE.js","HEAD.js","OPTIONS.js","PATCH.js","CONNECT.js","TRACE.js","index.js"],noRescanPaths:["^\\.well-known/","/favicon\\.ico$","/robots\\.txt$","/sitemap\\.xml$","/apple-touch-icon","/android-chrome-","/browserconfig\\.xml$","/manifest\\.json$","\\.map$","/__webpack_hmr$","/hot-update\\.","/sockjs-node/"],maxRescanAttempts:3,customRoutes:{},middleware:{cors:{enabled:!1,origin:"*",methods:["GET","POST","PUT","DELETE","OPTIONS"],headers:["Content-Type","Authorization"]},compression:{enabled:!1,threshold:1024},rateLimit:{enabled:!1,maxRequests:100,windowMs:6e4,message:"Too many requests"},security:{enabled:!0,headers:{"X-Content-Type-Options":"nosniff","X-Frame-Options":"DENY","X-XSS-Protection":"1; mode=block"}},logging:{enabled:!0,includeUserAgent:!1,includeResponseTime:!0},custom:[]},cache:{enabled:!1,maxSize:100,maxMemoryMB:50,ttlMs:3e5,maxHeapUsagePercent:70,memoryCheckInterval:3e4,watchFiles:!0,enableMemoryMonitoring:!0}};

package/dist/router.js

@@ -1 +1 @@
-import path from"path";import{readFile}from"fs/promises";import{pathToFileURL}from"url";import defaultConfig from"./defaultConfig.js";import getFiles from"./getFiles.js";import findFile from"./findFile.js";import serveFile from"./serveFile.js";import MiddlewareRunner from"./middlewareRunner.js";import ModuleCache from"./moduleCache.js";import{corsMiddleware,compressionMiddleware,rateLimitMiddleware,securityMiddleware,loggingMiddleware}from"./builtinMiddleware.js";export default async(flags,log)=>{log("Initializing router",3);const rootPath=path.isAbsolute(flags.root)?flags.root:path.join(process.cwd(),flags.root);log(`Root path: ${rootPath}`,3);let config=defaultConfig;try{const configFileName=flags.config||".config.json",configPath=path.isAbsolute(configFileName)?configFileName:path.join(rootPath,configFileName);if(log(`Config file name: ${configFileName}`,3),log(`Config path: ${configPath}`,3),path.isAbsolute(configFileName))log("Config file name is absolute, skipping validation",4);else{const relativeConfigPath=path.relative(rootPath,configPath);if(log(`Relative config path: ${relativeConfigPath}`,4),log(`Starts with '..': ${relativeConfigPath.startsWith("..")}`,4),relativeConfigPath.startsWith("..")||path.isAbsolute(relativeConfigPath))throw log("Validation failed - throwing error",4),new Error(`Config file must be within the server root directory. Config path: ${configPath}, Root path: ${rootPath}`);log("Validation passed",4)}log(`Loading config from: ${configPath}`,3);const configContent=await readFile(configPath,"utf8"),userConfig=JSON.parse(configContent);config={...defaultConfig,...userConfig,allowedMimes:{...defaultConfig.allowedMimes,...userConfig.allowedMimes},middleware:{...defaultConfig.middleware,...userConfig.middleware},customRoutes:{...defaultConfig.customRoutes,...userConfig.customRoutes},cache:{...defaultConfig.cache,...userConfig.cache}},log("User config loaded and merged with defaults",3)}catch(e){if(e.message.includes("Config file must be within the server root directory"))throw e;log("Using default config (no config file found)",3)}const dis=new Set(config.disallowedRegex);dis.add("^/\\..*"),dis.add("\\.config$"),dis.add("\\.git/"),config.disallowedRegex=[...dis],log(`Config loaded with ${config.disallowedRegex.length} disallowed patterns`,3);let files=await getFiles(rootPath,config,log);log(`Initial scan found ${files.length} files`,2);const middlewareRunner=new MiddlewareRunner;if(config.middleware?.cors?.enabled&&(middlewareRunner.use(corsMiddleware(config.middleware.cors)),log("CORS middleware enabled",3)),config.middleware?.compression?.enabled&&(middlewareRunner.use(compressionMiddleware(config.middleware.compression)),log("Compression middleware enabled",3)),config.middleware?.rateLimit?.enabled&&(middlewareRunner.use(rateLimitMiddleware(config.middleware.rateLimit)),log("Rate limit middleware enabled",3)),config.middleware?.security?.enabled&&(middlewareRunner.use(securityMiddleware(config.middleware.security)),log("Security middleware enabled",3)),config.middleware?.logging?.enabled&&(middlewareRunner.use(loggingMiddleware(config.middleware.logging,log)),log("Logging middleware enabled",3)),config.middleware?.custom&&config.middleware.custom.length>0){log(`Loading ${config.middleware.custom.length} custom middleware files`,3);for(const middlewarePath of config.middleware.custom)try{const resolvedPath=path.resolve(middlewarePath),customMiddleware=(await import(pathToFileURL(resolvedPath))).default;"function"==typeof customMiddleware?(middlewareRunner.use(customMiddleware(config.middleware)),log(`Custom middleware loaded: ${middlewarePath}`,3)):log(`Custom middleware error: ${middlewarePath} does not export a default function`,1)}catch(error){log(`Custom middleware error for ${middlewarePath}: ${error.message}`,1)}}let moduleCache=null;config.cache?.enabled&&(moduleCache=new ModuleCache(config.cache),log(`Module cache initialized: ${config.cache.maxSize} max modules, ${config.cache.maxMemoryMB}MB limit, ${config.cache.ttlMs}ms TTL`,2));const customRoutes=new Map,wildcardRoutes=new Map;if(config.customRoutes&&Object.keys(config.customRoutes).length>0){log(`Processing ${Object.keys(config.customRoutes).length} custom routes`,3);for(const[urlPath,filePath]of Object.entries(config.customRoutes))if(urlPath.includes("*")){const resolvedPath=path.isAbsolute(filePath)?filePath:path.resolve(rootPath,filePath);wildcardRoutes.set(urlPath,resolvedPath),log(`Wildcard route mapped: ${urlPath} -> ${resolvedPath}`,3)}else{const resolvedPath=path.isAbsolute(filePath)?filePath:path.resolve(rootPath,filePath);customRoutes.set(urlPath,resolvedPath),log(`Custom route mapped: ${urlPath} -> ${resolvedPath}`,3)}}const matchWildcardRoute=(requestPath,pattern)=>{const regexPattern=pattern.replace(/\*\*/g,"(.+)").replace(/\*/g,"([^/]+)");return new RegExp(`^${regexPattern}$`).exec(requestPath)},rescanAttempts=new Map,dynamicNoRescanPaths=new Set,shouldSkipRescan=requestPath=>config.noRescanPaths.some(pattern=>new RegExp(pattern).test(requestPath))?(log(`Skipping rescan for configured pattern: ${requestPath}`,3),!0):!!dynamicNoRescanPaths.has(requestPath)&&(log(`Skipping rescan for dynamically blacklisted path: ${requestPath}`,3),!0),handler=async(req,res)=>{await middlewareRunner.run(req,res,async()=>{const requestPath=req.url.split("?")[0];log(`${req.method} ${requestPath}`,4),log(`customRoutes keys: ${Array.from(customRoutes.keys()).join(", ")}`,4);const normalizePath=p=>{try{let np=decodeURIComponent(p);return np.startsWith("/")||(np="/"+np),np.length>1&&np.endsWith("/")&&(np=np.slice(0,-1)),np}catch(e){log(`Warning: Failed to decode URI component "${p}": ${e.message}`,1);let np=p;return np.startsWith("/")||(np="/"+np),np.length>1&&np.endsWith("/")&&(np=np.slice(0,-1)),np}},normalizedRequestPath=normalizePath(requestPath);log(`Normalized requestPath: ${normalizedRequestPath}`,4);let matchedKey=null;for(const key of customRoutes.keys())if(normalizePath(key)===normalizedRequestPath){matchedKey=key;break}if(matchedKey){const customFilePath=customRoutes.get(matchedKey);log(`Serving custom route: ${normalizedRequestPath} -> ${customFilePath}`,3);try{const{stat:stat}=await import("fs/promises");try{await stat(customFilePath),log(`Custom route file exists: ${customFilePath}`,4)}catch(e){return log(`Custom route file does NOT exist: ${customFilePath}`,1),res.writeHead(404,{"Content-Type":"text/plain"}),void res.end("Custom route file not found")}const fileContent=await readFile(customFilePath),fileExtension=path.extname(customFilePath).toLowerCase().slice(1),mimeType=config.allowedMimes[fileExtension]||"application/octet-stream";return log(`Serving custom file as ${mimeType} (${fileContent.length} bytes)`,2),res.writeHead(200,{"Content-Type":mimeType}),void res.end(fileContent)}catch(error){return log(`Error serving custom route ${normalizedRequestPath}: ${error.message}`,1),res.writeHead(500,{"Content-Type":"text/plain"}),void res.end("Internal Server Error")}}const wildcardMatch=(requestPath=>{for(const[pattern,filePath]of wildcardRoutes){const matches=matchWildcardRoute(requestPath,pattern);if(matches)return{filePath:filePath,matches:matches}}return null})(requestPath);if(wildcardMatch){const resolvedFilePath=((filePath,matches)=>{let resolvedPath=filePath,matchIndex=1;for(;resolvedPath.includes("**")&&matchIndex<matches.length;)resolvedPath=resolvedPath.replace("**",matches[matchIndex]),matchIndex++;for(;resolvedPath.includes("*")&&matchIndex<matches.length;)resolvedPath=resolvedPath.replace("*",matches[matchIndex]),matchIndex++;return path.isAbsolute(resolvedPath)?resolvedPath:path.resolve(rootPath,resolvedPath)})(wildcardMatch.filePath,wildcardMatch.matches);log(`Serving wildcard route: ${requestPath} -> ${resolvedFilePath}`,3);try{const fileContent=await readFile(resolvedFilePath),fileExtension=path.extname(resolvedFilePath).toLowerCase().slice(1),mimeType=config.allowedMimes[fileExtension]||"application/octet-stream";return log(`Serving wildcard file as ${mimeType} (${fileContent.length} bytes)`,4),res.writeHead(200,{"Content-Type":mimeType}),void res.end(fileContent)}catch(error){return log(`Error serving wildcard route ${requestPath}: ${error.message}`,1),res.writeHead(500,{"Content-Type":"text/plain"}),void res.end("Internal Server Error")}}const served=await serveFile(files,rootPath,requestPath,req.method,config,req,res,log,moduleCache);if(served||!flags.scan||shouldSkipRescan(requestPath))served||(shouldSkipRescan(requestPath)?log(`404 - Skipped rescan for: ${requestPath}`,2):log(`404 - File not found: ${requestPath}`,1),res.writeHead(404,{"Content-Type":"text/plain"}),res.end("Not Found"));else{(requestPath=>{const newAttempts=(rescanAttempts.get(requestPath)||0)+1;rescanAttempts.set(requestPath,newAttempts),newAttempts>=config.maxRescanAttempts&&(dynamicNoRescanPaths.add(requestPath),log(`Path ${requestPath} added to dynamic blacklist after ${newAttempts} failed attempts`,1)),log(`Rescan attempt ${newAttempts}/${config.maxRescanAttempts} for: ${requestPath}`,3)})(requestPath),log("File not found, rescanning directory...",1),files=await getFiles(rootPath,config,log),log(`Rescan found ${files.length} files`,2);await serveFile(files,rootPath,requestPath,req.method,config,req,res,log,moduleCache)||(log(`404 - File not found after rescan: ${requestPath}`,1),res.writeHead(404,{"Content-Type":"text/plain"}),res.end("Not Found"))}})};return handler.moduleCache=moduleCache,handler.getStats=()=>moduleCache?.getStats()||null,handler.logCacheStats=()=>moduleCache?.logStats(log),handler.clearCache=()=>moduleCache?.clear(),handler};
+import path from"path";import{readFile}from"fs/promises";import{pathToFileURL}from"url";import defaultConfig from"./defaultConfig.js";import getFiles from"./getFiles.js";import findFile from"./findFile.js";import serveFile from"./serveFile.js";import MiddlewareRunner from"./middlewareRunner.js";import ModuleCache from"./moduleCache.js";import{corsMiddleware,compressionMiddleware,rateLimitMiddleware,securityMiddleware,loggingMiddleware}from"./builtinMiddleware.js";export default async(flags,log)=>{log("Initializing router",3);const rootPath=path.isAbsolute(flags.root)?flags.root:path.join(process.cwd(),flags.root);log(`Root path: ${rootPath}`,3);let config=defaultConfig;try{const configFileName=flags.config||".config.json",configPath=path.isAbsolute(configFileName)?configFileName:path.join(rootPath,configFileName);if(log(`Config file name: ${configFileName}`,3),log(`Config path: ${configPath}`,3),path.isAbsolute(configFileName))log("Config file name is absolute, skipping validation",4);else{const relativeConfigPath=path.relative(rootPath,configPath);if(log(`Relative config path: ${relativeConfigPath}`,4),log(`Starts with '..': ${relativeConfigPath.startsWith("..")}`,4),relativeConfigPath.startsWith("..")||path.isAbsolute(relativeConfigPath))throw log("Validation failed - throwing error",4),new Error(`Config file must be within the server root directory. Config path: ${configPath}, Root path: ${rootPath}`);log("Validation passed",4)}log(`Loading config from: ${configPath}`,3);const configContent=await readFile(configPath,"utf8"),userConfig=JSON.parse(configContent);config={...defaultConfig,...userConfig,allowedMimes:{...defaultConfig.allowedMimes,...userConfig.allowedMimes},middleware:{...defaultConfig.middleware,...userConfig.middleware},customRoutes:{...defaultConfig.customRoutes,...userConfig.customRoutes},cache:{...defaultConfig.cache,...userConfig.cache}},log("User config loaded and merged with defaults",3)}catch(e){if(e.message.includes("Config file must be within the server root directory"))throw e;log("Using default config (no config file found)",3)}const dis=new Set(config.disallowedRegex);dis.add("^/\\..*"),dis.add("\\.config$"),dis.add("\\.git/"),config.disallowedRegex=[...dis],log(`Config loaded with ${config.disallowedRegex.length} disallowed patterns`,3);let files=await getFiles(rootPath,config,log);log(`Initial scan found ${files.length} files`,2);const middlewareRunner=new MiddlewareRunner;if(config.middleware?.cors?.enabled&&(middlewareRunner.use(corsMiddleware(config.middleware.cors)),log("CORS middleware enabled",3)),config.middleware?.compression?.enabled&&(middlewareRunner.use(compressionMiddleware(config.middleware.compression)),log("Compression middleware enabled",3)),config.middleware?.rateLimit?.enabled&&(middlewareRunner.use(rateLimitMiddleware(config.middleware.rateLimit)),log("Rate limit middleware enabled",3)),config.middleware?.security?.enabled&&(middlewareRunner.use(securityMiddleware(config.middleware.security)),log("Security middleware enabled",3)),config.middleware?.logging?.enabled&&(middlewareRunner.use(loggingMiddleware(config.middleware.logging,log)),log("Logging middleware enabled",3)),config.middleware?.custom&&config.middleware.custom.length>0){log(`Loading ${config.middleware.custom.length} custom middleware files`,3);for(const middlewarePath of config.middleware.custom)try{const resolvedPath=path.resolve(middlewarePath),customMiddleware=(await import(pathToFileURL(resolvedPath))).default;"function"==typeof customMiddleware?(middlewareRunner.use(customMiddleware(config.middleware)),log(`Custom middleware loaded: ${middlewarePath}`,3)):log(`Custom middleware error: ${middlewarePath} does not export a default function`,1)}catch(error){log(`Custom middleware error for ${middlewarePath}: ${error.message}`,1)}}let moduleCache=null;config.cache?.enabled&&(moduleCache=new ModuleCache(config.cache),log(`Module cache initialized: ${config.cache.maxSize} max modules, ${config.cache.maxMemoryMB}MB limit, ${config.cache.ttlMs}ms TTL`,2));const customRoutes=new Map,wildcardRoutes=new Map;if(config.customRoutes&&Object.keys(config.customRoutes).length>0){log(`Processing ${Object.keys(config.customRoutes).length} custom routes`,3);for(const[urlPath,filePath]of Object.entries(config.customRoutes))if(urlPath.includes("*")){const resolvedPath=path.isAbsolute(filePath)?filePath:path.resolve(rootPath,filePath);wildcardRoutes.set(urlPath,resolvedPath),log(`Wildcard route mapped: ${urlPath} -> ${resolvedPath}`,3)}else{const resolvedPath=path.isAbsolute(filePath)?filePath:path.resolve(rootPath,filePath);customRoutes.set(urlPath,resolvedPath),log(`Custom route mapped: ${urlPath} -> ${resolvedPath}`,3)}}const matchWildcardRoute=(requestPath,pattern)=>{const regexPattern=pattern.replace(/\*\*/g,"(.+)").replace(/\*/g,"([^/]+)");return new RegExp(`^${regexPattern}$`).exec(requestPath)},rescanAttempts=new Map,dynamicNoRescanPaths=new Set,shouldSkipRescan=requestPath=>config.noRescanPaths.some(pattern=>new RegExp(pattern).test(requestPath))?(log(`Skipping rescan for configured pattern: ${requestPath}`,3),!0):!!dynamicNoRescanPaths.has(requestPath)&&(log(`Skipping rescan for dynamically blacklisted path: ${requestPath}`,3),!0),handler=async(req,res)=>{await middlewareRunner.run(req,res,async()=>{const requestPath=req.url.split("?")[0];log(`${req.method} ${requestPath}`,4),log(`customRoutes keys: ${Array.from(customRoutes.keys()).join(", ")}`,4);const normalizePath=p=>{try{let np=decodeURIComponent(p);return np.startsWith("/")||(np="/"+np),np.length>1&&np.endsWith("/")&&(np=np.slice(0,-1)),np}catch(e){log(`Warning: Failed to decode URI component "${p}": ${e.message}`,1);let np=p;return np.startsWith("/")||(np="/"+np),np.length>1&&np.endsWith("/")&&(np=np.slice(0,-1)),np}},normalizedRequestPath=normalizePath(requestPath);log(`Normalized requestPath: ${normalizedRequestPath}`,4);let matchedKey=null;for(const key of customRoutes.keys())if(normalizePath(key)===normalizedRequestPath){matchedKey=key;break}if(matchedKey){const customFilePath=customRoutes.get(matchedKey);log(`Serving custom route: ${normalizedRequestPath} -> ${customFilePath}`,3);try{const{stat:stat}=await import("fs/promises");try{await stat(customFilePath),log(`Custom route file exists: ${customFilePath}`,4)}catch(e){return log(`Custom route file does NOT exist: ${customFilePath}`,1),res.writeHead(404,{"Content-Type":"text/plain"}),void res.end("Custom route file not found")}const fileExtension=path.extname(customFilePath).toLowerCase().slice(1),mimeConfig=config.allowedMimes[fileExtension];let mimeType,encoding;"string"==typeof mimeConfig?(mimeType=mimeConfig,encoding=void 0):(mimeType=mimeConfig?.mime||"application/octet-stream",encoding="utf8"===mimeConfig?.encoding?"utf8":void 0);const fileContent=await readFile(customFilePath,encoding);return log(`Serving custom file as ${mimeType} (${fileContent.length} bytes)`,2),res.writeHead(200,{"Content-Type":mimeType}),void res.end(fileContent)}catch(error){return log(`Error serving custom route ${normalizedRequestPath}: ${error.message}`,1),res.writeHead(500,{"Content-Type":"text/plain"}),void res.end("Internal Server Error")}}const wildcardMatch=(requestPath=>{for(const[pattern,filePath]of wildcardRoutes){const matches=matchWildcardRoute(requestPath,pattern);if(matches)return{filePath:filePath,matches:matches}}return null})(requestPath);if(wildcardMatch){const resolvedFilePath=((filePath,matches)=>{let resolvedPath=filePath,matchIndex=1;for(;resolvedPath.includes("**")&&matchIndex<matches.length;)resolvedPath=resolvedPath.replace("**",matches[matchIndex]),matchIndex++;for(;resolvedPath.includes("*")&&matchIndex<matches.length;)resolvedPath=resolvedPath.replace("*",matches[matchIndex]),matchIndex++;return path.isAbsolute(resolvedPath)?resolvedPath:path.resolve(rootPath,resolvedPath)})(wildcardMatch.filePath,wildcardMatch.matches);log(`Serving wildcard route: ${requestPath} -> ${resolvedFilePath}`,3);try{const fileExtension=path.extname(resolvedFilePath).toLowerCase().slice(1),mimeConfig=config.allowedMimes[fileExtension];let mimeType,encoding;"string"==typeof mimeConfig?(mimeType=mimeConfig,encoding=void 0):(mimeType=mimeConfig?.mime||"application/octet-stream",encoding="utf8"===mimeConfig?.encoding?"utf8":void 0);const fileContent=await readFile(resolvedFilePath,encoding);return log(`Serving wildcard file as ${mimeType} (${fileContent.length} bytes)`,4),res.writeHead(200,{"Content-Type":mimeType}),void res.end(fileContent)}catch(error){return log(`Error serving wildcard route ${requestPath}: ${error.message}`,1),res.writeHead(500,{"Content-Type":"text/plain"}),void res.end("Internal Server Error")}}const served=await serveFile(files,rootPath,requestPath,req.method,config,req,res,log,moduleCache);if(served||!flags.scan||shouldSkipRescan(requestPath))served||(shouldSkipRescan(requestPath)?log(`404 - Skipped rescan for: ${requestPath}`,2):log(`404 - File not found: ${requestPath}`,1),res.writeHead(404,{"Content-Type":"text/plain"}),res.end("Not Found"));else{(requestPath=>{const newAttempts=(rescanAttempts.get(requestPath)||0)+1;rescanAttempts.set(requestPath,newAttempts),newAttempts>=config.maxRescanAttempts&&(dynamicNoRescanPaths.add(requestPath),log(`Path ${requestPath} added to dynamic blacklist after ${newAttempts} failed attempts`,1)),log(`Rescan attempt ${newAttempts}/${config.maxRescanAttempts} for: ${requestPath}`,3)})(requestPath),log("File not found, rescanning directory...",1),files=await getFiles(rootPath,config,log),log(`Rescan found ${files.length} files`,2);await serveFile(files,rootPath,requestPath,req.method,config,req,res,log,moduleCache)||(log(`404 - File not found after rescan: ${requestPath}`,1),res.writeHead(404,{"Content-Type":"text/plain"}),res.end("Not Found"))}})};return handler.moduleCache=moduleCache,handler.getStats=()=>moduleCache?.getStats()||null,handler.logCacheStats=()=>moduleCache?.logStats(log),handler.clearCache=()=>moduleCache?.clear(),handler};

package/dist/serveFile.js

@@ -1 +1 @@
-import path from"path";import{readFile,stat}from"fs/promises";import{pathToFileURL}from"url";import findFile from"./findFile.js";import createRequestWrapper from"./requestWrapper.js";import createResponseWrapper from"./responseWrapper.js";export default async(files,rootPath,requestPath,method,config,req,res,log,moduleCache=null)=>{log(`Attempting to serve: ${requestPath}`,3);const[file,params]=await findFile(files,rootPath,requestPath,method,log);if(!file)return log(`No file found for: ${requestPath}`,3),!1;const fileName=path.basename(file);if(log(`Found file: ${file}`,2),config.routeFiles.includes(fileName)){log(`Executing route file: ${fileName}`,2);try{let module;if(moduleCache&&config.cache?.enabled){const fileStats=await stat(file);if(module=moduleCache.get(file,fileStats),module)log(`Using cached module: ${fileName}`,3);else{const fileUrl=pathToFileURL(file).href+`?t=${Date.now()}`;log(`Loading module from: ${fileUrl}`,3),module=await import(fileUrl);const estimatedSizeKB=fileStats.size/1024;moduleCache.set(file,module,fileStats,estimatedSizeKB),log(`Cached module: ${fileName} (${estimatedSizeKB.toFixed(1)}KB)`,3)}}else{const fileUrl=pathToFileURL(file).href+`?t=${Date.now()}`;log(`Loading module from: ${fileUrl}`,3),module=await import(fileUrl)}if("function"==typeof module.default){log(`Executing route function with params: ${JSON.stringify(params)}`,3);const enhancedRequest=createRequestWrapper(req,params),enhancedResponse=createResponseWrapper(res);return moduleCache&&(enhancedRequest._kempoCache=moduleCache),await module.default(enhancedRequest,enhancedResponse),log(`Route executed successfully: ${fileName}`,2),!0}return log(`Route file does not export a function: ${fileName}`,0),res.writeHead(500,{"Content-Type":"text/plain"}),res.end("Route file does not export a function"),!0}catch(error){return log(`Error loading route file ${fileName}: ${error.message}`,0),res.writeHead(500,{"Content-Type":"text/plain"}),res.end("Internal Server Error"),!0}}else{log(`Serving static file: ${fileName}`,2);try{const fileContent=await readFile(file),fileExtension=path.extname(file).toLowerCase().slice(1),mimeType=config.allowedMimes[fileExtension]||"application/octet-stream";return log(`Serving ${file} as ${mimeType} (${fileContent.length} bytes)`,2),res.writeHead(200,{"Content-Type":mimeType}),res.end(fileContent),!0}catch(error){return log(`Error reading file ${file}: ${error.message}`,0),res.writeHead(500,{"Content-Type":"text/plain"}),res.end("Internal Server Error"),!0}}};
+import path from"path";import{readFile,stat}from"fs/promises";import{pathToFileURL}from"url";import findFile from"./findFile.js";import createRequestWrapper from"./requestWrapper.js";import createResponseWrapper from"./responseWrapper.js";export default async(files,rootPath,requestPath,method,config,req,res,log,moduleCache=null)=>{log(`Attempting to serve: ${requestPath}`,3);const[file,params]=await findFile(files,rootPath,requestPath,method,log);if(!file)return log(`No file found for: ${requestPath}`,3),!1;const fileName=path.basename(file);if(log(`Found file: ${file}`,2),config.routeFiles.includes(fileName)){log(`Executing route file: ${fileName}`,2);try{let module;if(moduleCache&&config.cache?.enabled){const fileStats=await stat(file);if(module=moduleCache.get(file,fileStats),module)log(`Using cached module: ${fileName}`,3);else{const fileUrl=pathToFileURL(file).href+`?t=${Date.now()}`;log(`Loading module from: ${fileUrl}`,3),module=await import(fileUrl);const estimatedSizeKB=fileStats.size/1024;moduleCache.set(file,module,fileStats,estimatedSizeKB),log(`Cached module: ${fileName} (${estimatedSizeKB.toFixed(1)}KB)`,3)}}else{const fileUrl=pathToFileURL(file).href+`?t=${Date.now()}`;log(`Loading module from: ${fileUrl}`,3),module=await import(fileUrl)}if("function"==typeof module.default){log(`Executing route function with params: ${JSON.stringify(params)}`,3);const enhancedRequest=createRequestWrapper(req,params),enhancedResponse=createResponseWrapper(res);return moduleCache&&(enhancedRequest._kempoCache=moduleCache),await module.default(enhancedRequest,enhancedResponse),log(`Route executed successfully: ${fileName}`,2),!0}return log(`Route file does not export a function: ${fileName}`,0),res.writeHead(500,{"Content-Type":"text/plain"}),res.end("Route file does not export a function"),!0}catch(error){return log(`Error loading route file ${fileName}: ${error.message}`,0),res.writeHead(500,{"Content-Type":"text/plain"}),res.end("Internal Server Error"),!0}}else{log(`Serving static file: ${fileName}`,2);try{const fileExtension=path.extname(file).toLowerCase().slice(1),mimeConfig=config.allowedMimes[fileExtension];let mimeType,encoding;"string"==typeof mimeConfig?(mimeType=mimeConfig,encoding=void 0):(mimeType=mimeConfig?.mime||"application/octet-stream",encoding="utf8"===mimeConfig?.encoding?"utf8":void 0);const fileContent=await readFile(file,encoding);return log(`Serving ${file} as ${mimeType} (${fileContent.length} bytes)`,2),res.writeHead(200,{"Content-Type":mimeType}),res.end(fileContent),!0}catch(error){return log(`Error reading file ${file}: ${error.message}`,0),res.writeHead(500,{"Content-Type":"text/plain"}),res.end("Internal Server Error"),!0}}};

package/dist/utils/ensure-build.js

@@ -0,0 +1 @@
+import{execSync}from"child_process";import fs from"fs";import path from"path";let hasBuilt=!1;export default function ensureBuild(){if(hasBuilt)return;const distIndex=path.join(process.cwd(),"dist/index.js");if(!fs.existsSync(distIndex))try{execSync("npm run build",{stdio:"pipe"}),console.log("✓ Build completed successfully")}catch(error){throw console.error("✗ Build failed:",error.message),error}hasBuilt=!0}

package/docs/configuration.html

@@ -32,8 +32,22 @@
     </ul>
 
     <h3 id="allowedMimes">allowedMimes</h3>
-    <p>An object mapping file extensions to their MIME types. Files with extensions not in this list will not be served.</p>
-    <pre><code class="hljs json">{<br />  <span class="hljs-attr">"allowedMimes"</span>: {<br />    <span class="hljs-attr">"html"</span>: <span class="hljs-string">"text/html"</span>,<br />    <span class="hljs-attr">"css"</span>: <span class="hljs-string">"text/css"</span>,<br />    <span class="hljs-attr">"js"</span>: <span class="hljs-string">"application/javascript"</span>,<br />    <span class="hljs-attr">"json"</span>: <span class="hljs-string">"application/json"</span>,<br />    <span class="hljs-attr">"png"</span>: <span class="hljs-string">"image/png"</span>,<br />    <span class="hljs-attr">"jpg"</span>: <span class="hljs-string">"image/jpeg"</span>,<br />    <span class="hljs-attr">"jpeg"</span>: <span class="hljs-string">"image/jpeg"</span>,<br />    <span class="hljs-attr">"gif"</span>: <span class="hljs-string">"image/gif"</span>,<br />    <span class="hljs-attr">"svg"</span>: <span class="hljs-string">"image/svg+xml"</span>,<br />    <span class="hljs-attr">"woff"</span>: <span class="hljs-string">"font/woff"</span>,<br />    <span class="hljs-attr">"woff2"</span>: <span class="hljs-string">"font/woff2"</span><br />  }<br />}</code></pre>
+    <p>An object mapping file extensions to their MIME types and encoding. Each value is an object with <code>mime</code> and <code>encoding</code> properties. Files with extensions not in this list will not be served.</p>
+    <pre><code class="hljs json">{
+  "allowedMimes": {
+    "html": { "mime": "text/html", "encoding": "utf8" },
+    "css": { "mime": "text/css", "encoding": "utf8" },
+    "js": { "mime": "application/javascript", "encoding": "utf8" },
+    "json": { "mime": "application/json", "encoding": "utf8" },
+    "png": { "mime": "image/png", "encoding": "binary" },
+    "jpg": { "mime": "image/jpeg", "encoding": "binary" },
+    "jpeg": { "mime": "image/jpeg", "encoding": "binary" },
+    "gif": { "mime": "image/gif", "encoding": "binary" },
+    "svg": { "mime": "image/svg+xml", "encoding": "utf8" },
+    "woff": { "mime": "font/woff", "encoding": "binary" },
+    "woff2": { "mime": "font/woff2", "encoding": "binary" }
+  }
+}</code></pre>
 
     <h3 id="disallowedRegex">disallowedRegex</h3>
     <p>An array of regular expressions that match paths that should never be served. This provides security by preventing access to sensitive files.</p>
@@ -85,6 +99,62 @@
     <h3>Development Configuration</h3>
     <p>Create <code>.config.dev.json</code> for development:</p>
     <pre><code class="hljs json">{<br />  <span class="hljs-attr">"allowedMimes"</span>: {<br />    <span class="hljs-attr">"html"</span>: <span class="hljs-string">"text/html"</span>,<br />    <span class="hljs-attr">"css"</span>: <span class="hljs-string">"text/css"</span>,<br />    <span class="hljs-attr">"js"</span>: <span class="hljs-string">"application/javascript"</span>,<br />    <span class="hljs-attr">"json"</span>: <span class="hljs-string">"application/json"</span>,<br />    <span class="hljs-attr">"map"</span>: <span class="hljs-string">"application/json"</span><br />  },<br />  <span class="hljs-attr">"middleware"</span>: {<br />    <span class="hljs-attr">"cors"</span>: {<br />      <span class="hljs-attr">"enabled"</span>: <span class="hljs-literal">true</span>,<br />      <span class="hljs-attr">"origin"</span>: <span class="hljs-string">"*"</span><br />    },<br />    <span class="hljs-attr">"compression"</span>: {<br />      <span class="hljs-attr">"enabled"</span>: <span class="hljs-literal">false</span><br />    }<br />  }<br />}</code></pre>
+    <pre><code class="hljs json">{
+  "allowedMimes": {
+    "html": { "mime": "text/html", "encoding": "utf8" },
+    "css": { "mime": "text/css", "encoding": "utf8" },
+    "js": { "mime": "application/javascript", "encoding": "utf8" },
+    "json": { "mime": "application/json", "encoding": "utf8" },
+    "map": { "mime": "application/json", "encoding": "utf8" }
+  },
+  "middleware": {
+    "cors": {
+      "enabled": true,
+      "origin": "*"
+    },
+    "compression": {
+      "enabled": false
+    }
+  }
+}</code></pre>
+    <pre><code class="hljs json">{
+  "allowedMimes": {
+    "html": { "mime": "text/html", "encoding": "utf8" },
+    "css": { "mime": "text/css", "encoding": "utf8" },
+    "js": { "mime": "application/javascript", "encoding": "utf8" },
+    "json": { "mime": "application/json", "encoding": "utf8" },
+    "png": { "mime": "image/png", "encoding": "binary" },
+    "jpg": { "mime": "image/jpeg", "encoding": "binary" }
+  },
+  "disallowedRegex": [
+    "^/\\..*",
+    "\\.env$",
+    "\\.config$",
+    "password",
+    "node_modules",
+    "\\.git",
+    "\\.map$"
+  ],
+  "middleware": {
+    "cors": {
+      "enabled": true,
+      "origin": "https://yourdomain.com"
+    },
+    "compression": {
+      "enabled": true,
+      "threshold": 1024
+    },
+    "security": {
+      "enabled": true,
+      "headers": {
+        "X-Content-Type-Options": "nosniff",
+        "X-Frame-Options": "DENY",
+        "X-XSS-Protection": "1; mode=block",
+        "Strict-Transport-Security": "max-age=31536000; includeSubDomains"
+      }
+    }
+  }
+}</code></pre>
     <p>Use with: <code>kempo-server --root public --config .config.dev.json</code></p>
 
     <h3>Production Configuration</h3>

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "kempo-server",
   "type": "module",
-  "version": "1.7.12",
+  "version": "1.8.0",
   "description": "A lightweight, zero-dependency, file based routing server.",
   "main": "dist/index.js",
   "exports": {

package/src/defaultConfig.js

@@ -1,46 +1,46 @@
 export default {
   allowedMimes: {
-    html: "text/html",
-    htm: "text/html",
-    shtml: "text/html",
-    css: "text/css",
-    xml: "text/xml",
-    gif: "image/gif",
-    jpeg: "image/jpeg",
-    jpg: "image/jpeg",
-    js: "application/javascript",
-    mjs: "application/javascript",
-    json: "application/json",
-    webp: "image/webp",
-    png: "image/png",
-    svg: "image/svg+xml",
-    svgz: "image/svg+xml",
-    ico: "image/x-icon",
-    webm: "video/webm",
-    mp4: "video/mp4",
-    m4v: "video/mp4",
-    ogv: "video/ogg",
-    mp3: "audio/mpeg",
-    ogg: "audio/ogg",
-    wav: "audio/wav",
-    woff: "font/woff",
-    woff2: "font/woff2",
-    ttf: "font/ttf",
-    otf: "font/otf",
-    eot: "application/vnd.ms-fontobject",
-    pdf: "application/pdf",
-    txt: "text/plain",
-    webmanifest: "application/manifest+json",
-    md: "text/markdown",
-    csv: "text/csv",
-    doc: "application/msword",
-    docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-    xls: "application/vnd.ms-excel",
-    xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-    ppt: "application/vnd.ms-powerpoint",
-    pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
-    avif: "image/avif",
-    wasm: "application/wasm"
+    html: { mime: "text/html", encoding: "utf8" },
+    htm: { mime: "text/html", encoding: "utf8" },
+    shtml: { mime: "text/html", encoding: "utf8" },
+    css: { mime: "text/css", encoding: "utf8" },
+    xml: { mime: "text/xml", encoding: "utf8" },
+    gif: { mime: "image/gif", encoding: "binary" },
+    jpeg: { mime: "image/jpeg", encoding: "binary" },
+    jpg: { mime: "image/jpeg", encoding: "binary" },
+    js: { mime: "application/javascript", encoding: "utf8" },
+    mjs: { mime: "application/javascript", encoding: "utf8" },
+    json: { mime: "application/json", encoding: "utf8" },
+    webp: { mime: "image/webp", encoding: "binary" },
+    png: { mime: "image/png", encoding: "binary" },
+    svg: { mime: "image/svg+xml", encoding: "utf8" },
+    svgz: { mime: "image/svg+xml", encoding: "utf8" },
+    ico: { mime: "image/x-icon", encoding: "binary" },
+    webm: { mime: "video/webm", encoding: "binary" },
+    mp4: { mime: "video/mp4", encoding: "binary" },
+    m4v: { mime: "video/mp4", encoding: "binary" },
+    ogv: { mime: "video/ogg", encoding: "binary" },
+    mp3: { mime: "audio/mpeg", encoding: "binary" },
+    ogg: { mime: "audio/ogg", encoding: "binary" },
+    wav: { mime: "audio/wav", encoding: "binary" },
+    woff: { mime: "font/woff", encoding: "binary" },
+    woff2: { mime: "font/woff2", encoding: "binary" },
+    ttf: { mime: "font/ttf", encoding: "binary" },
+    otf: { mime: "font/otf", encoding: "binary" },
+    eot: { mime: "application/vnd.ms-fontobject", encoding: "binary" },
+    pdf: { mime: "application/pdf", encoding: "binary" },
+    txt: { mime: "text/plain", encoding: "utf8" },
+    webmanifest: { mime: "application/manifest+json", encoding: "utf8" },
+    md: { mime: "text/markdown", encoding: "utf8" },
+    csv: { mime: "text/csv", encoding: "utf8" },
+    doc: { mime: "application/msword", encoding: "binary" },
+    docx: { mime: "application/vnd.openxmlformats-officedocument.wordprocessingml.document", encoding: "binary" },
+    xls: { mime: "application/vnd.ms-excel", encoding: "binary" },
+    xlsx: { mime: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", encoding: "binary" },
+    ppt: { mime: "application/vnd.ms-powerpoint", encoding: "binary" },
+    pptx: { mime: "application/vnd.openxmlformats-officedocument.presentationml.presentation", encoding: "binary" },
+    avif: { mime: "image/avif", encoding: "binary" },
+    wasm: { mime: "application/wasm", encoding: "binary" }
   },
   disallowedRegex: [
     "^/\\..*",

package/src/getFiles.js

@@ -32,11 +32,10 @@ export default async (root, config, log) => {
   const isAllowedMimeType = (filePath) => {
     const ext = getExtension(filePath);
     const allowed = config.allowedMimes.hasOwnProperty(ext);
-    
+    // If you ever need the MIME type, use config.allowedMimes[ext]?.mime
     if (!allowed) {
       log(`Skipping file with disallowed extension: ${path.relative(root, filePath)} (.${ext})`, 4);
     }
-    
     return allowed;
   };
   

package/src/router.js

@@ -310,9 +310,17 @@ export default async (flags, log) => {
             res.end('Custom route file not found');
             return;
           }
-          const fileContent = await readFile(customFilePath);
           const fileExtension = path.extname(customFilePath).toLowerCase().slice(1);
-          const mimeType = config.allowedMimes[fileExtension] || 'application/octet-stream';
+          const mimeConfig = config.allowedMimes[fileExtension];
+          let mimeType, encoding;
+          if (typeof mimeConfig === 'string') {
+            mimeType = mimeConfig;
+            encoding = undefined;
+          } else {
+            mimeType = mimeConfig?.mime || 'application/octet-stream';
+            encoding = mimeConfig?.encoding === 'utf8' ? 'utf8' : undefined;
+          }
+          const fileContent = await readFile(customFilePath, encoding);
           log(`Serving custom file as ${mimeType} (${fileContent.length} bytes)`, 2);
           res.writeHead(200, { 'Content-Type': mimeType });
           res.end(fileContent);
@@ -331,9 +339,17 @@ export default async (flags, log) => {
         const resolvedFilePath = resolveWildcardPath(wildcardMatch.filePath, wildcardMatch.matches);
         log(`Serving wildcard route: ${requestPath} -> ${resolvedFilePath}`, 3);
         try {
-          const fileContent = await readFile(resolvedFilePath);
           const fileExtension = path.extname(resolvedFilePath).toLowerCase().slice(1);
-          const mimeType = config.allowedMimes[fileExtension] || 'application/octet-stream';
+          const mimeConfig = config.allowedMimes[fileExtension];
+          let mimeType, encoding;
+          if (typeof mimeConfig === 'string') {
+            mimeType = mimeConfig;
+            encoding = undefined;
+          } else {
+            mimeType = mimeConfig?.mime || 'application/octet-stream';
+            encoding = mimeConfig?.encoding === 'utf8' ? 'utf8' : undefined;
+          }
+          const fileContent = await readFile(resolvedFilePath, encoding);
           log(`Serving wildcard file as ${mimeType} (${fileContent.length} bytes)`, 4);
           res.writeHead(200, { 'Content-Type': mimeType });
           res.end(fileContent);

package/src/serveFile.js

@@ -79,13 +79,20 @@ export default async (files, rootPath, requestPath, method, config, req, res, lo
       return true; // Handled (even though it's an error)
     }
   } else {
-    // Serve the file content with appropriate MIME type
+    // Serve the file content with appropriate MIME type and encoding
     log(`Serving static file: ${fileName}`, 2);
     try {
-      const fileContent = await readFile(file);
       const fileExtension = path.extname(file).toLowerCase().slice(1);
-      const mimeType = config.allowedMimes[fileExtension] || 'application/octet-stream';
-      
+      const mimeConfig = config.allowedMimes[fileExtension];
+      let mimeType, encoding;
+      if (typeof mimeConfig === 'string') {
+        mimeType = mimeConfig;
+        encoding = undefined;
+      } else {
+        mimeType = mimeConfig?.mime || 'application/octet-stream';
+        encoding = mimeConfig?.encoding === 'utf8' ? 'utf8' : undefined;
+      }
+      const fileContent = await readFile(file, encoding);
       log(`Serving ${file} as ${mimeType} (${fileContent.length} bytes)`, 2);
       res.writeHead(200, { 'Content-Type': mimeType });
       res.end(fileContent);

package/tests/config-flag-cli.node-test.js

@@ -1,5 +1,8 @@
 import {startNode, randomPort, httpGet, withTempDir, write} from './test-utils.js';
 import path from 'path';
+import ensureBuild from './ensure-build.js';
+
+ensureBuild();
 
 export default {
   'CLI uses default config file when no --config flag provided': async ({pass, fail}) => {
@@ -7,8 +10,8 @@ export default {
       // Create default config and test file
       const defaultConfig = {
         allowedMimes: {
-          html: "text/html",
-          default: "text/default"
+          html: { mime: "text/html", encoding: "utf8" },
+          default: { mime: "text/default", encoding: "utf8" }
         }
       };
       await write(dir, '.config.json', JSON.stringify(defaultConfig));
@@ -45,8 +48,8 @@ export default {
       // Create custom config and test file
       const customConfig = {
         allowedMimes: {
-          html: "text/html",
-          custom: "text/custom"
+          html: { mime: "text/html", encoding: "utf8" },
+          custom: { mime: "text/custom", encoding: "utf8" }
         }
       };
       await write(dir, 'dev.config.json', JSON.stringify(customConfig));
@@ -89,8 +92,8 @@ export default {
       // Create custom config and test file
       const customConfig = {
         allowedMimes: {
-          html: "text/html",
-          short: "text/short"
+          html: { mime: "text/html", encoding: "utf8" },
+          short: { mime: "text/short", encoding: "utf8" }
         }
       };
       await write(dir, 'short.config.json', JSON.stringify(customConfig));
@@ -134,8 +137,8 @@ export default {
       const configDir = path.join(dir, 'configs');
       const customConfig = {
         allowedMimes: {
-          html: "text/html",
-          absolute: "text/absolute"
+          html: { mime: "text/html", encoding: "utf8" },
+          absolute: { mime: "text/absolute", encoding: "utf8" }
         }
       };
       const configPath = await write(configDir, 'prod.config.json', JSON.stringify(customConfig));

package/tests/config-flag.node-test.js

@@ -91,8 +91,8 @@ export default {
       // Create a custom config file as .config.json (default name)
       const customConfig = {
         allowedMimes: {
-          html: "text/html",
-          custom: "text/custom"
+          html: { mime: "text/html", encoding: "utf8" },
+          custom: { mime: "text/custom", encoding: "utf8" }
         }
       };
       await write(dir, '.config.json', JSON.stringify(customConfig));
@@ -128,12 +128,12 @@ export default {
   'router uses custom config file with relative path': async ({pass, fail}) => {
     await withTempDir(async (dir) => {
       // Create a custom config file with different name
-      const customConfig = {
-        allowedMimes: {
-          html: "text/html",
-          special: "text/special"
-        }
-      };
+        const customConfig = {
+          allowedMimes: {
+            html: { mime: "text/html", encoding: "utf8" },
+            special: { mime: "text/special", encoding: "utf8" }
+          }
+        };
       await write(dir, 'dev.config.json', JSON.stringify(customConfig));
       await write(dir, 'test.special', 'special content');
       
@@ -168,12 +168,12 @@ export default {
     await withTempDir(async (dir) => {
       // Create a custom config file in different location
       const configDir = path.join(dir, 'configs');
-      const customConfig = {
-        allowedMimes: {
-          html: "text/html",
-          absolute: "text/absolute"
-        }
-      };
+        const customConfig = {
+          allowedMimes: {
+            html: { mime: "text/html", encoding: "utf8" },
+            absolute: { mime: "text/absolute", encoding: "utf8" }
+          }
+        };
       const configPath = await write(configDir, 'prod.config.json', JSON.stringify(customConfig));
       await write(dir, 'test.absolute', 'absolute content');
       
@@ -274,7 +274,7 @@ export default {
       // Create partial config that only overrides some settings
       const partialConfig = {
         allowedMimes: {
-          custom: "text/custom"
+            custom: { mime: "text/custom", encoding: "utf8" }
         },
         maxRescanAttempts: 5
       };

package/tests/defaultConfig.node-test.js

@@ -3,7 +3,10 @@ import defaultConfig from '../src/defaultConfig.js';
 export default {
   'defaultConfig contains required fields and types': async ({pass, fail}) => {
     if(typeof defaultConfig !== 'object') return fail('not object');
-    if(!defaultConfig.allowedMimes || !defaultConfig.disallowedRegex) return fail('missing keys');
+  if(!defaultConfig.allowedMimes || !defaultConfig.disallowedRegex) return fail('missing keys');
+  // Check for mime and encoding properties in a few extensions
+  if(!defaultConfig.allowedMimes.html || defaultConfig.allowedMimes.html.mime !== 'text/html' || defaultConfig.allowedMimes.html.encoding !== 'utf8') return fail('html mime/encoding incorrect');
+  if(!defaultConfig.allowedMimes.png || defaultConfig.allowedMimes.png.mime !== 'image/png' || defaultConfig.allowedMimes.png.encoding !== 'binary') return fail('png mime/encoding incorrect');
     if(!defaultConfig.routeFiles.includes('GET.js')) return fail('routeFiles missing GET.js');
     if(!defaultConfig.middleware || typeof defaultConfig.middleware !== 'object') return fail('middleware missing');
     

package/tests/ensure-build.js

@@ -0,0 +1,22 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+
+let hasBuilt = false;
+
+export default function ensureBuild() {
+  if (hasBuilt) return;
+  
+  const distIndex = path.join(process.cwd(), 'dist/index.js');
+  if (!fs.existsSync(distIndex)) {
+    try {
+      execSync('npm run build', { stdio: 'pipe' });
+      console.log('✓ Build completed successfully');
+    } catch (error) {
+      console.error('✗ Build failed:', error.message);
+      throw error;
+    }
+  }
+  
+  hasBuilt = true;
+}

package/tests/index.node-test.js

@@ -1,5 +1,8 @@
 import {startNode, randomPort, httpGet, withTestDir, write} from './test-utils.js';
 import path from 'path';
+import ensureBuild from './ensure-build.js';
+
+ensureBuild();
 
 export default {
   'index.js CLI starts server and serves root': async ({pass, fail}) => {

package/tests/mimeTypes-merge.node-test.js

@@ -0,0 +1,189 @@
+import defaultConfig from '../src/defaultConfig.js';
+import router from '../src/router.js';
+import http from 'http';
+import { mkdtemp, writeFile, rm } from 'fs/promises';
+import { tmpdir } from 'os';
+import path from 'path';
+
+const withTempDir = async (callback) => {
+  const dir = await mkdtemp(path.join(tmpdir(), 'kempo-test-'));
+  try {
+    await callback(dir);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+};
+
+const write = async (dir, filename, content) => {
+  const filePath = path.join(dir, filename);
+  await writeFile(filePath, content, 'utf8');
+  return filePath;
+};
+
+const httpGet = (url) => new Promise((resolve, reject) => {
+  http.get(url, (res) => {
+    let data = '';
+    res.on('data', chunk => data += chunk);
+    res.on('end', () => resolve({ res, data }));
+  }).on('error', reject);
+});
+
+const randomPort = () => Math.floor(Math.random() * 10000) + 10000;
+
+export default {
+  'allowedMimes should merge with defaults, not replace them': async ({pass, fail}) => {
+    await withTempDir(async (dir) => {
+      const customConfig = {
+        allowedMimes: {
+          js: { mime: "text/javascript", encoding: "utf8" },
+          mjs: { mime: "text/javascript", encoding: "utf8" }
+        }
+      };
+      
+  await write(dir, '.config.json', JSON.stringify(customConfig));
+  await write(dir, 'test.css', 'body { color: red; }');
+  await write(dir, 'test.js', 'console.log("test");');
+  await write(dir, 'test.html', '<html></html>');
+  // Check config merge for mime and encoding
+  const mergedConfig = { ...defaultConfig.allowedMimes, ...customConfig.allowedMimes };
+  if(mergedConfig.js.mime !== 'text/javascript' || mergedConfig.js.encoding !== 'utf8') return fail('js mime/encoding merge failed');
+  if(mergedConfig.css.mime !== 'text/css' || mergedConfig.css.encoding !== 'utf8') return fail('css mime/encoding merge failed');
+      
+      const flags = {root: dir, logging: 0, scan: false, config: '.config.json'};
+      const logFn = () => {};
+      const handler = await router(flags, logFn);
+      const server = http.createServer(handler);
+      const port = randomPort();
+      
+      await new Promise(r => server.listen(port, r));
+      await new Promise(r => setTimeout(r, 50));
+      
+      try {
+        const cssResponse = await httpGet(`http://localhost:${port}/test.css`);
+        if(cssResponse.res.statusCode !== 200){
+          return fail('CSS file should be served');
+        }
+        if(cssResponse.res.headers['content-type'] !== 'text/css'){
+          return fail(`CSS should have text/css MIME type, got: ${cssResponse.res.headers['content-type']}`);
+        }
+        
+        const jsResponse = await httpGet(`http://localhost:${port}/test.js`);
+        if(jsResponse.res.statusCode !== 200){
+          return fail('JS file should be served');
+        }
+        if(jsResponse.res.headers['content-type'] !== 'text/javascript'){
+          return fail(`JS should have custom text/javascript MIME type, got: ${jsResponse.res.headers['content-type']}`);
+        }
+        
+        const htmlResponse = await httpGet(`http://localhost:${port}/test.html`);
+        if(htmlResponse.res.statusCode !== 200){
+          return fail('HTML file should be served');
+        }
+        if(htmlResponse.res.headers['content-type'] !== 'text/html'){
+          return fail(`HTML should have text/html MIME type, got: ${htmlResponse.res.headers['content-type']}`);
+        }
+        
+        pass('allowedMimes merges correctly with defaults');
+      } finally {
+        server.close();
+      }
+    });
+  },
+
+  'custom MIME types should override defaults': async ({pass, fail}) => {
+    await withTempDir(async (dir) => {
+      const customConfig = {
+        allowedMimes: {
+          js: { mime: "custom/javascript", encoding: "utf8" },
+          custom: { mime: "application/custom", encoding: "utf8" }
+        }
+      };
+      
+      await write(dir, '.config.json', JSON.stringify(customConfig));
+      await write(dir, 'test.js', 'console.log("test");');
+      await write(dir, 'test.custom', 'custom content');
+      
+      const flags = {root: dir, logging: 0, scan: false, config: '.config.json'};
+      const logFn = () => {};
+      const handler = await router(flags, logFn);
+      const server = http.createServer(handler);
+      const port = randomPort();
+      
+      await new Promise(r => server.listen(port, r));
+      await new Promise(r => setTimeout(r, 50));
+      
+      try {
+        const jsResponse = await httpGet(`http://localhost:${port}/test.js`);
+        if(jsResponse.res.statusCode !== 200){
+          return fail('JS file should be served');
+        }
+        if(jsResponse.res.headers['content-type'] !== 'custom/javascript'){
+          return fail(`JS should have overridden MIME type custom/javascript, got: ${jsResponse.res.headers['content-type']}`);
+        }
+        const customResponse = await httpGet(`http://localhost:${port}/test.custom`);
+        if(customResponse.res.statusCode !== 200){
+          return fail('Custom file should be served');
+        }
+        if(customResponse.res.headers['content-type'] !== 'application/custom'){
+          return fail(`Custom extension should have application/custom MIME type, got: ${customResponse.res.headers['content-type']}`);
+        }
+        
+        pass('custom MIME types correctly override defaults');
+      } finally {
+        server.close();
+      }
+    });
+  },
+
+  'all default MIME types should be preserved when adding custom ones': async ({pass, fail}) => {
+    await withTempDir(async (dir) => {
+      const customConfig = {
+        allowedMimes: {
+          custom: { mime: "application/custom", encoding: "utf8" }
+        }
+      };
+      
+      await write(dir, '.config.json', JSON.stringify(customConfig));
+      await write(dir, 'test.css', 'body {}');
+      await write(dir, 'test.html', '<html></html>');
+      await write(dir, 'test.json', '{}');
+      await write(dir, 'test.svg', '<svg></svg>');
+      await write(dir, 'test.png', 'fake png');
+      await write(dir, 'test.custom', 'custom');
+      
+      const flags = {root: dir, logging: 0, scan: false, config: '.config.json'};
+      const logFn = () => {};
+      const handler = await router(flags, logFn);
+      const server = http.createServer(handler);
+      const port = randomPort();
+      
+      await new Promise(r => server.listen(port, r));
+      await new Promise(r => setTimeout(r, 50));
+      
+      try {
+        const tests = [
+          { file: 'test.css', expectedType: 'text/css' },
+          { file: 'test.html', expectedType: 'text/html' },
+          { file: 'test.json', expectedType: 'application/json' },
+          { file: 'test.svg', expectedType: 'image/svg+xml' },
+          { file: 'test.png', expectedType: 'image/png' },
+          { file: 'test.custom', expectedType: 'application/custom' }
+        ];
+        
+        for(const test of tests){
+          const response = await httpGet(`http://localhost:${port}/${test.file}`);
+          if(response.res.statusCode !== 200){
+            return fail(`${test.file} should be served (status ${response.res.statusCode})`);
+          }
+          if(response.res.headers['content-type'] !== test.expectedType){
+            return fail(`${test.file} should have ${test.expectedType} MIME type, got: ${response.res.headers['content-type']}`);
+          }
+        }
+        
+        pass('all default MIME types preserved when adding custom types');
+      } finally {
+        server.close();
+      }
+    });
+  }
+};