@chenpu17/serve-here 1.0.0 → 1.0.2

package/README.md

@@ -8,6 +8,8 @@ Serve any local directory over HTTP with a single command.
   立即托管当前目录或指定目录。
 - Automatic `index.html` support plus clean directory listings.  
   自动识别 `index.html`，无首页时提供整洁的目录列表。
+- Safe redirects for non-ASCII directory names (e.g. 中文路径).  
+  支持中文等非 ASCII 路径的安全重定向。
 - Directory rows include file size and last modified time.  
   列表项展示文件大小与最近修改时间。
 - Works as a global install or `npx` one-off.  

package/bin/serve-here.js

@@ -4,12 +4,212 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 const process = require('process');
+const { spawn } = require('child_process');
 
 const { createStaticServer } = require('../src/server');
 const pkg = require('../package.json');
 
 const DEFAULT_PORT = 8080;
 const DEFAULT_HOST = '0.0.0.0';
+const PID_DIR = path.join(os.homedir(), '.serve-here');
+const LOG_DIR = path.join(os.homedir(), '.serve-here', 'logs');
+
+function ensureDirectories() {
+  if (!fs.existsSync(PID_DIR)) {
+    fs.mkdirSync(PID_DIR, { recursive: true });
+  }
+  if (!fs.existsSync(LOG_DIR)) {
+    fs.mkdirSync(LOG_DIR, { recursive: true });
+  }
+}
+
+function getPidFile(port) {
+  return path.join(PID_DIR, `serve-here-${port}.pid`);
+}
+
+function getLogFile(port) {
+  return path.join(LOG_DIR, `serve-here-${port}.log`);
+}
+
+function readPidFile(port) {
+  const pidFile = getPidFile(port);
+  if (fs.existsSync(pidFile)) {
+    try {
+      const content = fs.readFileSync(pidFile, 'utf8').trim();
+      const lines = content.split('\n');
+      const pid = parseInt(lines[0], 10);
+      const rootDir = lines[1] || '';
+      return { pid, rootDir };
+    } catch (error) {
+      return null;
+    }
+  }
+  return null;
+}
+
+function writePidFile(port, pid, rootDir) {
+  const pidFile = getPidFile(port);
+  fs.writeFileSync(pidFile, `${pid}\n${rootDir}`);
+}
+
+function removePidFile(port) {
+  const pidFile = getPidFile(port);
+  if (fs.existsSync(pidFile)) {
+    fs.unlinkSync(pidFile);
+  }
+}
+
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+function startDaemon(options) {
+  ensureDirectories();
+
+  const rootDir = path.resolve(options.directory || process.cwd());
+  const port = options.port || DEFAULT_PORT;
+  const host = options.host || DEFAULT_HOST;
+
+  // Check if already running
+  const pidInfo = readPidFile(port);
+  if (pidInfo && isProcessRunning(pidInfo.pid)) {
+    console.error(`Error: Server already running on port ${port} (PID: ${pidInfo.pid})`);
+    console.error(`Serving: ${pidInfo.rootDir}`);
+    process.exit(1);
+  }
+
+  // Validate directory
+  let stats;
+  try {
+    stats = fs.statSync(rootDir);
+  } catch (error) {
+    console.error(`Error: directory "${rootDir}" does not exist or is not accessible.`);
+    process.exit(1);
+  }
+  if (!stats.isDirectory()) {
+    console.error(`Error: path "${rootDir}" is not a directory.`);
+    process.exit(1);
+  }
+
+  const logFile = getLogFile(port);
+  const out = fs.openSync(logFile, 'a');
+  const err = fs.openSync(logFile, 'a');
+
+  const child = spawn(process.execPath, [__filename, '--daemon-child', '-d', rootDir, '-p', String(port), '-H', host], {
+    detached: true,
+    stdio: ['ignore', out, err],
+    env: process.env
+  });
+
+  child.unref();
+
+  writePidFile(port, child.pid, rootDir);
+
+  console.log(`Server started in background (PID: ${child.pid})`);
+  console.log(`Serving: ${rootDir}`);
+  console.log(`Listening on port: ${port}`);
+  console.log(`Log file: ${logFile}`);
+  console.log(`\nTo stop: serve-here --stop -p ${port}`);
+}
+
+function stopDaemon(port) {
+  const pidInfo = readPidFile(port);
+  if (!pidInfo) {
+    console.error(`No server running on port ${port}`);
+    process.exit(1);
+  }
+
+  if (!isProcessRunning(pidInfo.pid)) {
+    console.log(`Server (PID: ${pidInfo.pid}) is not running, cleaning up...`);
+    removePidFile(port);
+    process.exit(0);
+  }
+
+  try {
+    process.kill(pidInfo.pid, 'SIGTERM');
+    console.log(`Stopping server (PID: ${pidInfo.pid})...`);
+
+    // Wait for process to stop
+    let attempts = 0;
+    const checkInterval = setInterval(() => {
+      attempts++;
+      if (!isProcessRunning(pidInfo.pid)) {
+        clearInterval(checkInterval);
+        removePidFile(port);
+        console.log('Server stopped.');
+        process.exit(0);
+      } else if (attempts >= 10) {
+        clearInterval(checkInterval);
+        console.error('Server did not stop gracefully, force killing...');
+        try {
+          process.kill(pidInfo.pid, 'SIGKILL');
+        } catch (e) {}
+        removePidFile(port);
+        process.exit(0);
+      }
+    }, 500);
+  } catch (error) {
+    console.error(`Failed to stop server: ${error.message}`);
+    removePidFile(port);
+    process.exit(1);
+  }
+}
+
+function showStatus(port) {
+  if (port) {
+    const pidInfo = readPidFile(port);
+    if (!pidInfo) {
+      console.log(`No server running on port ${port}`);
+      return;
+    }
+
+    const running = isProcessRunning(pidInfo.pid);
+    console.log(`Port ${port}:`);
+    console.log(`  PID: ${pidInfo.pid}`);
+    console.log(`  Status: ${running ? 'running' : 'stopped'}`);
+    console.log(`  Directory: ${pidInfo.rootDir}`);
+    console.log(`  Log: ${getLogFile(port)}`);
+
+    if (!running) {
+      removePidFile(port);
+    }
+  } else {
+    // Show all
+    ensureDirectories();
+    const files = fs.readdirSync(PID_DIR).filter(f => f.endsWith('.pid'));
+
+    if (files.length === 0) {
+      console.log('No servers running.');
+      return;
+    }
+
+    console.log('Running servers:\n');
+    for (const file of files) {
+      const match = file.match(/serve-here-(\d+)\.pid/);
+      if (match) {
+        const p = parseInt(match[1], 10);
+        const pidInfo = readPidFile(p);
+        if (pidInfo) {
+          const running = isProcessRunning(pidInfo.pid);
+          console.log(`Port ${p}:`);
+          console.log(`  PID: ${pidInfo.pid}`);
+          console.log(`  Status: ${running ? 'running' : 'stopped'}`);
+          console.log(`  Directory: ${pidInfo.rootDir}`);
+          console.log('');
+
+          if (!running) {
+            removePidFile(p);
+          }
+        }
+      }
+    }
+  }
+}
 
 function main() {
   try {
@@ -25,6 +225,22 @@ function main() {
       process.exit(0);
     }
 
+    // Handle daemon commands
+    if (options.stop) {
+      stopDaemon(options.port || DEFAULT_PORT);
+      return;
+    }
+
+    if (options.status) {
+      showStatus(options.port);
+      return;
+    }
+
+    if (options.daemon && !options.daemonChild) {
+      startDaemon(options);
+      return;
+    }
+
     const rootDir = path.resolve(options.directory || process.cwd());
 
     let stats;
@@ -44,8 +260,16 @@ function main() {
     const port = options.port || DEFAULT_PORT;
     const host = options.host || DEFAULT_HOST;
 
+    if (options.daemonChild) {
+      ensureDirectories();
+      process.on('exit', () => removePidFile(port));
+    }
+
     server.on('error', error => {
       console.error('Failed to start server:', error.message);
+      if (options.daemonChild) {
+        removePidFile(port);
+      }
       process.exit(1);
     });
 
@@ -56,10 +280,18 @@ function main() {
         ...formatListeningAddresses(host, port)
       ];
       console.log(messageLines.join('\n  '));
+
+      // Write PID file when running as daemon child
+      if (options.daemonChild) {
+        writePidFile(port, process.pid, rootDir);
+      }
     });
 
     const shutdown = () => {
       console.log('\nShutting down...');
+      if (options.daemonChild) {
+        removePidFile(port);
+      }
       server.close(() => process.exit(0));
     };
 
@@ -77,7 +309,11 @@ function parseArguments(args) {
     port: undefined,
     host: undefined,
     help: false,
-    version: false
+    version: false,
+    daemon: false,
+    daemonChild: false,
+    stop: false,
+    status: false
   };
 
   for (let i = 0; i < args.length; i += 1) {
@@ -105,6 +341,19 @@ function parseArguments(args) {
       case '--host':
         options.host = requireValue(args, ++i, '--host');
         break;
+      case '-D':
+      case '--daemon':
+        options.daemon = true;
+        break;
+      case '--daemon-child':
+        options.daemonChild = true;
+        break;
+      case '--stop':
+        options.stop = true;
+        break;
+      case '--status':
+        options.status = true;
+        break;
       default:
         if (arg.startsWith('-')) {
           throw new Error(`Unknown option: ${arg}`);
@@ -167,8 +416,19 @@ Options:
   -d, --dir <path>        Directory to serve (defaults to current working directory)
   -p, --port <number>     Port to listen on (default: ${DEFAULT_PORT})
   -H, --host <address>    Hostname or IP to bind (default: ${DEFAULT_HOST})
+  -D, --daemon            Run as a background daemon (does not occupy terminal)
+  --stop                  Stop a running daemon (use with -p to specify port)
+  --status                Show status of running daemon(s)
   -h, --help              Show this help message
-  -V, --version           Show version`);
+  -V, --version           Show version
+
+Examples:
+  serve-here                      Start server in foreground on port 8080
+  serve-here -D                   Start server as daemon on port 8080
+  serve-here -D -p 3000           Start daemon on port 3000
+  serve-here --stop               Stop daemon on port 8080
+  serve-here --stop -p 3000       Stop daemon on port 3000
+  serve-here --status             Show all running daemons`);
 }
 
 main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chenpu17/serve-here",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "A minimal CLI to serve static files from a directory over HTTP.",
   "bin": {
     "serve-here": "bin/serve-here.js"

package/src/server.js

@@ -30,127 +30,162 @@ function createStaticServer({
     ? resolvedRoot
     : `${resolvedRoot}${path.sep}`;
 
-  const server = http.createServer(async (req, res) => {
+  const server = http.createServer((req, res) => {
     const startTime = Date.now();
 
-    if (!req.url) {
-      sendError(res, 400, 'Bad Request');
-      return;
-    }
-
-    if (req.method !== 'GET' && req.method !== 'HEAD') {
-      res.setHeader('Allow', 'GET, HEAD');
-      sendError(res, 405, 'Method Not Allowed');
-      logRequest(logger, req, res.statusCode, startTime);
-      return;
-    }
+    void (async () => {
+      if (!req.url) {
+        sendError(res, 400, 'Bad Request', req.method === 'HEAD');
+        return;
+      }
 
-    let decodedPath;
-    try {
-      const url = new URL(req.url, 'http://localhost');
-      decodedPath = decodeURIComponent(url.pathname);
-    } catch (error) {
-      sendError(res, 400, 'Bad Request');
-      logRequest(logger, req, res.statusCode, startTime, error);
-      return;
-    }
+      if (req.method !== 'GET' && req.method !== 'HEAD') {
+        res.setHeader('Allow', 'GET, HEAD');
+        sendError(res, 405, 'Method Not Allowed', false);
+        logRequest(logger, req, res.statusCode, startTime);
+        return;
+      }
 
-    const candidateSegments = decodedPath
-      .split('/')
-      .filter(segment => segment && segment !== '.');
-    const resolvedPath = path.resolve(resolvedRoot, ...candidateSegments);
+      let decodedPath;
+      let requestPathname;
+      let requestSearch;
+      try {
+        const url = new URL(req.url, 'http://localhost');
+        requestPathname = url.pathname;
+        requestSearch = url.search;
+        decodedPath = decodeURIComponent(requestPathname);
+      } catch (error) {
+        sendError(res, 400, 'Bad Request', req.method === 'HEAD');
+        logRequest(logger, req, res.statusCode, startTime, error);
+        return;
+      }
 
-    if (!resolvedPath.startsWith(rootWithSep) && resolvedPath !== resolvedRoot) {
-      sendError(res, 403, 'Forbidden');
-      logRequest(logger, req, res.statusCode, startTime);
-      return;
-    }
+      const candidateSegments = decodedPath
+        .split('/')
+        .filter(segment => segment && segment !== '.');
+      const resolvedPath = path.resolve(resolvedRoot, ...candidateSegments);
 
-    let stats;
-    try {
-      stats = await stat(resolvedPath);
-    } catch (error) {
-      if (error.code === 'ENOENT') {
-        sendError(res, 404, 'Not Found');
-      } else {
-        sendError(res, 500, 'Internal Server Error');
-        logger.error('Error reading path', resolvedPath, error);
+      if (!resolvedPath.startsWith(rootWithSep) && resolvedPath !== resolvedRoot) {
+        sendError(res, 403, 'Forbidden', req.method === 'HEAD');
+        logRequest(logger, req, res.statusCode, startTime);
+        return;
       }
-      logRequest(logger, req, res.statusCode, startTime, error);
-      return;
-    }
 
-    if (stats.isDirectory()) {
-      if (!decodedPath.endsWith('/')) {
-        // Align with browser expectations for relative asset loading.
-        res.statusCode = 301;
-        res.setHeader('Location', `${decodedPath}/`);
-        res.end();
-        logRequest(logger, req, res.statusCode, startTime);
+      let stats;
+      try {
+        stats = await stat(resolvedPath);
+      } catch (error) {
+        if (error.code === 'ENOENT') {
+          sendError(res, 404, 'Not Found', req.method === 'HEAD');
+        } else {
+          sendError(res, 500, 'Internal Server Error', req.method === 'HEAD');
+          logger.error('Error reading path', resolvedPath, error);
+        }
+        logRequest(logger, req, res.statusCode, startTime, error);
         return;
       }
 
-      for (const indexFile of indexFiles) {
-        const candidate = path.join(resolvedPath, indexFile);
-        try {
-          const indexStats = await stat(candidate);
-          if (indexStats.isFile()) {
-            await serveFile(res, candidate, indexStats, req.method === 'HEAD');
+      if (stats.isDirectory()) {
+        if (!requestPathname.endsWith('/')) {
+          // Align with browser expectations for relative asset loading.
+          const location = `${requestPathname}/${requestSearch}`;
+          try {
+            // Use the encoded pathname for headers (Node rejects non-ASCII in Location).
+            res.statusCode = 301;
+            res.setHeader('Location', location);
+            res.end();
             logRequest(logger, req, res.statusCode, startTime);
             return;
+          } catch (error) {
+            sendError(res, 400, 'Bad Request', req.method === 'HEAD');
+            logRequest(logger, req, res.statusCode, startTime, error);
+            return;
           }
-        } catch (error) {
-          if (error.code !== 'ENOENT') {
-            logger.error('Error reading index file', candidate, error);
+        }
+
+        for (const indexFile of indexFiles) {
+          const candidate = path.join(resolvedPath, indexFile);
+          try {
+            const indexStats = await stat(candidate);
+            if (indexStats.isFile()) {
+              await serveFile(res, candidate, indexStats, req.method === 'HEAD');
+              logRequest(logger, req, res.statusCode, startTime);
+              return;
+            }
+          } catch (error) {
+            if (error.code !== 'ENOENT') {
+              logger.error('Error reading index file', candidate, error);
+            }
           }
         }
-      }
 
-      if (!enableDirectoryListing) {
-        sendError(res, 403, 'Directory listing disabled');
-        logRequest(logger, req, res.statusCode, startTime);
-        return;
+        if (!enableDirectoryListing) {
+          sendError(res, 403, 'Directory listing disabled', req.method === 'HEAD');
+          logRequest(logger, req, res.statusCode, startTime);
+          return;
+        }
+
+        try {
+          await serveDirectoryListing(
+            res,
+            decodedPath,
+            resolvedPath,
+            req.method === 'HEAD'
+          );
+          logRequest(logger, req, res.statusCode, startTime);
+          return;
+        } catch (error) {
+          sendError(res, 500, 'Internal Server Error', req.method === 'HEAD');
+          logger.error('Error generating directory listing', resolvedPath, error);
+          logRequest(logger, req, res.statusCode, startTime, error);
+          return;
+        }
       }
 
-      try {
-        await serveDirectoryListing(
-          res,
-          decodedPath,
-          resolvedPath,
-          req.method === 'HEAD'
-        );
+      if (stats.isFile()) {
+        try {
+          await serveFile(res, resolvedPath, stats, req.method === 'HEAD');
+        } catch (error) {
+          logger.error('Error serving file', resolvedPath, error);
+          // Stream errors may happen after headers were sent.
+        }
         logRequest(logger, req, res.statusCode, startTime);
         return;
-      } catch (error) {
-        sendError(res, 500, 'Internal Server Error');
-        logger.error('Error generating directory listing', resolvedPath, error);
-        logRequest(logger, req, res.statusCode, startTime, error);
-        return;
       }
-    }
 
-    if (stats.isFile()) {
-      try {
-        await serveFile(res, resolvedPath, stats, req.method === 'HEAD');
-      } catch (error) {
-        logger.error('Error serving file', resolvedPath, error);
-        // Stream errors may happen after headers were sent.
-      }
+      sendError(res, 403, 'Forbidden', req.method === 'HEAD');
       logRequest(logger, req, res.statusCode, startTime);
-      return;
-    }
-
-    sendError(res, 403, 'Forbidden');
-    logRequest(logger, req, res.statusCode, startTime);
+    })().catch(error => {
+      if (!res.headersSent) {
+        sendError(res, 500, 'Internal Server Error', req.method === 'HEAD');
+      } else {
+        res.destroy();
+      }
+      logger.error('Unhandled request error', error);
+      logRequest(logger, req, res.statusCode || 500, startTime, error);
+    });
   });
 
   return server;
 }
 
-function sendError(res, statusCode, message) {
+function sendError(res, statusCode, message, headOnly = false) {
+  if (res.headersSent) {
+    if (!res.writableEnded) {
+      res.end();
+    }
+    return;
+  }
+
   res.statusCode = statusCode;
   res.setHeader('Content-Type', 'text/plain; charset=utf-8');
   res.setHeader('Cache-Control', 'no-store');
+
+  if (headOnly) {
+    res.end();
+    return;
+  }
+
   res.end(`${statusCode} ${message}`);
 }
 
@@ -173,15 +208,51 @@ async function serveFile(res, filePath, stats, headOnly) {
 function streamFile(res, filePath) {
   return new Promise((resolve, reject) => {
     const stream = fs.createReadStream(filePath);
-    stream.on('error', error => {
+    let settled = false;
+
+    const settle = (fn, arg) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      fn(arg);
+    };
+
+    const onResponseClose = () => {
+      if (!stream.destroyed) {
+        stream.destroy();
+      }
+      settle(resolve);
+    };
+
+    const onResponseError = error => {
+      if (!stream.destroyed) {
+        stream.destroy(error);
+      }
+      settle(reject, error);
+    };
+
+    const onStreamError = error => {
       if (!res.headersSent) {
         sendError(res, 500, 'Internal Server Error');
       } else {
         res.destroy(error);
       }
-      reject(error);
-    });
-    stream.on('end', resolve);
+      settle(reject, error);
+    };
+
+    const onStreamEnd = () => settle(resolve);
+
+    const cleanup = () => {
+      res.removeListener('close', onResponseClose);
+      res.removeListener('error', onResponseError);
+      stream.removeListener('error', onStreamError);
+      stream.removeListener('end', onStreamEnd);
+    };
+
+    res.on('close', onResponseClose);
+    res.on('error', onResponseError);
+    stream.on('error', onStreamError);
+    stream.on('end', onStreamEnd);
     stream.pipe(res);
   });
 }