srv-it 0.1.1

package/README.md

@@ -0,0 +1,95 @@
+# srv-it
+
+`srv-it` installs a `srv` command and merges the best parts of `live-server` and `serve`:
+
+- one-command static server from any folder
+- polished terminal UX
+- live DOM reload and CSS refresh
+- directory listing with customizable page style
+- simple defaults via config files
+
+## Quick start
+
+```bash
+npm install -g srv-it
+```
+
+Then run:
+
+```bash
+cd your-project
+srv
+```
+
+This serves the current directory on port `3000`.
+
+## Common usage
+
+```bash
+srv
+srv 3000
+srv 8080 ./public
+srv ./public --open
+srv --style neon --style-css ./srv-listing.css
+```
+
+## Config defaults
+
+You can set defaults globally and per-project:
+
+- global: `~/.srvrc.json`
+- project: `./srv.config.json`
+- override file: `srv --config ./my-srv.json`
+- template: `./srv.config.example.json`
+
+Example `srv.config.json`:
+
+```json
+{
+  "port": 3000,
+  "host": "0.0.0.0",
+  "open": false,
+  "single": true,
+  "cors": true,
+  "style": "midnight",
+  "directoryListing": true,
+  "noCssInject": false,
+  "logLevel": 2,
+  "noRequestLogging": false,
+  "ignore": ["**/.git/**", "**/node_modules/**"]
+}
+```
+
+CLI flags always override config files.
+
+## CLI options
+
+Run:
+
+```bash
+srv --help
+```
+
+Highlights:
+
+- `-p, --port <number>`
+- `--host <host>`
+- `--open [path]`, `--no-open`
+- `--watch <path>` (repeat)
+- `--ignore <glob>` (repeat)
+- `--single`
+- `--cors`
+- `--no-css-inject`
+- `--no-dir-listing`
+- `--style <midnight|paper|neon>`
+- `--style-css <file>`
+- `-c` (create `srv.config.json` in served root if missing)
+- `--log-level <0-3>`
+- `--no-request-logging`
+- `--ssl-cert <file> --ssl-key <file> [--ssl-pass <file>]`
+
+## Notes
+
+- HTML pages get an auto-injected websocket client for live reload.
+- CSS changes refresh styles without full page reload unless `--no-css-inject` is enabled.
+- If a folder has `index.html`, that file is served; otherwise a styled directory listing is shown.

package/bin/srv.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+const { run } = require('../src/cli');
+
+run().catch((error) => {
+  console.error(error.message || String(error));
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "srv-it",
+  "version": "0.1.1",
+  "description": "Static server with polished CLI UI, directory listing, and live reload",
+  "keywords": [
+    "server",
+    "static",
+    "live-reload",
+    "directory-listing",
+    "cli"
+  ],
+  "homepage": "https://github.com/elouan/srv-it",
+  "bugs": {
+    "url": "https://github.com/elouan/srv-it/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/elouan/srv-it.git"
+  },
+  "license": "MIT",
+  "author": "Elouan Grimm",
+  "type": "commonjs",
+  "main": "./src/cli.js",
+  "bin": {
+    "srv-it": "bin/srv.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "node ./bin/srv.js",
+    "test": "node ./bin/srv.js --help"
+  },
+  "dependencies": {
+    "arg": "^5.0.2",
+    "boxen": "^7.1.1",
+    "chalk": "^4.1.2",
+    "chokidar": "^3.6.0",
+    "compression": "^1.8.1",
+    "mime-types": "^2.1.35",
+    "open": "^10.1.2",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {},
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "preferGlobal": true
+}

package/src/cli.js

@@ -0,0 +1,236 @@
+const path = require('node:path');
+const fs = require('node:fs');
+const arg = require('arg');
+const chalk = require('chalk');
+const boxenModule = require('boxen');
+const openModule = require('open');
+const { loadConfig } = require('./config');
+const { createSrvServer } = require('./server');
+const pkg = require('../package.json');
+
+const boxen = boxenModule.default || boxenModule;
+const open = openModule.default || openModule;
+
+function isNumeric(value) {
+  return /^\d+$/.test(String(value));
+}
+
+function getHelpText() {
+  return [
+    'srv - static server + directory listing + live reload',
+    '',
+    'USAGE',
+    '  srv                          Serve current directory on port 3000',
+    '  srv 4000                     Serve current directory on port 4000',
+    '  srv 4000 ./public            Serve ./public on port 4000',
+    '  srv ./public                 Serve ./public on port 3000',
+    '',
+    'OPTIONS',
+    '  -h, --help                   Show help',
+    '  -v, --version                Show version',
+    '  -p, --port <number>          Port to listen on',
+    '  --host <host>                Host to bind to (default 0.0.0.0)',
+    '  --open [path]                Open browser (default /)',
+    '  --no-open                    Do not open browser',
+    '  --watch <path>               Extra watch path (can be repeated)',
+    '  --ignore <glob>              Ignore glob/path for watcher (repeatable)',
+    '  --no-css-inject              Reload page on css changes instead of hot css refresh',
+    '  --cors                       Enable CORS',
+    '  --single                     SPA fallback to /index.html',
+    '  --no-dir-listing             Disable directory listing',
+    '  --style <name>               Listing style preset: midnight | paper | neon',
+    '  --style-css <file>           Custom CSS file for listing page',
+    '  -c                           Create srv.config.json in served root if missing',
+    '  --config <file>              Read additional config JSON file',
+    '  --no-request-logging         Disable request logs',
+    '  --log-level <0-3>            Startup log verbosity',
+    '  --ssl-cert <file>            SSL certificate path',
+    '  --ssl-key <file>             SSL private key path',
+    '  --ssl-pass <file>            SSL passphrase file path',
+    '',
+    'CONFIG FILES',
+    '  ~/.srvrc.json (global defaults)',
+    '  ./srv.config.json (project defaults)',
+    '',
+    'CLI options always override config values.',
+  ].join('\n');
+}
+
+function parseCli() {
+  const parsed = arg(
+    {
+      '--help': Boolean,
+      '--version': Boolean,
+      '--port': Number,
+      '--host': String,
+      '--open': String,
+      '--no-open': Boolean,
+      '--watch': [String],
+      '--ignore': [String],
+      '--no-css-inject': Boolean,
+      '--cors': Boolean,
+      '--single': Boolean,
+      '--no-dir-listing': Boolean,
+      '--style': String,
+      '--style-css': String,
+      '-c': Boolean,
+      '--config': String,
+      '--no-request-logging': Boolean,
+      '--log-level': Number,
+      '--ssl-cert': String,
+      '--ssl-key': String,
+      '--ssl-pass': String,
+      '-h': '--help',
+      '-v': '--version',
+      '-p': '--port',
+    },
+    {
+      permissive: true,
+    },
+  );
+
+  return parsed;
+}
+
+function resolveOptions(parsed, mergedConfig) {
+  const positional = parsed._.slice();
+
+  let positionalPort;
+  let positionalRoot;
+  if (positional.length > 0) {
+    if (isNumeric(positional[0])) {
+      positionalPort = Number(positional.shift());
+    }
+    if (positional.length > 0) {
+      positionalRoot = positional.shift();
+    }
+  }
+
+  const options = {
+    port:
+      parsed['--port'] ?? positionalPort ?? mergedConfig.port ?? Number(process.env.PORT || 3000),
+    host: parsed['--host'] ?? mergedConfig.host ?? '0.0.0.0',
+    root: path.resolve(positionalRoot || mergedConfig.root || process.cwd()),
+    open:
+      parsed['--no-open']
+        ? false
+        : parsed['--open'] || mergedConfig.open === false
+          ? parsed['--open'] || mergedConfig.open
+          : '/',
+    watch: parsed['--watch'] ?? mergedConfig.watch ?? [],
+    ignore: parsed['--ignore'] ?? mergedConfig.ignore ?? [],
+    noCssInject: parsed['--no-css-inject'] ?? Boolean(mergedConfig.noCssInject),
+    cors: parsed['--cors'] ?? Boolean(mergedConfig.cors),
+    single: parsed['--single'] ?? Boolean(mergedConfig.single),
+    directoryListing:
+      parsed['--no-dir-listing']
+        ? false
+        : mergedConfig.directoryListing !== undefined
+          ? Boolean(mergedConfig.directoryListing)
+          : true,
+    style: parsed['--style'] ?? mergedConfig.style ?? 'midnight',
+    styleCss: parsed['--style-css'] ?? mergedConfig.styleCss,
+    noRequestLogging:
+      parsed['--no-request-logging'] ?? Boolean(mergedConfig.noRequestLogging),
+    logLevel: parsed['--log-level'] ?? mergedConfig.logLevel ?? 2,
+    sslCert: parsed['--ssl-cert'] ?? mergedConfig.sslCert,
+    sslKey: parsed['--ssl-key'] ?? mergedConfig.sslKey,
+    sslPass: parsed['--ssl-pass'] ?? mergedConfig.sslPass,
+    createConfig: Boolean(parsed['-c']),
+  };
+
+  return options;
+}
+
+async function run() {
+  const parsed = parseCli();
+
+  if (parsed['--help']) {
+    console.log(getHelpText());
+    return;
+  }
+
+  if (parsed['--version']) {
+    console.log(pkg.version);
+    return;
+  }
+
+  const { config } = loadConfig({
+    cwd: process.cwd(),
+    explicitConfigPath: parsed['--config'],
+  });
+
+  const options = resolveOptions(parsed, config);
+  let configCreated = false;
+
+  if (options.createConfig) {
+    const configFilePath = path.join(options.root, 'srv.config.json');
+    if (!fs.existsSync(configFilePath)) {
+      const template = {
+        port: 3000,
+        host: '0.0.0.0',
+        root: '.',
+        open: false,
+        watch: [],
+        ignore: ['**/.git/**', '**/node_modules/**'],
+        noCssInject: false,
+        cors: false,
+        single: false,
+        directoryListing: true,
+        style: 'midnight',
+        styleCss: '',
+        noRequestLogging: false,
+        logLevel: 2,
+        sslCert: '',
+        sslKey: '',
+        sslPass: '',
+      };
+      fs.writeFileSync(configFilePath, `${JSON.stringify(template, null, 2)}\n`, 'utf8');
+      configCreated = true;
+    }
+  }
+
+  const server = await createSrvServer(options);
+  const protocol = options.sslCert ? 'https' : 'http';
+  const visibleHost = options.host === '0.0.0.0' ? 'localhost' : options.host;
+  const url = `${protocol}://${visibleHost}:${server.port}`;
+
+  if (options.logLevel >= 1) {
+    const lines = [
+      `${chalk.green.bold('srv is running')}`,
+      '',
+      `${chalk.bold('- Local:')}    ${url}`,
+      `${chalk.bold('- Root:')}     ${options.root}`,
+      `${chalk.bold('- Reload:')}   ${options.noCssInject ? 'full page' : 'css + page'}`,
+    ];
+
+    if (server.network) {
+      lines.splice(3, 0, `${chalk.bold('- Network:')}  ${server.network}`);
+    }
+
+    if (configCreated) {
+      lines.push(`${chalk.bold('- Config:')}   ${path.join(options.root, 'srv.config.json')}`);
+    }
+
+    const content = [
+      ...lines,
+    ].join('\n');
+
+    console.log(
+      boxen(content, {
+        padding: 1,
+        borderStyle: 'single',
+        borderColor: 'cyan',
+      }),
+    );
+  }
+
+  if (options.open !== false) {
+    const openPath = typeof options.open === 'string' ? options.open : '/';
+    await open(`${url}${openPath.startsWith('/') ? openPath : `/${openPath}`}`);
+  }
+}
+
+module.exports = {
+  run,
+};

package/src/config.js

@@ -0,0 +1,41 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+function readJsonIfExists(filePath) {
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const parsed = JSON.parse(raw);
+    return typeof parsed === 'object' && parsed ? parsed : {};
+  } catch (error) {
+    if (error && error.code === 'ENOENT') {
+      return {};
+    }
+    throw new Error(`Failed to parse config at ${filePath}: ${error.message}`);
+  }
+}
+
+function loadConfig({ cwd, explicitConfigPath }) {
+  const globalPath = path.join(os.homedir(), '.srvrc.json');
+  const localPath = path.join(cwd, 'srv.config.json');
+
+  const globalConfig = readJsonIfExists(globalPath);
+  const localConfig = readJsonIfExists(localPath);
+  const explicitConfig = explicitConfigPath
+    ? readJsonIfExists(path.resolve(explicitConfigPath))
+    : {};
+
+  return {
+    globalPath,
+    localPath,
+    config: {
+      ...globalConfig,
+      ...localConfig,
+      ...explicitConfig,
+    },
+  };
+}
+
+module.exports = {
+  loadConfig,
+};

package/src/server.js

@@ -0,0 +1,483 @@
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const path = require('node:path');
+const http = require('node:http');
+const https = require('node:https');
+const { pipeline } = require('node:stream/promises');
+const chokidar = require('chokidar');
+const compression = require('compression');
+const mime = require('mime-types');
+const os = require('node:os');
+const chalk = require('chalk');
+const { WebSocketServer } = require('ws');
+
+const LIVE_RELOAD_SNIPPET = `\n<script>\n(function(){\n  if(!('WebSocket' in window)) return;\n  function refreshCSS(){\n    var links=[].slice.call(document.querySelectorAll('link[rel="stylesheet"],link:not([rel])'));\n    links.forEach(function(link){\n      var href=link.getAttribute('href');\n      if(!href) return;\n      var u=href.replace(/([?&])_srv=\\d+/,'').replace(/[?&]$/,'');\n      var join=u.indexOf('?')>-1?'&':'?';\n      link.setAttribute('href',u+join+'_srv='+Date.now());\n    });\n  }\n  var proto=location.protocol==='https:'?'wss':'ws';\n  var socket=new WebSocket(proto+'://'+location.host+'/__srv_ws');\n  socket.onmessage=function(event){\n    if(event.data==='refreshcss') refreshCSS();\n    if(event.data==='reload') location.reload();\n  };\n})();\n</script>\n`;
+
+const STYLE_PRESETS = {
+  midnight: {
+    accent: '#3b82f6',
+    borderStrong: '#78716c',
+  },
+  paper: {
+    accent: '#f59e0b',
+    borderStrong: '#a8a29e',
+  },
+  neon: {
+    accent: '#22c55e',
+    borderStrong: '#a8a29e',
+  },
+};
+
+function getNetworkAddress() {
+  const interfaces = os.networkInterfaces();
+  for (const networkInterface of Object.values(interfaces)) {
+    if (!networkInterface) {
+      continue;
+    }
+    for (const details of networkInterface) {
+      if (details.family === 'IPv4' && !details.internal) {
+        return details.address;
+      }
+    }
+  }
+  return undefined;
+}
+
+function toSafePathname(urlValue) {
+  try {
+    return decodeURIComponent(new URL(urlValue, 'http://srv.local').pathname);
+  } catch (_error) {
+    return '/';
+  }
+}
+
+function resolvePath(root, pathnameValue) {
+  const cleaned = pathnameValue.replace(/\\0/g, '');
+  const absolute = path.resolve(root, `.${cleaned}`);
+  if (!absolute.startsWith(root)) {
+    return null;
+  }
+  return absolute;
+}
+
+function injectReload(html) {
+  const candidates = ['</body>', '</head>', '</svg>'];
+  for (const tag of candidates) {
+    const index = html.toLowerCase().lastIndexOf(tag);
+    if (index !== -1) {
+      return html.slice(0, index) + LIVE_RELOAD_SNIPPET + html.slice(index);
+    }
+  }
+  return html + LIVE_RELOAD_SNIPPET;
+}
+
+function renderDirListing({ pathnameValue, entries, style, customCss }) {
+  const palette = STYLE_PRESETS[style] || STYLE_PRESETS.midnight;
+  const base = pathnameValue.endsWith('/') ? pathnameValue : `${pathnameValue}/`;
+
+  const list = entries
+    .map((entry) => {
+      const suffix = entry.isDirectory() ? '/' : '';
+      const href = encodeURIComponent(entry.name).replace(/%2F/g, '/') + suffix;
+      return `<li><a href="${href}"><span class="name">${entry.name}${suffix}</span><span class="type">${entry.isDirectory() ? 'dir' : 'file'}</span></a></li>`;
+    })
+    .join('');
+
+  const up = pathnameValue !== '/' ? '<a class="up" href="..">Go up</a>' : '';
+
+  return `<!doctype html>
+<html>
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width,initial-scale=1" />
+  <title>Index of ${pathnameValue}</title>
+  <style>
+    :root {
+      --stone-050: #fafaf9;
+      --stone-100: #f5f5f4;
+      --stone-200: #e7e5e4;
+      --stone-300: #d6d3d1;
+      --stone-400: #a8a29e;
+      --stone-500: #78716c;
+      --stone-600: #57534e;
+      --stone-700: #44403c;
+      --stone-800: #292524;
+      --stone-900: #1c1917;
+      --stone-950: #0c0a09;
+
+      --bg: var(--stone-950);
+      --bg-raised: var(--stone-900);
+      --bg-surface: var(--stone-800);
+      --border: var(--stone-800);
+      --border-strong: ${palette.borderStrong};
+      --text: var(--stone-200);
+      --text-muted: var(--stone-400);
+      --text-faint: var(--stone-500);
+      --text-bright: var(--stone-100);
+      --accent: ${palette.accent};
+      --font-sans: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+      --font-mono: "JetBrains Mono", "SF Mono", "Fira Code", "Roboto Mono", "Cascadia Code", monospace;
+      --line-height: 1.6;
+      --line-height-tight: 1.2;
+    }
+
+    * {
+      margin: 0;
+      padding: 0;
+      box-sizing: border-box;
+      border-radius: 0 !important;
+    }
+
+    body {
+      background-color: var(--bg);
+      color: var(--text);
+      font-family: var(--font-sans);
+      line-height: var(--line-height);
+      min-height: 100vh;
+      padding: 2rem;
+    }
+
+    main {
+      display: block;
+      max-width: 900px;
+      margin: 0 auto;
+      padding: 1rem;
+      background-color: var(--bg-raised);
+      border: 1px solid var(--border);
+    }
+
+    h1 {
+      margin-bottom: 0.25rem;
+      color: var(--text-bright);
+      font-family: var(--font-mono);
+      font-size: 1.1rem;
+      line-height: var(--line-height-tight);
+      text-transform: uppercase;
+      letter-spacing: 0.04em;
+    }
+
+    .path {
+      margin-bottom: 0.75rem;
+      color: var(--text-muted);
+      font-family: var(--font-mono);
+      font-size: 0.9rem;
+    }
+
+    .up {
+      display: inline-block;
+      margin-bottom: 0.75rem;
+      color: var(--accent);
+      text-decoration: none;
+      border: 1px solid var(--border-strong);
+      padding: 0.3rem 0.55rem;
+      font-family: var(--font-mono);
+      transition: background-color 0.18s ease, color 0.18s ease;
+    }
+
+    .up:hover {
+      background-color: var(--accent);
+      color: var(--bg);
+    }
+
+    ul {
+      list-style: none;
+      border: 1px solid var(--border);
+    }
+
+    li a {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      width: 100%;
+      padding: 0.65rem 0.75rem;
+      text-decoration: none;
+      color: var(--text);
+      border-bottom: 1px solid var(--border);
+      font-family: var(--font-mono);
+      transition: background-color 0.18s ease, color 0.18s ease;
+    }
+
+    li:last-child a {
+      border-bottom: 0;
+    }
+
+    li a:hover {
+      background-color: var(--bg-surface);
+      color: var(--text-bright);
+    }
+
+    .name {
+      max-width: 80%;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+
+    .type {
+      color: var(--text-faint);
+      text-transform: uppercase;
+      font-size: 0.72rem;
+      letter-spacing: 0.07em;
+    }
+
+    @media (max-width: 768px) {
+      body {
+        padding: 1rem;
+      }
+
+      main {
+        padding: 0.8rem;
+      }
+
+      li a {
+        padding: 0.55rem 0.6rem;
+      }
+    }
+
+    ${customCss || ''}
+  </style>
+</head>
+<body>
+  <main>
+    <h1>srv</h1>
+    <div class="path">Index of ${base}</div>
+    ${up}
+    <ul>${list}</ul>
+  </main>
+</body>
+</html>`;
+}
+
+function getCompressionMiddleware() {
+  const middleware = compression();
+  return (req, res) =>
+    new Promise((resolve, reject) => {
+      middleware(req, res, (error) => {
+        if (error) reject(error);
+        else resolve();
+      });
+    });
+}
+
+async function createSrvServer(options) {
+  const root = path.resolve(options.root);
+  const compress = getCompressionMiddleware();
+  const clients = new Set();
+
+  let customCss = '';
+  if (options.styleCss) {
+    customCss = await fsp.readFile(path.resolve(options.styleCss), 'utf8');
+  }
+
+  const requestHandler = async (req, res) => {
+    const start = Date.now();
+    const method = req.method || 'GET';
+    const pathnameValue = toSafePathname(req.url || '/');
+
+    try {
+      if (options.cors) {
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Headers', '*');
+        res.setHeader('Access-Control-Allow-Credentials', 'true');
+      }
+
+      if (req.method === 'OPTIONS') {
+        res.statusCode = 204;
+        res.end();
+        return;
+      }
+
+      await compress(req, res);
+
+      let filePath = resolvePath(root, pathnameValue);
+      if (!filePath) {
+        res.statusCode = 403;
+        res.end('Forbidden');
+        return;
+      }
+
+      let stat;
+      try {
+        stat = await fsp.stat(filePath);
+      } catch (error) {
+        if (options.single) {
+          filePath = path.join(root, 'index.html');
+          stat = await fsp.stat(filePath);
+        } else {
+          res.statusCode = 404;
+          res.end('Not found');
+          return;
+        }
+      }
+
+      if (stat.isDirectory()) {
+        const indexPath = path.join(filePath, 'index.html');
+        try {
+          const indexStat = await fsp.stat(indexPath);
+          if (indexStat.isFile()) {
+            filePath = indexPath;
+            stat = indexStat;
+          }
+        } catch (_error) {
+          if (!options.directoryListing) {
+            res.statusCode = 404;
+            res.end('Not found');
+            return;
+          }
+
+          const entries = await fsp.readdir(filePath, { withFileTypes: true });
+          entries.sort((a, b) => {
+            if (a.isDirectory() && !b.isDirectory()) return -1;
+            if (!a.isDirectory() && b.isDirectory()) return 1;
+            return a.name.localeCompare(b.name);
+          });
+
+          const html = renderDirListing({
+            pathnameValue,
+            entries,
+            style: options.style,
+            customCss,
+          });
+          res.setHeader('content-type', 'text/html; charset=utf-8');
+          res.statusCode = 200;
+          res.end(injectReload(html));
+          return;
+        }
+      }
+
+      if (!stat.isFile()) {
+        res.statusCode = 404;
+        res.end('Not found');
+        return;
+      }
+
+      const ext = path.extname(filePath).toLowerCase();
+      const contentType = mime.contentType(ext) || 'application/octet-stream';
+      res.setHeader('content-type', contentType);
+      res.setHeader('cache-control', 'no-cache');
+
+      if (['.html', '.htm', '.xhtml', '.php', '.svg'].includes(ext)) {
+        const raw = await fsp.readFile(filePath, 'utf8');
+        const html = injectReload(raw);
+        res.statusCode = 200;
+        res.end(html);
+        return;
+      }
+
+      res.statusCode = 200;
+      await pipeline(fs.createReadStream(filePath), res);
+    } catch (error) {
+      res.statusCode = 500;
+      res.end('Internal server error');
+      if (options.logLevel >= 1) {
+        console.error('[srv] request error:', error.message);
+      }
+    } finally {
+      if (!options.noRequestLogging) {
+        const statusCode = res.statusCode;
+        const elapsed = Date.now() - start;
+        const sourceIp = (req.socket.remoteAddress || '-').replace('::ffff:', '');
+        const now = new Date();
+        const formattedTime = `${now.toLocaleDateString()} ${now.toLocaleTimeString()}`;
+        const methodColor = method === 'GET' ? 'cyan' : 'magenta';
+
+        console.log(
+          chalk.dim(formattedTime),
+          chalk.yellow(sourceIp),
+          chalk[methodColor](`${method} ${pathnameValue}`),
+          chalk[statusCode < 400 ? 'green' : 'red'](`-> ${statusCode} (${elapsed}ms)`),
+        );
+      }
+    }
+  };
+
+  const useSsl = options.sslCert && options.sslKey;
+  let server;
+
+  if (useSsl) {
+    const cert = await fsp.readFile(path.resolve(options.sslCert));
+    const key = await fsp.readFile(path.resolve(options.sslKey));
+    const passphrase = options.sslPass
+      ? await fsp.readFile(path.resolve(options.sslPass), 'utf8')
+      : undefined;
+    server = https.createServer({ cert, key, passphrase }, (req, res) => {
+      requestHandler(req, res).catch((error) => {
+        res.statusCode = 500;
+        res.end('Internal server error');
+        if (options.logLevel >= 1) {
+          console.error('[srv] handler error:', error.message);
+        }
+      });
+    });
+  } else {
+    server = http.createServer((req, res) => {
+      requestHandler(req, res).catch((error) => {
+        res.statusCode = 500;
+        res.end('Internal server error');
+        if (options.logLevel >= 1) {
+          console.error('[srv] handler error:', error.message);
+        }
+      });
+    });
+  }
+
+  const wss = new WebSocketServer({ server, path: '/__srv_ws' });
+  wss.on('connection', (socket) => {
+    clients.add(socket);
+    socket.on('close', () => clients.delete(socket));
+  });
+
+  const watchPaths = [root, ...(options.watch || []).map((x) => path.resolve(x))];
+  const watcher = chokidar.watch(watchPaths, {
+    ignoreInitial: true,
+    ignored: options.ignore && options.ignore.length > 0 ? options.ignore : undefined,
+  });
+
+  const sendReload = (changePath) => {
+    const isCss = path.extname(changePath).toLowerCase() === '.css' && !options.noCssInject;
+    const message = isCss ? 'refreshcss' : 'reload';
+    for (const client of clients) {
+      if (client.readyState === 1) {
+        client.send(message);
+      }
+    }
+    if (options.logLevel >= 2) {
+      console.log(`[srv] ${isCss ? 'css refresh' : 'reload'}: ${changePath}`);
+    }
+  };
+
+  watcher.on('change', sendReload);
+  watcher.on('add', sendReload);
+  watcher.on('unlink', sendReload);
+  watcher.on('addDir', sendReload);
+  watcher.on('unlinkDir', sendReload);
+
+  const closeAll = async () => {
+    await watcher.close();
+    wss.close();
+    await new Promise((resolve) => server.close(resolve));
+  };
+
+  process.on('SIGINT', async () => {
+    console.log('\n[srv] shutting down...');
+    await closeAll();
+    process.exit(0);
+  });
+
+  await new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(options.port, options.host, resolve);
+  });
+
+  const address = server.address();
+  const port = typeof address === 'object' && address ? address.port : options.port;
+  const networkIp = getNetworkAddress();
+  const protocol = useSsl ? 'https' : 'http';
+  const network = networkIp ? `${protocol}://${networkIp}:${port}` : undefined;
+
+  return { server, port, closeAll, network };
+}
+
+module.exports = {
+  createSrvServer,
+};