busyserver 1.0.0

package/src/server.js

@@ -0,0 +1,734 @@
+const os = require("os");
+const http = require("http");
+const path = require("path");
+const fs = require("fs");
+const { execFile } = require("child_process");
+const { WebSocketServer } = require("ws");
+const { startWatcher } = require("./watcher");
+const zlib = require("zlib");
+const qrcode = require("qrcode-terminal");
+// ── Colors ──────────────────────────────────────────
+
+const c = process.stdout.isTTY
+  ? {
+      r: "\x1b[0m",
+      dim: "\x1b[2m",
+      bold: "\x1b[1m",
+      green: "\x1b[32m",
+      cyan: "\x1b[36m",
+      yellow: "\x1b[33m",
+      red: "\x1b[31m",
+      magenta: "\x1b[35m",
+    }
+  : { r: "", dim: "", bold: "", green: "", cyan: "", yellow: "", red: "", magenta: "" };
+
+// ── MIME Types ───────────────────────────────────────
+
+const MIME_TYPES = {
+  ".html": "text/html; charset=utf-8",
+  ".htm": "text/html; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".js": "text/javascript; charset=utf-8",
+  ".mjs": "text/javascript; charset=utf-8",
+  ".cjs": "text/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".xml": "application/xml; charset=utf-8",
+  ".txt": "text/plain; charset=utf-8",
+  ".md": "text/markdown; charset=utf-8",
+  ".csv": "text/csv; charset=utf-8",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".ogg": "audio/ogg",
+  ".flac": "audio/flac",
+  ".aac": "audio/aac",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".ogv": "video/ogg",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".eot": "application/vnd.ms-fontobject",
+  ".wasm": "application/wasm",
+  ".map": "application/json",
+  ".pdf": "application/pdf",
+  ".zip": "application/zip",
+  ".gz": "application/gzip",
+  ".tar": "application/x-tar",
+};
+
+// ── Utilities ───────────────────────────────────────
+
+function getContentType(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return MIME_TYPES[ext] || "application/octet-stream";
+}
+
+function isHtmlType(contentType) {
+  return contentType.startsWith("text/html");
+}
+
+function isCompressible(contentType) {
+  return /text|javascript|json|xml|svg/i.test(contentType);
+}
+
+
+
+function getNetworkAddress() {
+  try {
+    const interfaces = os.networkInterfaces();
+    for (const name of Object.keys(interfaces)) {
+      for (const net of interfaces[name] || []) {
+        if (net.family === "IPv4" && !net.internal) {
+          return net.address;
+        }
+      }
+    }
+  } catch {
+    // Network info unavailable
+  }
+  return null;
+}
+
+function makeEtag(stat) {
+  return `"${stat.mtimeMs.toString(36)}-${stat.size.toString(36)}"`;
+}
+
+function shortenPath(fullPath) {
+  const home = os.homedir();
+  if (fullPath.startsWith(home)) {
+    return "~" + fullPath.slice(home.length);
+  }
+  return fullPath;
+}
+
+function formatMs(ms) {
+  if (ms < 1000) return `${ms}ms`;
+  return `${(ms / 1000).toFixed(1)}s`;
+}
+
+// ── HTML Templates ──────────────────────────────────
+
+const { getErrorPage, getDirectoryListing, injectLiveReload } = require("./templates");
+
+// ── Port Management ─────────────────────────────────
+
+function listenOnPort(server, port, host) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+
+    const onError = (error) => {
+      if (settled) return;
+      settled = true;
+      server.removeListener("listening", onListening);
+      reject(error);
+    };
+
+    const onListening = () => {
+      if (settled) return;
+      settled = true;
+      server.removeListener("error", onError);
+      resolve(server.address().port);
+    };
+
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(port, host);
+  });
+}
+
+// ── Browser Opening ─────────────────────────────────
+
+function openBrowser(url) {
+  const isTermux = process.env.PREFIX && process.env.PREFIX.includes("com.termux");
+  let cmd, args;
+
+  if (isTermux) {
+    cmd = "termux-open-url";
+    args = [url];
+  } else if (process.platform === "darwin") {
+    cmd = "open";
+    args = [url];
+  } else if (process.platform === "win32") {
+    cmd = "cmd";
+    args = ["/c", "start", url];
+  } else {
+    cmd = "xdg-open";
+    args = [url];
+  }
+
+  try {
+    const child = execFile(cmd, args, { stdio: "ignore" });
+    child.unref();
+    child.on("error", () => {
+      // Silently fail - URL is printed anyway
+    });
+  } catch {
+    // Browser opening unavailable
+  }
+}
+
+// ── Security ────────────────────────────────────────
+
+function isPathSafe(filePath, root) {
+  // Must be within root
+  if (filePath !== root && !filePath.startsWith(root + path.sep)) {
+    return false;
+  }
+  return true;
+}
+
+function hasNullByte(str) {
+  return str.includes("\0");
+}
+
+function hasDotSegment(urlPath) {
+  // Check if any path segment starts with a dot (hidden files/dirs)
+  const segments = urlPath.split("/");
+  for (const seg of segments) {
+    if (seg.startsWith(".") && seg !== "." && seg !== "..") {
+      return true;
+    }
+  }
+  return false;
+}
+
+// ── Request Logger ──────────────────────────────────
+
+function logRequest(method, urlPath, statusCode, startTime, quiet) {
+  if (quiet) return;
+
+  const elapsed = Date.now() - startTime;
+  const methodStr = method.padEnd(5);
+
+  let statusColor = c.green;
+  if (statusCode >= 400) statusColor = c.yellow;
+  if (statusCode >= 500) statusColor = c.red;
+
+  const pathDisplay = urlPath.length > 40
+    ? urlPath.slice(0, 37) + "..."
+    : urlPath;
+
+  console.log(
+    `  ${c.dim}${methodStr}${c.r} ${pathDisplay.padEnd(42)} ${statusColor}${statusCode}${c.r}  ${c.dim}${formatMs(elapsed)}${c.r}`
+  );
+}
+
+// ── Main Server ─────────────────────────────────────
+
+/**
+ * Start the BusyServer server.
+ *
+ * @param {Object} options
+ * @param {string} options.root - Directory to serve
+ * @param {number} options.port - Port number
+ * @param {string} options.host - Host to bind to
+ * @param {boolean} options.autoPort - Auto-find available port
+ * @param {boolean} options.reload - Enable live reload
+ * @param {boolean} options.watch - Enable file watching
+ * @param {boolean} options.open - Open browser
+ * @param {boolean} options.spa - SPA fallback mode
+ * @param {boolean} options.quiet - Suppress request logging
+ * @param {boolean} options.qr - Show QR code
+ * @param {string[]} options.ignore - Additional ignore patterns
+ */
+async function startBusyServer(options = {}) {
+  const root = options.root || process.cwd();
+  const port = options.port != null ? options.port : 3000;
+  const host = options.host || "0.0.0.0";
+  const autoPort = options.autoPort !== false;
+  const reloadEnabled = options.reload !== false;
+  const watchEnabled = options.watch !== false;
+  const spaMode = options.spa === true;
+  const quiet = options.quiet === true;
+  const openBrowserOnStart = options.open === true;
+  const showQr = options.qr === true;
+  const ignorePatterns = options.ignore || [];
+
+  // Read version
+  let version = "1.0.0";
+  try {
+    const pkg = require("../package.json");
+    version = pkg.version || version;
+  } catch {
+    // package.json not found
+  }
+
+  // ── Create HTTP Server ──
+
+  const handler = async (req, res) => {
+    const startTime = Date.now();
+    let statusCode = 200;
+
+    try {
+      if (options.headers) {
+        for (const [key, val] of Object.entries(options.headers)) {
+          res.setHeader(key, val);
+        }
+      }
+
+      if (req.url === "/__busyserver") {
+        const { generateDashboard } = require("./dashboard");
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(generateDashboard(options, wss, watcher));
+        return;
+      }
+
+      const { handleProxy } = require("./proxy");
+      if (handleProxy(req, res, options)) return;
+
+      const { handleMock } = require("./mock");
+      if (handleMock(req, res, options)) return;
+
+      // Only support GET and HEAD
+      if (req.method !== "GET" && req.method !== "HEAD") {
+        statusCode = 405;
+        res.writeHead(405, { "Content-Type": "text/html; charset=utf-8", "Allow": "GET, HEAD" });
+        res.end(getErrorPage(405, "Method Not Allowed", "Use GET or HEAD."));
+        logRequest(req.method, req.url, statusCode, startTime, quiet);
+        return;
+      }
+
+      // Parse URL
+      let urlPath;
+      try {
+        const rawPath = req.url.split("?")[0];
+        urlPath = decodeURIComponent(rawPath);
+      } catch {
+        statusCode = 400;
+        res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(getErrorPage(400, "Bad Request", "Malformed URL."));
+        logRequest(req.method, req.url, statusCode, startTime, quiet);
+        return;
+      }
+
+      // Null byte check
+      if (hasNullByte(urlPath)) {
+        statusCode = 400;
+        res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(getErrorPage(400, "Bad Request", "Null byte in URL."));
+        logRequest(req.method, urlPath, statusCode, startTime, quiet);
+        return;
+      }
+
+      if (!urlPath.startsWith("/")) {
+        urlPath = "/" + urlPath;
+      }
+
+      // Resolve file path
+      const filePath = path.resolve(root, "." + urlPath);
+
+      // Security: path traversal check
+      if (!isPathSafe(filePath, root)) {
+        statusCode = 403;
+        res.writeHead(403, {
+          "Content-Type": "text/html; charset=utf-8",
+          "X-Content-Type-Options": "nosniff",
+        });
+        res.end(getErrorPage(403, "Access forbidden", urlPath));
+        logRequest(req.method, urlPath, statusCode, startTime, quiet);
+        return;
+      }
+
+      // Block dotfiles/dotdirs (but not root)
+      if (hasDotSegment(urlPath)) {
+        statusCode = 403;
+        res.writeHead(403, {
+          "Content-Type": "text/html; charset=utf-8",
+          "X-Content-Type-Options": "nosniff",
+        });
+        res.end(getErrorPage(403, "Access forbidden", urlPath));
+        logRequest(req.method, urlPath, statusCode, startTime, quiet);
+        return;
+      }
+
+      let stats;
+      try {
+        stats = await fs.promises.stat(filePath);
+      } catch {
+        // File not found - SPA fallback?
+        if (spaMode && !path.extname(urlPath)) {
+          const spaIndex = path.join(root, "index.html");
+          try {
+            const spaStats = await fs.promises.stat(spaIndex);
+            if (spaStats.isFile()) {
+              const data = await fs.promises.readFile(spaIndex, "utf-8");
+              const html = injectLiveReload(data, reloadEnabled);
+              res.writeHead(200, {
+                "Content-Type": "text/html; charset=utf-8",
+                "Cache-Control": "no-cache",
+                "X-Content-Type-Options": "nosniff",
+              });
+              res.end(html);
+              logRequest(req.method, urlPath, 200, startTime, quiet);
+              return;
+            }
+          } catch {
+            // SPA index.html not found either
+          }
+        }
+
+        statusCode = 404;
+        const body = injectLiveReload(getErrorPage(404, "File not found", urlPath), reloadEnabled);
+        res.writeHead(404, {
+          "Content-Type": "text/html; charset=utf-8",
+          "X-Content-Type-Options": "nosniff",
+        });
+        res.end(body);
+        logRequest(req.method, urlPath, statusCode, startTime, quiet);
+        return;
+      }
+
+      // ── Directory ──
+
+      if (stats.isDirectory()) {
+        // Redirect to trailing slash if missing
+        if (!urlPath.endsWith("/")) {
+          res.writeHead(301, { Location: urlPath + "/" });
+          res.end();
+          logRequest(req.method, urlPath, 301, startTime, quiet);
+          return;
+        }
+
+        // Try index.html
+        const indexPath = path.join(filePath, "index.html");
+        try {
+          const indexStats = await fs.promises.stat(indexPath);
+          if (indexStats.isFile()) {
+            const data = await fs.promises.readFile(indexPath, "utf-8");
+            const html = injectLiveReload(data, reloadEnabled);
+            res.writeHead(200, {
+              "Content-Type": "text/html; charset=utf-8",
+              "Cache-Control": "no-cache",
+              "X-Content-Type-Options": "nosniff",
+            });
+            res.end(html);
+            logRequest(req.method, urlPath, 200, startTime, quiet);
+            return;
+          }
+        } catch {
+          // No index.html - show directory listing
+        }
+
+        const listing = injectLiveReload(getDirectoryListing(filePath, urlPath), reloadEnabled);
+        res.writeHead(200, {
+          "Content-Type": "text/html; charset=utf-8",
+          "Cache-Control": "no-cache",
+          "X-Content-Type-Options": "nosniff",
+        });
+        res.end(listing);
+        logRequest(req.method, urlPath, 200, startTime, quiet);
+        return;
+      }
+
+      // ── File ──
+
+      const contentType = getContentType(filePath);
+      const etag = makeEtag(stats);
+
+      // 304 Not Modified
+      if (req.headers["if-none-match"] === etag) {
+        statusCode = 304;
+        res.writeHead(304);
+        res.end();
+        logRequest(req.method, urlPath, statusCode, startTime, quiet);
+        return;
+      }
+
+      // HTML files: read into memory for live reload injection
+      if (isHtmlType(contentType)) {
+        const data = await fs.promises.readFile(filePath, "utf-8");
+        const html = injectLiveReload(data, reloadEnabled);
+        res.writeHead(200, {
+          "Content-Type": contentType,
+          "Cache-Control": "no-cache",
+          "ETag": etag,
+          "X-Content-Type-Options": "nosniff",
+        });
+        res.end(html);
+        logRequest(req.method, urlPath, 200, startTime, quiet);
+        return;
+      }
+
+      // All other files: stream
+      const headers = {
+        "Content-Type": contentType,
+        "Cache-Control": "no-cache",
+        "ETag": etag,
+        "X-Content-Type-Options": "nosniff",
+        "Accept-Ranges": "bytes"
+      };
+
+      // Range support
+      let start = 0;
+      let end = stats.size - 1;
+      let isRange = false;
+
+      if (req.headers.range) {
+        const parts = req.headers.range.replace(/bytes=/, "").split("-");
+        const partialStart = parts[0];
+        const partialEnd = parts[1];
+
+        start = parseInt(partialStart, 10);
+        end = partialEnd ? parseInt(partialEnd, 10) : stats.size - 1;
+
+        if (isNaN(start) || isNaN(end) || start > end || start >= stats.size) {
+          res.writeHead(416, { "Content-Range": `bytes */${stats.size}` });
+          res.end();
+          logRequest(req.method, urlPath, 416, startTime, quiet);
+          return;
+        }
+
+        isRange = true;
+        headers["Content-Range"] = `bytes ${start}-${end}/${stats.size}`;
+        headers["Content-Length"] = end - start + 1;
+        statusCode = 206;
+      } else {
+        headers["Content-Length"] = stats.size;
+        statusCode = 200;
+      }
+
+      // Compression support
+      let compressStream = null;
+      if (!isRange && isCompressible(contentType) && options.compression !== false) {
+        const acceptEncoding = req.headers["accept-encoding"] || "";
+        if (acceptEncoding.match(/\bbr\b/)) {
+          headers["Content-Encoding"] = "br";
+          delete headers["Content-Length"]; // Chunked transfer
+          compressStream = zlib.createBrotliCompress();
+        } else if (acceptEncoding.match(/\bgzip\b/)) {
+          headers["Content-Encoding"] = "gzip";
+          delete headers["Content-Length"];
+          compressStream = zlib.createGzip();
+        }
+      }
+
+      if (req.method === "HEAD") {
+        res.writeHead(statusCode, headers);
+        res.end();
+        logRequest(req.method, urlPath, statusCode, startTime, quiet);
+        return;
+      }
+
+      res.writeHead(statusCode, headers);
+      const stream = fs.createReadStream(filePath, { start, end });
+
+      stream.on("error", (err) => {
+        if (!res.headersSent) {
+          res.writeHead(500);
+        }
+        res.end(getErrorPage(500, "Internal Server Error", err.message));
+        logRequest(req.method, urlPath, 500, startTime, quiet);
+      });
+
+      if (compressStream) {
+        stream.pipe(compressStream).pipe(res);
+      } else {
+        stream.pipe(res);
+      }
+
+      stream.on("end", () => {
+        logRequest(req.method, urlPath, statusCode, startTime, quiet);
+      });
+    } catch (error) {
+      console.error(`${c.red}Server error:${c.r}`, error.message);
+      statusCode = 500;
+      if (!res.headersSent) {
+        res.writeHead(500, { "Content-Type": "text/plain" });
+      }
+      if (!res.writableEnded) {
+        res.end("500 - Internal Server Error");
+      }
+      logRequest(req.method, req.url, statusCode, startTime, quiet);
+    }
+  };
+
+  let server;
+  if (options.https) {
+    try {
+      const https = require("https");
+      const key = fs.readFileSync(path.join(process.cwd(), "key.pem"));
+      const cert = fs.readFileSync(path.join(process.cwd(), "cert.pem"));
+      server = https.createServer({ key, cert }, handler);
+    } catch (e) {
+      console.error(`${c.red}❌ HTTPS Error:${c.r} Could not read key.pem or cert.pem in current directory.`);
+      process.exit(1);
+    }
+  } else {
+    server = http.createServer(handler);
+  }
+
+  // ── Bind Port ──
+
+  let actualPort = port;
+
+  if (autoPort) {
+    let attempts = 0;
+    while (true) {
+      try {
+        actualPort = await listenOnPort(server, actualPort, host);
+        break;
+      } catch (error) {
+        if (error.code !== "EADDRINUSE") throw error;
+        if (!quiet) console.log(`${c.yellow}⚠️  Port ${actualPort} is busy, trying ${actualPort + 1}...${c.r}`);
+        actualPort++;
+        attempts++;
+        if (actualPort > 65535 || attempts > 100) {
+          console.error(`${c.red}❌ No available ports found.${c.r}`);
+          process.exit(1);
+        }
+      }
+    }
+  } else {
+    try {
+      actualPort = await listenOnPort(server, port, host);
+    } catch (error) {
+      if (error.code === "EADDRINUSE") {
+        console.error(`${c.red}❌ Port ${port} is already in use.${c.r}`);
+        process.exit(1);
+      }
+      throw error;
+    }
+  }
+
+  // ── WebSocket ──
+
+  let wss = null;
+  if (reloadEnabled) {
+    wss = new WebSocketServer({ server, path: "/__busyserver_ws" });
+    wss.on("connection", (ws) => {
+      if (!quiet) {
+        console.log(`  ${c.dim}🔌 Browser connected${c.r}`);
+      }
+      ws.on("error", () => {
+        // Ignore WebSocket errors from disconnected clients
+      });
+    });
+  }
+
+  // ── File Watcher ──
+
+  const watcher = await startWatcher(
+    root,
+    (change) => {
+      if (!quiet) {
+        console.log(`  ${c.magenta}⚡ ${change.event}:${c.r} ${change.relativePath} ${c.dim}[${change.type}]${c.r}`);
+      }
+
+      if (!wss) return;
+
+      for (const client of wss.clients) {
+        if (client.readyState === 1) {
+          client.send(JSON.stringify({
+            type: change.type,
+            file: change.relativePath,
+          }));
+        }
+      }
+    },
+    {
+      enabled: watchEnabled,
+      ignore: ignorePatterns,
+    }
+  );
+
+  // ── Graceful Shutdown ──
+
+  let shuttingDown = false;
+
+  function shutdown() {
+    if (shuttingDown) return;
+    shuttingDown = true;
+
+    console.log(`\n${c.dim}Shutting down...${c.r}`);
+
+    // Close watcher
+    if (watcher) {
+      try { watcher.close(); } catch { /* ignore */ }
+    }
+
+    // Close WebSocket connections
+    if (wss) {
+      for (const client of wss.clients) {
+        try { client.close(); } catch { /* ignore */ }
+      }
+      try { wss.close(); } catch { /* ignore */ }
+    }
+
+    // Close HTTP server
+    server.close(() => {
+      process.exit(0);
+    });
+
+    // Force exit after 3 seconds
+    setTimeout(() => process.exit(0), 3000).unref();
+  }
+
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+
+  // ── Startup Banner ──
+
+  const networkAddress = getNetworkAddress();
+  const protocol = options.https ? "https" : "http";
+  const localUrl = `${protocol}://localhost:${actualPort}`;
+  const networkUrl = networkAddress ? `${protocol}://${networkAddress}:${actualPort}` : null;
+
+  if (!quiet) {
+    console.log("");
+    console.log(`  ${c.bold}🚀 BusyServer v${version}${c.r}`);
+    console.log("");
+    console.log(`  ${c.dim}Local:${c.r}        ${c.cyan}${localUrl}${c.r}`);
+
+    if (networkUrl) {
+      console.log(`  ${c.dim}Network:${c.r}      ${c.cyan}${networkUrl}${c.r}`);
+    } else {
+      console.log(`  ${c.dim}Network:${c.r}      ${c.dim}Not available${c.r}`);
+    }
+
+    console.log("");
+    console.log(`  ${c.dim}Folder:${c.r}       ${shortenPath(root)}`);
+    console.log(`  ${c.dim}Live Reload:${c.r}  ${reloadEnabled ? `${c.green}ON${c.r}` : `${c.dim}OFF${c.r}`}`);
+    console.log(`  ${c.dim}Watching:${c.r}     ${watchEnabled ? `${c.green}ON${c.r}` : `${c.dim}OFF${c.r}`}`);
+
+    if (spaMode) {
+      console.log(`  ${c.dim}SPA Mode:${c.r}    ${c.green}ON${c.r}`);
+    }
+
+    console.log("");
+  }
+
+  // ── QR Code ──
+
+  if (showQr && networkUrl && !quiet) {
+    try {
+      console.log(`  ${c.dim}Network URL for mobile:${c.r}`);
+      qrcode.generate(networkUrl, { small: true }, function (qrcode) {
+        const indented = qrcode.split("\n").map(line => "  " + line).join("\n");
+        console.log(indented);
+      });
+      console.log("");
+    } catch {
+      console.log(`  ${c.bold}${networkUrl}${c.r}`);
+      console.log("");
+    }
+  }
+
+  // ── Open Browser ──
+
+  if (openBrowserOnStart) {
+    openBrowser(localUrl);
+  }
+
+  return { server, wss, watcher, port: actualPort, url: localUrl };
+}
+
+module.exports = { startBusyServer };