@johnhenry/packfile 0.0.0

package/lib/from-directory.mjs

@@ -0,0 +1,79 @@
+import { readFile, readdir, stat, realpath } from "node:fs/promises";
+import { join, relative, sep } from "node:path";
+import { hashBuffer } from "./hash.mjs";
+import { isWithinRoot } from "./safe-symlink.mjs";
+
+// path.relative() returns platform-native separators -- backslash on
+// Windows. FilesMap keys (and everything that looks them up: createRouter(),
+// toArchive()/fromArchive() round-tripping, a consumer's own path.join()
+// calls) all assume the single POSIX-style "/" convention used everywhere
+// else in this codebase (see FORMATS.md), so a Windows-produced FilesMap
+// with un-normalized "docs\index.html"-style keys silently fails every
+// forward-slash lookup. Found via real Windows CI, not by inspection.
+const toPosixPath = (path) => (sep === "/" ? path : path.split(sep).join("/"));
+
+export const fromDirectory = async (directoryPath, options = {}) => {
+  const {
+    ignorePatterns = [],
+    maxFileSize = Infinity,
+  } = options;
+
+  const files = new Map();
+  const rootRealPath = await realpath(directoryPath);
+
+  // Tracks the real path of every directory from the root down to the one
+  // currently being walked, so a symlink that points back at an ancestor
+  // (e.g. `ln -s . loop`, or a mutual A<->B symlink cycle) is detected and
+  // skipped instead of recursing until the OS's ELOOP limit crashes the
+  // whole fromDirectory() call.
+  const walk = async (currentPath, currentRealPath, ancestors) => {
+    const entries = await readdir(currentPath, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = join(currentPath, entry.name);
+      const relativePath = toPosixPath(relative(directoryPath, fullPath));
+
+      if (ignorePatterns.some((pattern) => new RegExp(pattern).test(relativePath))) {
+        continue;
+      }
+
+      let childRealPath = join(currentRealPath, entry.name);
+
+      if (entry.isSymbolicLink()) {
+        // A symlink inside the target directory can point anywhere on disk.
+        // Resolve its real path and skip it if it escapes the directory
+        // being archived — otherwise fromDirectory() would silently read
+        // and package up arbitrary files from outside the target tree.
+        let realTarget;
+        try {
+          realTarget = await realpath(fullPath);
+        } catch {
+          continue; // broken symlink or too many levels of symlinks (ELOOP)
+        }
+        if (!isWithinRoot(rootRealPath, realTarget)) continue;
+        if (ancestors.has(realTarget)) continue; // symlink cycle
+        childRealPath = realTarget;
+      }
+
+      // Resolve the actual type via stat (follows symlinks that passed the
+      // containment/cycle checks above).
+      const stats = await stat(fullPath);
+
+      if (stats.isDirectory()) {
+        await walk(fullPath, childRealPath, new Set(ancestors).add(childRealPath));
+      } else if (stats.isFile()) {
+        if (stats.size > maxFileSize) continue;
+        const data = await readFile(fullPath);
+        const hash = hashBuffer(data);
+        files.set(relativePath, {
+          data: new Uint8Array(data),
+          size: stats.size,
+          hash,
+        });
+      }
+    }
+  };
+
+  await walk(directoryPath, rootRealPath, new Set([rootRealPath]));
+  return files;
+};

package/lib/hash.mjs

@@ -0,0 +1,14 @@
+import { createHash } from "node:crypto";
+
+export const hashBuffer = (buffer) => {
+  return createHash("sha256").update(buffer).digest("hex");
+};
+
+export const hashStream = (stream) => {
+  return new Promise((resolve, reject) => {
+    const hash = createHash("sha256");
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolve(hash.digest("hex")));
+    stream.on("error", reject);
+  });
+};

package/lib/lazy-file-map.mjs

@@ -0,0 +1,62 @@
+import { readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { hashBuffer } from "./hash.mjs";
+
+export class LazyFileMap {
+  #basePath;
+  #paths;
+
+  constructor(basePath, paths) {
+    this.#basePath = basePath;
+    this.#paths = paths;
+  }
+
+  has(key) {
+    return this.#paths.has(key);
+  }
+
+  async get(key) {
+    if (!this.#paths.has(key)) return undefined;
+    const fullPath = join(this.#basePath, key);
+    const [data, stats] = await Promise.all([
+      readFile(fullPath),
+      stat(fullPath),
+    ]);
+    const hash = hashBuffer(data);
+    return {
+      data: new Uint8Array(data),
+      size: stats.size,
+      hash,
+    };
+  }
+
+  keys() {
+    return this.#paths.keys();
+  }
+
+  *values() {
+    for (const key of this.#paths) {
+      yield this.get(key);
+    }
+  }
+
+  *entries() {
+    for (const key of this.#paths) {
+      yield [key, this.get(key)];
+    }
+  }
+
+  forEach(callback, thisArg) {
+    for (const key of this.#paths) {
+      callback.call(thisArg, this.get(key), key, this);
+    }
+  }
+
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+
+  get size() {
+    return this.#paths.size;
+  }
+}

package/lib/mime.mjs

@@ -0,0 +1,74 @@
+const MIME_TYPES = {
+  // Text
+  html: "text/html",
+  htm: "text/html",
+  css: "text/css",
+  csv: "text/csv",
+  txt: "text/plain",
+  xml: "text/xml",
+  markdown: "text/markdown",
+  md: "text/markdown",
+
+  // JavaScript / JSON
+  js: "application/javascript",
+  mjs: "application/javascript",
+  cjs: "application/javascript",
+  json: "application/json",
+  jsonld: "application/ld+json",
+  map: "application/json",
+
+  // Images
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  svg: "image/svg+xml",
+  webp: "image/webp",
+  avif: "image/avif",
+  ico: "image/x-icon",
+  bmp: "image/bmp",
+  tiff: "image/tiff",
+  tif: "image/tiff",
+
+  // Fonts
+  woff: "font/woff",
+  woff2: "font/woff2",
+  ttf: "font/ttf",
+  otf: "font/otf",
+  eot: "application/vnd.ms-fontobject",
+
+  // Audio / Video
+  mp3: "audio/mpeg",
+  ogg: "audio/ogg",
+  wav: "audio/wav",
+  mp4: "video/mp4",
+  webm: "video/webm",
+
+  // Application
+  pdf: "application/pdf",
+  zip: "application/zip",
+  gz: "application/gzip",
+  tar: "application/x-tar",
+  wasm: "application/wasm",
+  bin: "application/octet-stream",
+
+  // Web
+  manifest: "application/manifest+json",
+  webmanifest: "application/manifest+json",
+};
+
+export const getContentType = (filePath, customMimeTypes) => {
+  const extension = filePath.split(".").pop()?.toLowerCase() ?? "";
+  // Plain-object lookups on an attacker/user-influenced key (the file
+  // extension) must use an own-property check: MIME_TYPES/customMimeTypes
+  // are ordinary object literals, so extensions like "constructor",
+  // "__proto__", or "toString" would otherwise resolve to inherited
+  // Object.prototype values instead of falling back to the default type.
+  if (customMimeTypes && Object.hasOwn(customMimeTypes, extension)) {
+    return customMimeTypes[extension];
+  }
+  if (Object.hasOwn(MIME_TYPES, extension)) {
+    return MIME_TYPES[extension];
+  }
+  return "application/octet-stream";
+};

package/lib/response.mjs

@@ -0,0 +1,41 @@
+import { getContentType } from "./mime.mjs";
+
+const DEFAULT_CACHE_CONTROL = "max-age=3600";
+
+export const buildFileResponse = (request, filePath, entry, opts = {}) => {
+  const {
+    cacheControl = DEFAULT_CACHE_CONTROL,
+    mimeTypes,
+  } = opts;
+
+  const etag = `"${entry.hash}"`;
+
+  // 304 Not Modified
+  if (request) {
+    const ifNoneMatch = typeof request.headers?.get === "function"
+      ? request.headers.get("if-none-match")
+      : request.headers?.["if-none-match"];
+    if (ifNoneMatch && ifNoneMatch === etag) {
+      return new Response(null, {
+        status: 304,
+        headers: { ETag: etag },
+      });
+    }
+  }
+
+  const contentType = getContentType(filePath, mimeTypes);
+  const headers = new Headers({
+    "Content-Type": contentType,
+    "Content-Length": String(entry.size),
+    "Cache-Control": cacheControl,
+    ETag: etag,
+  });
+
+  // HEAD — no body
+  const method = request?.method ?? "GET";
+  if (method === "HEAD") {
+    return new Response(null, { status: 200, headers });
+  }
+
+  return new Response(entry.data, { status: 200, headers });
+};

package/lib/safe-symlink.mjs

@@ -0,0 +1,15 @@
+import { relative, isAbsolute } from "node:path";
+
+/**
+ * Returns true if `target` (an absolute, already-resolved path) is equal to
+ * or nested inside `root` (an absolute, already-resolved path).
+ *
+ * Used to keep symlink resolution from escaping the directory being walked:
+ * a symlink inside a directory can point anywhere on disk, and following it
+ * blindly would let `fromDirectory`/`fromDirectoryLazy` read and package up
+ * arbitrary files from outside the target tree.
+ */
+export const isWithinRoot = (root, target) => {
+  const rel = relative(root, target);
+  return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+};

package/lib/to-archive.mjs

@@ -0,0 +1,27 @@
+/**
+ * Serializes a `FilesMap` to this package's archive format: gzip(Web
+ * Bundle), via `toWebBundle()` (`lib/web-bundle.mjs`). `ARCHIVE_BASE_URL`
+ * is purely an internal implementation detail -- `toArchive()`/
+ * `fromArchive()` keep the same flat path -> content contract callers
+ * already had with the previous CBOR format; nothing about the Web Bundle
+ * format's own absolute-URL requirement is exposed here. It uses the
+ * IANA/RFC 2606 `.invalid` TLD, guaranteed to never resolve to a real
+ * origin, since this URL is never meant to be dereferenced -- only ever
+ * built and immediately stripped back off by `fromArchive()`.
+ */
+import { compressObject } from "./compression.mjs";
+import { toWebBundle } from "./web-bundle.mjs";
+
+const ARCHIVE_BASE_URL = "https://packfile.invalid/";
+
+export const toArchive = async (map, opts = {}) => {
+  const { compress = true, compressionLevel } = opts;
+
+  let buffer = toWebBundle(map, { baseURL: ARCHIVE_BASE_URL });
+
+  if (compress) {
+    buffer = await compressObject(buffer, compressionLevel);
+  }
+
+  return buffer;
+};

package/lib/web-bundle.mjs

@@ -0,0 +1,195 @@
+/**
+ * The Web Bundle engine underlying this package's archive format.
+ * `lib/to-archive.mjs`/`lib/from-archive.mjs` (the main, stable
+ * `toArchive()`/`fromArchive()` at the `.` entrypoint) are thin wrappers
+ * around `toWebBundle()`/`fromWebBundle()` below, with a fixed internal
+ * `baseURL` and the existing gzip layer -- packfile moved from a bespoke
+ * flat-object CBOR format to `application/webbundle` (`.wbn`, the format
+ * Chrome's Isolated Web Apps are built on) wholesale, via the real,
+ * Google-maintained `wbn` package (build/parse) and, for signing,
+ * `wbn-sign` -- not a reimplementation of the format here.
+ *
+ * This module itself is also reachable directly via the
+ * `@johnhenry/packfile/web-bundle` subpath, for callers who want lower-level
+ * control `toArchive()`/`fromArchive()` deliberately hide: a real `baseURL`
+ * (for producing a bundle with real, resolvable exchange URLs -- IWA's
+ * `isolated-app://` origin, or a real `https://` one), custom per-file
+ * `headers()`, and `createWebBundleRouter()` for serving a bundle's own
+ * baked-in headers verbatim instead of `createRouter()`'s synthesized ones.
+ *
+ * The two shapes involved: `FilesMap` (`Map<path, {data,size,hash}>`, this
+ * package's own, as produced by `fromDirectory()`) has no HTTP semantics at
+ * all; a Web Bundle is a set of full HTTP *exchanges* -- absolute URL +
+ * status + headers + body per entry. `toWebBundle()` synthesizes the
+ * exchange (absolute URL by resolving each relative path against `baseURL`;
+ * status always 200; `Content-Type` inferred the same way `createRouter()`'s
+ * own responses already are, via `getContentType()`) since `FileEntry`
+ * itself carries none of that. `fromWebBundle()` does the reverse and also
+ * drops back to `FileEntry`'s own `hash` field by recomputing it from the
+ * response body with `hashBuffer()` -- Web Bundles don't carry a content
+ * hash of their own, so there's nothing to read instead.
+ */
+import * as wbn from "wbn";
+import { getContentType } from "./mime.mjs";
+import { hashBuffer } from "./hash.mjs";
+
+// Deliberately the same coarse, pure-string check `browser.mjs` already used
+// on its own (previously divergent) archive-reading path -- not Node's
+// `path.normalize()`/`isAbsolute()` (what the old CBOR-based from-archive.mjs
+// used), so this same logic works identically for a browser build with no
+// `node:path` available. Any ".." substring is rejected outright rather than
+// only a normalized leading "..", which is stricter than strictly necessary
+// (rejects a harmless "a..b" filename too) but avoids re-implementing real
+// path normalization twice for two platforms.
+const isSafePath = (p) => {
+  if (p.startsWith("/") || p.startsWith("\\")) return false;
+  if (p.includes("..")) return false;
+  if (p.includes("\0")) return false;
+  if (p === "" || p === ".") return false;
+  return true;
+};
+
+/**
+ * @param {Map<string, import("../types.js").FileEntry>} map
+ * @param {{ baseURL: string, primaryURL?: string, formatVersion?: "b1"|"b2", mimeTypes?: Record<string,string>, headers?: (path: string) => Record<string,string> }} options
+ * @returns {Uint8Array}
+ */
+export const toWebBundle = (map, options = {}) => {
+  const { baseURL, primaryURL, formatVersion = "b2", mimeTypes, headers } = options;
+  if (!baseURL) {
+    throw new Error('toWebBundle() requires a `baseURL` (e.g. "https://example.com/") to resolve each relative path into an absolute exchange URL');
+  }
+
+  const builder = new wbn.BundleBuilder(formatVersion);
+  for (const [path, entry] of map) {
+    const url = new URL(path, baseURL).toString();
+    const responseHeaders = {
+      "Content-Type": getContentType(path, mimeTypes),
+      ...(headers ? headers(path) : {}),
+    };
+    builder.addExchange(url, 200, responseHeaders, entry.data);
+  }
+  builder.setPrimaryURL(primaryURL ?? baseURL);
+  return builder.createBundle();
+};
+
+/**
+ * @param {Uint8Array} buffer
+ * @param {{ baseURL?: string }} options -- if `baseURL` is passed, each
+ *   exchange's absolute URL is stripped back down to a `baseURL`-relative
+ *   path (the inverse of `toWebBundle()`'s own resolution) so the result is
+ *   directly usable as a `FilesMap` key, e.g. handed straight to
+ *   `toArchive()`. Without it, the map is keyed by the exchange's full URL
+ *   instead -- still a real `FilesMap`, just not path-shaped. Whenever
+ *   `baseURL` is given, a resulting relative key that would escape it (a
+ *   leading slash, `..`, a NUL byte, or the empty/"." path itself) is
+ *   silently skipped rather than included -- the same defense-in-depth the
+ *   old CBOR-based `fromArchive()` applied before handing entries to
+ *   `decompileDirectory()`'s `writeFile()` calls.
+ * @returns {Map<string, import("../types.js").FileEntry>}
+ */
+export const fromWebBundle = (buffer, options = {}) => {
+  const { baseURL } = options;
+  const bundle = new wbn.Bundle(buffer);
+  const files = new Map();
+  for (const url of bundle.urls) {
+    const relativeKey = baseURL ? stripBaseURL(url, baseURL) : url;
+    if (baseURL && !isSafePath(relativeKey)) continue;
+    const response = bundle.getResponse(url);
+    files.set(relativeKey, {
+      data: response.body,
+      size: response.body.byteLength,
+      hash: hashBuffer(response.body),
+    });
+  }
+  return files;
+};
+
+const stripBaseURL = (url, baseURL) => {
+  const base = baseURL.endsWith("/") ? baseURL : `${baseURL}/`;
+  return url.startsWith(base) ? url.slice(base.length) : url;
+};
+
+/**
+ * Serves a parsed `wbn.Bundle` directly -- same `(input, ctx?) =>
+ * Promise<Response>` (+ `.fetch`) contract as `createRouter()`, but returns
+ * each exchange's OWN baked-in status/headers verbatim instead of
+ * resynthesizing them the way `createRouter()` does for a `FileEntry`
+ * (Content-Type/Cache-Control/ETag there are packfile's own invention;
+ * here, whatever `toWebBundle()`'s `headers()` callback -- or an external
+ * bundle -- actually set into the response is what gets served). Prefer
+ * this over `createRouter(fromWebBundle(...))` whenever the bundle's own
+ * headers matter; use the `fromWebBundle()` + `createRouter()` path when a
+ * plain `FilesMap` (e.g. to feed into `toArchive()`) is what's actually
+ * wanted.
+ *
+ * `new wbn.Bundle(buffer)` decodes the ENTIRE bundle up front (verified by
+ * reading `wbn`'s own decoder: the constructor eagerly walks every response
+ * in the `responses` section) -- unlike `fromDirectoryLazy()`'s
+ * `LazyFileMap`, there is no on-demand/streaming read path in `wbn` itself,
+ * so "serving" a large bundle still means holding the whole parsed thing in
+ * memory. Parse once (e.g. at process startup) and reuse the same `Bundle`
+ * instance across requests; re-parsing per request would repeat that full
+ * decode for no reason.
+ *
+ * @param {InstanceType<typeof wbn.Bundle>} bundle
+ * @param {{ baseURL: string, alias?: Record<string,string>, tryExtensions?: string[], fallback?: (input: string|Request, ctx?: unknown) => Response|Promise<Response> }} options
+ */
+export const createWebBundleRouter = (bundle, options = {}) => {
+  const { baseURL, alias = {}, tryExtensions = [], fallback } = options;
+  if (!baseURL) {
+    throw new Error("createWebBundleRouter() requires the same `baseURL` used to build the bundle, to resolve an incoming request path back to its absolute exchange URL");
+  }
+  const knownURLs = new Set(bundle.urls);
+
+  const notFound = (input, ctx) => {
+    if (fallback) return fallback(input, ctx);
+    return new Response("Not Found", { status: 404 });
+  };
+
+  const resolve = (path) => {
+    const direct = new URL(path, baseURL).toString();
+    if (knownURLs.has(direct)) return direct;
+    for (const ext of tryExtensions) {
+      const candidate = new URL(path + ext, baseURL).toString();
+      if (knownURLs.has(candidate)) return candidate;
+    }
+    return null;
+  };
+
+  const handler = async (input, ctx) => {
+    let method, filePath, request;
+    if (typeof input === "string") {
+      method = "GET";
+      filePath = input;
+      request = null;
+    } else {
+      request = input;
+      method = request.method;
+      filePath = new URL(request.url).pathname;
+    }
+
+    if (method !== "GET" && method !== "HEAD") {
+      if (fallback) return fallback(input, ctx);
+      return new Response("Method Not Allowed", { status: 405, headers: { Allow: "GET, HEAD" } });
+    }
+
+    for (const [aliasPath, targetPath] of Object.entries(alias)) {
+      if (filePath === aliasPath) {
+        filePath = targetPath;
+        break;
+      }
+    }
+
+    const resolved = resolve(filePath.replace(/^\//, ""));
+    if (!resolved) return notFound(input, ctx);
+
+    const response = bundle.getResponse(resolved);
+    const headers = new Headers(response.headers);
+    if (method === "HEAD") return new Response(null, { status: response.status, headers });
+    return new Response(response.body, { status: response.status, headers });
+  };
+
+  handler.fetch = handler;
+  return handler;
+};

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@johnhenry/packfile",
+  "version": "0.0.0",
+  "type": "module",
+  "main": "index.mjs",
+  "types": "./types.d.ts",
+  "bin": {
+    "packfile": "packfile.mjs"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/johnhenry/packfile.git"
+  },
+  "bugs": {
+    "url": "https://github.com/johnhenry/packfile/issues"
+  },
+  "homepage": "https://opensource.johnhenry.me/packfile/",
+  "engines": {
+    "node": ">=26.0.0"
+  },
+  "scripts": {
+    "test": "node --test test.mjs",
+    "demo:compile": "node demo/compile.mjs",
+    "demo:server": "node demo/server.mjs",
+    "demo:browser": "npx serve ."
+  },
+  "keywords": [],
+  "author": "John Henry",
+  "license": "MIT",
+  "description": "Content-addressed static-file archiver and in-memory HTTP router",
+  "dependencies": {
+    "@johnhenry/andbox": "^0.0.2",
+    "wbn": "^0.0.9"
+  },
+  "devDependencies": {
+    "theres-waldo": "^0.0.0",
+    "wbn-sign": "^0.3.1"
+  },
+  "exports": {
+    ".": {
+      "types": "./types.d.ts",
+      "default": "./index.mjs"
+    },
+    "./browser": "./browser.mjs",
+    "./compat": "./compat.mjs",
+    "./cache": "./cache.mjs",
+    "./hash": "./lib/hash.mjs",
+    "./compression": "./lib/compression.mjs",
+    "./blob-preview": "./lib/blob-preview.mjs",
+    "./web-bundle": "./lib/web-bundle.mjs"
+  },
+  "files": [
+    "index.mjs",
+    "browser.mjs",
+    "compat.mjs",
+    "cache.mjs",
+    "packfile.mjs",
+    "lib/",
+    "types.d.ts",
+    "types.ts",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/packfile.mjs

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+
+import { readFile, writeFile } from "node:fs/promises";
+import { createServer } from "node:http";
+import { constants } from "node:zlib";
+import { fromDirectory } from "./lib/from-directory.mjs";
+import { toArchive } from "./lib/to-archive.mjs";
+import { fromArchive } from "./lib/from-archive.mjs";
+import { createRouter } from "./lib/create-router.mjs";
+import { decompileDirectory } from "./compat.mjs";
+
+function log(level, message) {
+  const timestamp = new Date().toISOString();
+  console[level](`[${timestamp}] ${level.toUpperCase()}: ${message}`);
+}
+
+const [, , command, ...args] = process.argv;
+
+try {
+  switch (command) {
+    case "compress": {
+      if (args.length < 2 || args.length > 3) {
+        throw new Error("Usage: packfile compress <path-to-folder> <path-to-file> [compression-level]");
+      }
+      let compressionLevel;
+      if (args[2] !== undefined) {
+        compressionLevel = parseInt(args[2]);
+        if (isNaN(compressionLevel) || compressionLevel < 0 || compressionLevel > 9) {
+          throw new Error("Compression level must be a number between 0 and 9");
+        }
+      }
+      log("info", `Starting compression of folder ${args[0]}`);
+      const map = await fromDirectory(args[0]);
+      const buffer = await toArchive(map, { compress: true, compressionLevel });
+      await writeFile(args[1], buffer);
+      log("info", `Successfully compressed folder ${args[0]} to ${args[1]}`);
+      break;
+    }
+    case "decompress": {
+      if (args.length !== 2) {
+        throw new Error("Usage: packfile decompress <path-to-file> <path-to-folder>");
+      }
+      log("info", `Starting decompression of file ${args[0]}`);
+      const data = await readFile(args[0]);
+      await decompileDirectory(data, args[1], true);
+      log("info", `Successfully decompressed file ${args[0]} to folder ${args[1]}`);
+      break;
+    }
+    case "serve": {
+      if (args.length < 1 || args.length > 2) {
+        throw new Error("Usage: packfile serve <path-to-file> [port]");
+      }
+      const port = args[1] ? parseInt(args[1]) : 3000;
+      log("info", `Starting server for file ${args[0]} on port ${port}`);
+      const archiveData = await readFile(args[0]);
+      const files = await fromArchive(archiveData, { compressed: true });
+      const router = createRouter(files, { alias: { "/": "index.html" } });
+
+      const server = createServer(async (req, res) => {
+        try {
+          const url = new URL(req.url, `http://localhost:${port}`);
+          const request = new Request(url, { method: req.method, headers: req.headers });
+          const response = await router(request);
+          res.writeHead(response.status, Object.fromEntries(response.headers));
+          if (response.body) {
+            const buf = Buffer.from(await response.arrayBuffer());
+            res.end(buf);
+          } else {
+            res.end();
+          }
+        } catch (error) {
+          log("error", `Failed to serve: ${error.message}`);
+          res.writeHead(500);
+          res.end("Internal Server Error");
+        }
+      });
+
+      server.listen(port, () => {
+        log("info", `Server running at http://localhost:${port}`);
+      });
+      break;
+    }
+    default:
+      throw new Error("Unknown command. Available commands: compress, decompress, serve");
+  }
+} catch (error) {
+  log("error", error.message);
+  process.exit(1);
+}