ssserve 0.1.0__tar.gz

ssserve-0.1.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: ssserve
+Version: 0.1.0
+Summary: Static file serving and directory listing — Python port of vercel/serve
+License: MIT
+Requires-Python: >=3.10
+Requires-Dist: click>=8.0

ssserve-0.1.0/README.md

@@ -0,0 +1,148 @@
+# ssserve
+
+Python port of [vercel/serve](https://github.com/vercel/serve) — static file serving and directory listing. (vibecoded)
+
+## Install
+
+```bash
+uv tool install ssserve
+```
+
+Or run directly without installing:
+
+```bash
+uv run --from ssserve ssserve
+```
+
+## Usage
+
+```bash
+ssserve [path] [options]
+```
+
+Defaults to current directory and port 3000.
+
+### Options
+
+| Flag | Description |
+|---|---|
+| `-l, --listen URI` | Listen endpoint (default: `tcp://0.0.0.0:3000`, multi-allowed) |
+| `-s, --single` | SPA mode — rewrite 404s to `index.html` |
+| `-C, --cors` | Enable CORS headers |
+| `-u, --no-compression` | Disable gzip compression |
+| `-S, --symlinks` | Resolve symlinks |
+| `-L, --no-request-logging` | Disable request logging |
+| `-c, --config PATH` | Path to `serve.json` |
+| `--no-etag` | Disable ETag (use `Last-Modified`) |
+| `--ssl-cert FILE` | SSL certificate (PEM) |
+| `--ssl-key FILE` | SSL private key (PEM) |
+| `--ssl-pass FILE` | SSL passphrase file |
+| `--no-port-switching` | Don't auto-switch if port is taken |
+| `-d, --debug` | Debug output |
+| `--version` | Show version |
+| `--help` | Show help |
+
+### Examples
+
+```bash
+# Serve current directory on port 3000
+ssserve
+
+# Serve specific directory on port 5000 with CORS
+ssserve -l 5000 -C ./my-site
+
+# Serve with HTTPS
+ssserve --ssl-cert cert.pem --ssl-key key.pem
+
+# SPA mode for React/Vue apps
+ssserve -s dist
+
+# Multiple listeners
+ssserve -l tcp://0.0.0.0:3000 -l unix:/tmp/serve.sock
+```
+
+## Configuration
+
+Create a `serve.json` file in the served directory:
+
+```json
+{
+  "public": "_site",
+  "cleanUrls": true,
+  "rewrites": [
+    { "source": "/api/**", "destination": "/index.html" }
+  ],
+  "redirects": [
+    { "source": "/old", "destination": "/new", "type": 302 }
+  ],
+  "headers": [
+    {
+      "source": "**/*.@(jpg|png)",
+      "headers": [
+        { "key": "Cache-Control", "value": "max-age=7200" }
+      ]
+    }
+  ],
+  "directoryListing": false,
+  "trailingSlash": true,
+  "etag": true,
+  "symlinks": false,
+  "renderSingle": false
+}
+```
+
+## Testing
+
+E2E tests verify behaviour, performance, and resource consumption against a live server process.
+
+```bash
+# Run all tests
+uv run pytest tests/ -v
+
+# Run only e2e tests
+uv run pytest tests/e2e/ -v
+```
+
+### Test layout
+
+| File | Tests | What it covers |
+|---|---|---|
+| `tests/e2e/test_behavior.py` | 47 | File serving, directory listing, clean URLs, redirects, rewrites, CORS, gzip, ETag/304, Range requests, SPA mode, custom headers, symlinks, path traversal |
+| `tests/e2e/test_performance.py` | 8 | Latency (p50/p95/p99), TTFB, gzip vs raw, concurrent throughput — measure-only |
+| `tests/e2e/test_resources.py` | 7 | RSS memory, CPU usage, file descriptor count — measure-only |
+
+Dependencies: `pytest`, `psutil` (see `[dependency-groups]` in `pyproject.toml`).
+
+Tests run automatically on CI via `.github/workflows/tests.yml`.
+
+## Benchmarks
+
+Micro-benchmarks using [airspeed velocity](https://asv.readthedocs.io/) track performance of core operations across commits:
+
+| Benchmark | What it measures |
+|---|---|
+| `TimeRouteToRegex` | Pattern compilation for route matching |
+| `TimeMatchGlob` | Glob matching and exclusion lists |
+| `TimeParseByteRange` | HTTP Range header parsing |
+| `TimeFormatSize` | File size formatting |
+| `TimeFormatDate` | Date formatting |
+| `TimeParseListen` | Listen URI parsing |
+| `TimeMergeConfig` | Config merging from `serve.json` |
+| `TimeRenderListing` | HTML directory listing rendering (100 files) |
+
+```bash
+# Validate benchmarks
+uv run asv check --python=same
+
+# Quick run
+uv run asv run --python=same --quick
+
+# Full run across configured pythons
+uv run asv run
+```
+
+Benchmarks run automatically on CI via `.github/workflows/benchmarks.yml`.
+
+## License
+
+MIT

ssserve-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[project]
+name = "ssserve"
+version = "0.1.0"
+description = "Static file serving and directory listing — Python port of vercel/serve"
+requires-python = ">=3.10"
+dependencies = ["click>=8.0"]
+license = { text = "MIT" }
+
+[project.scripts]
+ssserve = "ssserve.cli:main"
+
+[build-system]
+requires = ["setuptools>=64"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["ssserve"]
+
+[dependency-groups]
+dev = [
+    "pytest>=8",
+    "psutil>=6",
+    "asv>=0.6.5",
+]

ssserve-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ssserve-0.1.0/ssserve/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

ssserve-0.1.0/ssserve/__main__.py

@@ -0,0 +1,3 @@
+from ssserve.cli import main
+
+main()

ssserve-0.1.0/ssserve/cli.py

@@ -0,0 +1,198 @@
+from __future__ import annotations
+
+import os
+import socket
+import ssl
+import socketserver
+import sys
+import time
+from http.server import HTTPServer
+
+import click
+
+from ssserve import __version__
+from ssserve.config import load_config
+from ssserve.handler import ServeHandler
+from ssserve.network import Address, find_free_port, get_lan_ip, parse_listen
+
+
+def _create_server(
+    addr: Address,
+    handler_class: type,
+    ssl_cert: str | None = None,
+    ssl_key: str | None = None,
+    ssl_pass: str | None = None,
+) -> HTTPServer:
+    if addr.scheme == "unix":
+        if os.path.exists(addr.path):
+            os.unlink(addr.path)
+        server = HTTPServer(addr.path, handler_class)
+        server.server_address = addr.path
+    else:
+        host = addr.host or "0.0.0.0"
+        server = HTTPServer((host, addr.port), handler_class)
+        server.server_address = (host, addr.port)
+
+    if ssl_cert and ssl_key:
+        passphrase = None
+        if ssl_pass:
+            with open(ssl_pass) as f:
+                passphrase = f.read().strip()
+        ctx = ssl.SSLContext(ssl.Purpose.CLIENT_AUTH)
+        ctx.load_cert_chain(ssl_cert, ssl_key, passphrase if passphrase else None)
+        server.socket = ctx.wrap_socket(server.socket, server_side=True)
+
+    return server
+
+
+def _print_startup(
+    addr: Address,
+    cors: bool,
+    ssl_active: bool,
+    no_port_switching: bool,
+    no_compression: bool,
+    port_switched: bool = False,
+) -> None:
+    scheme = "https" if ssl_active else "http"
+    host = addr.host or "0.0.0.0"
+
+    click.echo("")
+    click.echo(f"  ssserve v{__version__}")
+    click.echo("")
+
+    if addr.scheme == "unix":
+        click.echo(f"  ➜ Local:   unix:{addr.path}")
+    else:
+        local_url = f"  ➜ Local:   {scheme}://localhost:{addr.port}"
+        if port_switched:
+            local_url += f" (port {addr.port} was in use, switched)"
+        click.echo(local_url)
+
+        lan_ip = get_lan_ip()
+        if lan_ip:
+            click.echo(f"  ➜ Network: {scheme}://{lan_ip}:{addr.port}")
+
+    click.echo("")
+
+    if cors:
+        click.echo("  ➜ CORS enabled")
+    if ssl_active:
+        click.echo("  ➜ SSL enabled")
+    if not no_compression:
+        click.echo("  ➜ Compression enabled (gzip)")
+
+    click.echo("")
+
+
+@click.command()
+@click.argument("path", type=click.Path(exists=True, file_okay=False, dir_okay=True), default=".", required=False)
+@click.option("-l", "--listen", type=str, multiple=True, default=["tcp://0.0.0.0:3000"], help="Listen endpoint")
+@click.option("-s", "--single", is_flag=True, help="Single page application mode (rewrite 404 to index.html)")
+@click.option("-d", "--debug", is_flag=True, help="Show debugging information")
+@click.option("-c", "--config", type=click.Path(exists=True, dir_okay=False), help="Path to serve.json config")
+@click.option("-L", "--no-request-logging", is_flag=True, help="Disable request logging")
+@click.option("-C", "--cors", is_flag=True, help="Enable CORS")
+@click.option("-u", "--no-compression", is_flag=True, help="Disable compression")
+@click.option("--no-etag", is_flag=True, help="Disable ETag (use Last-Modified)")
+@click.option("-S", "--symlinks", is_flag=True, help="Resolve symlinks")
+@click.option("--ssl-cert", type=click.Path(exists=True, dir_okay=False), help="SSL/TLS certificate (PEM)")
+@click.option("--ssl-key", type=click.Path(exists=True, dir_okay=False), help="SSL/TLS private key (PEM)")
+@click.option("--ssl-pass", type=click.Path(exists=True, dir_okay=False), help="SSL/TLS passphrase file")
+@click.option("--no-port-switching", is_flag=True, help="Don't switch to another port when port is taken")
+@click.version_option(version=__version__, prog_name="ssserve")
+def main(
+    path: str,
+    listen: tuple[str, ...],
+    single: bool,
+    debug: bool,
+    config: str | None,
+    no_request_logging: bool,
+    cors: bool,
+    no_compression: bool,
+    no_etag: bool,
+    symlinks: bool,
+    ssl_cert: str | None,
+    ssl_key: str | None,
+    ssl_pass: str | None,
+    no_port_switching: bool,
+) -> None:
+    root_dir = os.path.abspath(path) if path else os.getcwd()
+
+    if not os.path.isdir(root_dir):
+        click.echo(f"Error: {path} is not a directory", err=True)
+        sys.exit(1)
+
+    cfg = load_config(config, root_dir)
+
+    if ssl_cert and not ssl_key:
+        click.echo("Error: --ssl-key is required when --ssl-cert is provided", err=True)
+        sys.exit(1)
+
+    if no_etag:
+        cfg.etag = False
+
+    if symlinks:
+        cfg.symlinks = True
+
+    ServeHandler.config = cfg
+    ServeHandler.cors = cors
+    ServeHandler.single = single
+    ServeHandler.debug = debug
+    ServeHandler.logging_enabled = not no_request_logging
+    ServeHandler.no_compression = no_compression
+    ServeHandler.no_port_switching = no_port_switching
+    ServeHandler.root_dir = root_dir
+
+    listeners = []
+    for listen_val in listen:
+        addr = parse_listen(listen_val)
+        port_switched = False
+
+        if addr.scheme == "tcp" and not no_port_switching:
+            try:
+                with socket.create_connection(("localhost", addr.port), timeout=0.5):
+                    new_port = find_free_port(addr.port + 1)
+                    click.echo(f"  Port {addr.port} is in use, using port {new_port} instead", err=True)
+                    addr.port = new_port
+                    port_switched = True
+            except (ConnectionRefusedError, OSError, socket.timeout):
+                pass
+
+        listeners.append((addr, port_switched))
+
+    ssl_active = ssl_cert is not None and ssl_key is not None
+
+    if len(listeners) == 1:
+        addr, port_switched = listeners[0]
+        _print_startup(addr, cors, ssl_active, no_port_switching, no_compression, port_switched)
+        server = _create_server(addr, ServeHandler, ssl_cert, ssl_key, ssl_pass)
+        try:
+            server.serve_forever()
+        except KeyboardInterrupt:
+            click.echo("\n  Shutting down...")
+            server.shutdown()
+    else:
+        servers = []
+        for addr, port_switched in listeners:
+            _print_startup(addr, cors, ssl_active, no_port_switching, no_compression, port_switched)
+            server = _create_server(addr, ServeHandler, ssl_cert, ssl_key, ssl_pass)
+            servers.append(server)
+
+        click.echo(f"  Serving {len(servers)} listeners")
+        click.echo("")
+
+        try:
+            for server in servers:
+                import threading
+                t = threading.Thread(target=server.serve_forever, daemon=True)
+                t.start()
+            while True:
+                time.sleep(3600)
+        except KeyboardInterrupt:
+            click.echo("\n  Shutting down...")
+            for server in servers:
+                server.shutdown()
+
+
+if __name__ == "__main__":
+    main()

ssserve-0.1.0/ssserve/config.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+
+
+@dataclass
+class Rewrite:
+    source: str
+    destination: str
+
+
+@dataclass
+class Redirect:
+    source: str
+    destination: str
+    type: int = 301
+
+
+@dataclass
+class HeaderRule:
+    source: str
+    headers: list[dict[str, str | None]]
+
+
+@dataclass
+class Config:
+    public: str | None = None
+    clean_urls: bool | list[str] = True
+    rewrites: list[Rewrite] = field(default_factory=list)
+    redirects: list[Redirect] = field(default_factory=list)
+    headers: list[HeaderRule] = field(default_factory=list)
+    directory_listing: bool | list[str] = True
+    unlisted: list[str] = field(default_factory=lambda: [".DS_Store", ".git"])
+    trailing_slash: bool | None = None
+    render_single: bool = False
+    symlinks: bool = False
+    etag: bool = False
+
+    @classmethod
+    def defaults(cls) -> Config:
+        return cls()
+
+
+def merge_config(base: Config, overrides: dict) -> Config:
+    kw = {}
+    for key, val in overrides.items():
+        match key:
+            case "public":
+                kw["public"] = str(val) if val else None
+            case "cleanUrls":
+                if isinstance(val, bool):
+                    kw["clean_urls"] = val
+                elif isinstance(val, list):
+                    kw["clean_urls"] = val
+            case "rewrites":
+                kw["rewrites"] = [Rewrite(**r) for r in val]
+            case "redirects":
+                kw["redirects"] = [Redirect(**r) for r in val]
+            case "headers":
+                kw["headers"] = [HeaderRule(**h) for h in val]
+            case "directoryListing":
+                if isinstance(val, bool):
+                    kw["directory_listing"] = val
+                elif isinstance(val, list):
+                    kw["directory_listing"] = val
+            case "unlisted":
+                kw["unlisted"] = list(val)
+            case "trailingSlash":
+                kw["trailing_slash"] = bool(val)
+            case "renderSingle":
+                kw["render_single"] = bool(val)
+            case "symlinks":
+                kw["symlinks"] = bool(val)
+            case "etag":
+                kw["etag"] = bool(val)
+    return Config(**kw)
+
+
+def load_config(path: str | None, base_dir: str | None = None) -> Config:
+    if path:
+        config_path = Path(path)
+    else:
+        search_dir = base_dir or os.getcwd()
+        for name in ("serve.json",):
+            p = Path(search_dir) / name
+            if p.exists():
+                config_path = p
+                break
+        else:
+            return Config.defaults()
+
+    if not config_path.exists():
+        return Config.defaults()
+
+    with open(config_path) as f:
+        data = json.load(f)
+
+    return merge_config(Config.defaults(), data)

ssserve-0.1.0/ssserve/handler.py

@@ -0,0 +1,466 @@
+from __future__ import annotations
+
+import gzip
+import hashlib
+import html
+import io
+import mimetypes
+import os
+import re
+import time
+import urllib.parse
+from email.utils import formatdate, parsedate
+from fnmatch import fnmatch
+from http import HTTPStatus
+from http.server import BaseHTTPRequestHandler
+
+from ssserve.config import Config
+from ssserve.listing import render_listing
+
+
+def _route_to_regex(pattern: str) -> re.Pattern:
+    parts = []
+    for segment in pattern.split("/"):
+        if segment.startswith(":"):
+            parts.append(f"(?P<{segment[1:]}>[^/]+)")
+        elif "*" in segment:
+            parts.append(re.escape(segment).replace(r"\*\*", ".*").replace(r"\*", "[^/]*"))
+        else:
+            parts.append(re.escape(segment))
+    return re.compile(f"^{'/'.join(parts)}$")
+
+
+def _apply_segments(template: str, groups: dict[str, str]) -> str:
+    result = template
+    for key, val in groups.items():
+        result = result.replace(f":{key}", val)
+    return result
+
+
+def _match_glob(path: str, pattern: str) -> bool:
+    if pattern.startswith("!"):
+        return not fnmatch(path, pattern[1:])
+    return fnmatch(path, pattern)
+
+
+def _match_glob_list(path: str, patterns: list[str]) -> bool:
+    result = False
+    for p in patterns:
+        if p.startswith("!"):
+            if fnmatch(path, p[1:]):
+                return False
+        else:
+            if fnmatch(path, p):
+                result = True
+    return result
+
+
+def _parse_byte_range(range_header: str, file_size: int) -> tuple[int, int] | None:
+    if not range_header or not range_header.startswith("bytes="):
+        return None
+    parts = range_header[6:].split("-", 1)
+    if len(parts) != 2:
+        return None
+    start_str, end_str = parts
+    try:
+        if start_str == "":
+            start = file_size - int(end_str)
+            end = file_size - 1
+        else:
+            start = int(start_str)
+            end = int(end_str) if end_str else file_size - 1
+        if start < 0 or end >= file_size or start > end:
+            return None
+        return start, end
+    except ValueError:
+        return None
+
+
+class ServeHandler(BaseHTTPRequestHandler):
+    server_version = "ssserve/0.1.0"
+    default_request_version = "HTTP/1.1"
+
+    config: Config = Config.defaults()
+    cors: bool = False
+    single: bool = False
+    debug: bool = False
+    logging_enabled: bool = True
+    no_compression: bool = False
+    no_port_switching: bool = False
+    root_dir: str = os.getcwd()
+
+    def log_message(self, format: str, *args) -> None:
+        if self.logging_enabled:
+            super().log_message(format, *args)
+
+    def _log_request(self, status: int, size: int = 0) -> None:
+        if not self.logging_enabled:
+            return
+        self.log_message('"%s %s %s" %d %d', self.command, self.path, self.request_version, status, size)
+
+    def _send_redirect(self, location: str, status: int = 301) -> None:
+        self.send_response(status)
+        self.send_header("Location", location)
+        self.send_header("Content-Length", "0")
+        self._apply_common_headers()
+        self.end_headers()
+        self._log_request(status)
+
+    def _send_error_page(self, status: int, message: str = "") -> None:
+        status_code = int(status)
+        error_page = os.path.join(self.root_dir, f"{status_code}.html")
+        content = f"<h1>{status_code} {HTTPStatus(status_code).phrase}</h1>"
+        if os.path.isfile(error_page):
+            with open(error_page, "rb") as f:
+                body = f.read()
+            content = body.decode("utf-8", errors="replace")
+        else:
+            content = f"<!doctype html><html><head><meta charset='utf-8'><title>{status_code}</title><style>body{{font-family:sans-serif;padding:40px;text-align:center}}h1{{font-weight:400;color:#333}}p{{color:#666}}</style></head><body><h1>{status_code}</h1><p>{html.escape(message)}</p></body></html>"
+            if status_code == 404:
+                content = f"<!doctype html><html><head><meta charset='utf-8'><title>404 Not Found</title><style>body{{font-family:sans-serif;padding:40px;text-align:center}}h1{{font-weight:400;color:#333}}</style></head><body><h1>404</h1><p>Not Found</p></body></html>"
+
+        body_bytes = content.encode("utf-8")
+        self.send_response(status)
+        self.send_header("Content-Type", "text/html; charset=utf-8")
+        self.send_header("Content-Length", str(len(body_bytes)))
+        self._apply_common_headers()
+        self.end_headers()
+        self.wfile.write(body_bytes)
+        self._log_request(status, len(body_bytes))
+
+    def _apply_common_headers(self) -> None:
+        if self.cors:
+            self.send_header("Access-Control-Allow-Origin", "*")
+            self.send_header("Access-Control-Allow-Headers", "*")
+            self.send_header("Access-Control-Allow-Methods", "GET, HEAD, OPTIONS")
+            self.send_header("Access-Control-Allow-Credentials", "true")
+
+    def _get_mime(self, path: str) -> str:
+        mime, _ = mimetypes.guess_type(path)
+        return mime or "application/octet-stream"
+
+    def _normalize_path(self, url_path: str) -> str:
+        parsed = urllib.parse.urlsplit(url_path)
+        path = urllib.parse.unquote(parsed.path)
+        has_trailing_slash = path.endswith("/") and path != "/"
+        path = os.path.normpath(path).replace("\\", "/")
+        if not path.startswith("/"):
+            path = "/" + path
+        if has_trailing_slash and not path.endswith("/"):
+            path += "/"
+        return path
+
+    def _resolve_path(self, url_path: str) -> str | None:
+        normalized = self._normalize_path(url_path)
+        if self.config.public:
+            base = os.path.join(self.root_dir, self.config.public)
+        else:
+            base = self.root_dir
+        fs_path = os.path.normpath(os.path.join(base, normalized.lstrip("/")))
+
+        if not fs_path.startswith(os.path.normpath(base)):
+            return None
+
+        if not self.config.symlinks and os.path.islink(fs_path):
+            return None
+
+        if not os.path.exists(fs_path):
+            return None
+
+        return fs_path
+
+    def _check_clean_urls(self, url_path: str) -> str | None:
+        if isinstance(self.config.clean_urls, bool) and not self.config.clean_urls:
+            return None
+        if url_path.endswith(".html"):
+            stripped = url_path[: -len(".html")] if url_path != "/index.html" else "/"
+            if stripped == "":
+                stripped = "/"
+            fs_path = self._resolve_with_clean_urls(stripped)
+            if fs_path:
+                return stripped
+            return None
+        return None
+
+    def _resolve_with_clean_urls(self, url_path: str) -> str | None:
+        fs_path = self._resolve_path(url_path)
+        if fs_path:
+            return fs_path
+        if self.config.clean_urls is not False:
+            html_path = url_path.rstrip("/") + ".html"
+            if url_path == "/":
+                html_path = "/index.html"
+            fs_path = self._resolve_path(html_path)
+            if fs_path and os.path.isfile(fs_path):
+                return fs_path
+        return None
+
+    def _check_trailing_slash(self, url_path: str) -> str | None:
+        if self.config.trailing_slash is None:
+            return None
+        fs_path = self._resolve_path(url_path)
+        if fs_path and os.path.isdir(fs_path):
+            if not url_path.endswith("/") and self.config.trailing_slash:
+                return url_path + "/"
+            if url_path.endswith("/") and not self.config.trailing_slash:
+                return url_path.rstrip("/") or "/"
+        if fs_path and os.path.isfile(fs_path):
+            if url_path.endswith("/") and not self.config.trailing_slash:
+                return url_path.rstrip("/") or "/"
+        return None
+
+    def _check_redirects(self, url_path: str) -> tuple[str, int] | None:
+        for rule in self.config.redirects:
+            regex = _route_to_regex(rule.source)
+            m = regex.match(url_path)
+            if m:
+                dest = _apply_segments(rule.destination, m.groupdict())
+                return dest, rule.type
+        return None
+
+    def _check_rewrites(self, url_path: str) -> str | None:
+        for rule in self.config.rewrites:
+            regex = _route_to_regex(rule.source)
+            m = regex.match(url_path)
+            if m:
+                return _apply_segments(rule.destination, m.groupdict())
+        return None
+
+    def _get_custom_headers(self, url_path: str) -> list[tuple[str, str | None]]:
+        result = []
+        for rule in self.config.headers:
+            if _match_glob(url_path, rule.source):
+                for h in rule.headers:
+                    result.append((h["key"], h.get("value")))
+        return result
+
+    def _is_listing_allowed(self, url_path: str) -> bool:
+        val = self.config.directory_listing
+        if isinstance(val, bool):
+            return val
+        return _match_glob_list(url_path, val)
+
+    def _is_unlisted(self, name: str) -> bool:
+        return _match_glob_list(name, self.config.unlisted)
+
+    def _serve_file(self, fs_path: str, url_path: str, byte_range: tuple[int, int] | None = None) -> None:
+        try:
+            stat = os.stat(fs_path)
+            file_size = stat.st_size
+            mtime = stat.st_mtime
+        except OSError:
+            self._send_error_page(500)
+            return
+
+        mime = self._get_mime(fs_path)
+        etag_val = None
+        if self.config.etag:
+            hasher = hashlib.sha256()
+            try:
+                with open(fs_path, "rb") as f:
+                    for chunk in iter(lambda: f.read(65536), b""):
+                        hasher.update(chunk)
+                etag_val = f'"{hasher.hexdigest()}"'
+            except OSError:
+                etag_val = None
+
+        if byte_range:
+            status = HTTPStatus.PARTIAL_CONTENT
+            start, end = byte_range
+            content_length = end - start + 1
+        else:
+            status = HTTPStatus.OK
+            content_length = file_size
+
+            if etag_val:
+                if_none_match = self.headers.get("If-None-Match")
+                if if_none_match and if_none_match.strip('" ') == etag_val.strip('" '):
+                    self.send_response(HTTPStatus.NOT_MODIFIED)
+                    self._apply_common_headers()
+                    if etag_val:
+                        self.send_header("ETag", etag_val)
+                    self.end_headers()
+                    self._log_request(304)
+                    return
+            else:
+                ims = self.headers.get("If-Modified-Since")
+                if ims:
+                    try:
+                        ims_time = time.mktime(parsedate(ims))
+                        if int(mtime) <= int(ims_time):
+                            self.send_response(HTTPStatus.NOT_MODIFIED)
+                            self._apply_common_headers()
+                            self.end_headers()
+                            self._log_request(304)
+                            return
+                    except (TypeError, OSError):
+                        pass
+
+        accept_encoding = self.headers.get("Accept-Encoding", "")
+        use_gzip = (
+            not self.no_compression
+            and "gzip" in accept_encoding
+        )
+
+        gzipped_data = None
+        if use_gzip and not byte_range:
+            try:
+                with open(fs_path, "rb") as f:
+                    raw = f.read()
+                gzipped_data = gzip.compress(raw)
+                content_length = len(gzipped_data)
+            except OSError:
+                gzipped_data = None
+        else:
+            gzipped_data = None
+
+        self.send_response(status)
+        self.send_header("Content-Type", mime)
+        if content_length is not None:
+            self.send_header("Content-Length", str(content_length))
+        if etag_val:
+            self.send_header("ETag", etag_val)
+        else:
+            self.send_header("Last-Modified", formatdate(mtime, usegmt=True))
+        if byte_range:
+            self.send_header("Content-Range", f"bytes {byte_range[0]}-{byte_range[1]}/{file_size}")
+        if not self.config.etag:
+            self.send_header("Accept-Ranges", "bytes")
+        if gzipped_data is not None:
+            self.send_header("Content-Encoding", "gzip")
+
+        for key, val in self._get_custom_headers(url_path):
+            if val is None:
+                self.send_header(key, "")
+            else:
+                self.send_header(key, val)
+
+        self._apply_common_headers()
+        self.end_headers()
+
+        if self.command == "HEAD":
+            self._log_request(status, file_size)
+            return
+
+        try:
+            if gzipped_data is not None:
+                self.wfile.write(gzipped_data)
+            elif byte_range:
+                with open(fs_path, "rb") as f:
+                    f.seek(byte_range[0])
+                    remaining = byte_range[1] - byte_range[0] + 1
+                    while remaining > 0:
+                        chunk_size = min(65536, remaining)
+                        data = f.read(chunk_size)
+                        if not data:
+                            break
+                        self.wfile.write(data)
+                        remaining -= len(data)
+            else:
+                with open(fs_path, "rb") as f:
+                    self.copyfile(f, self.wfile)
+        except OSError:
+            pass
+
+        self._log_request(status, file_size)
+
+    def _handle_request(self) -> None:
+        url_path = self._normalize_path(self.path)
+
+        if url_path != self.path:
+            self._send_redirect(url_path, 301)
+            return
+
+        cu_result = self._check_clean_urls(url_path)
+        if cu_result:
+            self._send_redirect(cu_result, 301)
+            return
+
+        ts_result = self._check_trailing_slash(url_path)
+        if ts_result:
+            self._send_redirect(ts_result, 301)
+            return
+
+        redirect = self._check_redirects(url_path)
+        if redirect:
+            dest, status = redirect
+            self._send_redirect(dest, status)
+            return
+
+        rewritten = self._check_rewrites(url_path)
+        if rewritten:
+            url_path = rewritten
+
+        fs_path = self._resolve_with_clean_urls(url_path)
+
+        if fs_path and os.path.isdir(fs_path):
+            for index in ("index.html", "index.htm"):
+                index_path = os.path.join(fs_path, index)
+                if os.path.isfile(index_path):
+                    self._serve_file(index_path, url_path.rstrip("/") + "/" + index)
+                    return
+
+            if self.config.render_single:
+                entries = [e for e in os.scandir(fs_path) if not self._is_unlisted(e.name)]
+                if len(entries) == 1:
+                    entry = entries[0]
+                    file_path = os.path.join(fs_path, entry.name)
+                    if entry.is_file():
+                        sub_url = url_path.rstrip("/") + "/" + entry.name
+                        self._serve_file(file_path, sub_url)
+                        return
+
+            if self._is_listing_allowed(url_path):
+                try:
+                    entries = sorted(os.scandir(fs_path), key=lambda e: (not e.is_dir(), e.name.lower()))
+                    entries = [e for e in entries if not self._is_unlisted(e.name)]
+                    if not url_path.endswith("/"):
+                        self._send_redirect(url_path + "/", 301)
+                        return
+                    html = render_listing(url_path, fs_path, entries)
+                    body = html.encode("utf-8")
+                    self.send_response(HTTPStatus.OK)
+                    self.send_header("Content-Type", "text/html; charset=utf-8")
+                    self.send_header("Content-Length", str(len(body)))
+                    self._apply_common_headers()
+                    self.end_headers()
+                    if self.command != "HEAD":
+                        self.wfile.write(body)
+                    self._log_request(200, len(body))
+                    return
+                except OSError:
+                    pass
+
+            self._send_error_page(404)
+            return
+
+        if fs_path and os.path.isfile(fs_path):
+            range_header = self.headers.get("Range", "")
+            byte_range = _parse_byte_range(range_header, os.path.getsize(fs_path))
+            self._serve_file(fs_path, url_path, byte_range)
+            return
+
+        if self.single:
+            index_path = os.path.join(self.root_dir, "index.html")
+            if os.path.isfile(index_path):
+                self._serve_file(index_path, "/index.html")
+                return
+
+        self._send_error_page(404)
+
+    def do_GET(self) -> None:
+        self._handle_request()
+
+    def do_HEAD(self) -> None:
+        self._handle_request()
+
+    def do_OPTIONS(self) -> None:
+        self.send_response(HTTPStatus.NO_CONTENT)
+        self._apply_common_headers()
+        self.end_headers()
+
+    def copyfile(self, source: io.IOBase, output: io.IOBase) -> None:
+        buf = source.read(65536)
+        while buf:
+            output.write(buf)
+            buf = source.read(65536)

ssserve-0.1.0/ssserve/listing.py

@@ -0,0 +1,111 @@
+import html
+import math
+import os
+import time
+
+
+def format_size(size: int) -> str:
+    if size == 0:
+        return "0 B"
+    units = ["B", "KB", "MB", "GB", "TB"]
+    i = int(math.floor(math.log(size, 1024))) if size > 0 else 0
+    i = min(i, len(units) - 1)
+    s = size / (1024**i)
+    return f"{s:.1f} {units[i]}" if i > 0 else f"{s:.0f} B"
+
+
+def format_date(timestamp: float) -> str:
+    return time.strftime("%Y-%m-%d %H:%M", time.localtime(timestamp))
+
+
+LISTING_TEMPLATE = """\
+<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<title>Index of {path}</title>
+<style>
+*{{margin:0;padding:0;box-sizing:border-box}}
+body{{font-family:-apple-system,BlinkMacSystemFont,"Segoe UI",Roboto,Oxygen,Ubuntu,Cantarell,sans-serif;font-size:14px;color:#333;background:#fafafa;padding:20px}}
+h1{{font-weight:500;font-size:18px;margin-bottom:16px;color:#111}}
+table{{width:100%;border-collapse:collapse}}
+th{{text-align:left;font-weight:500;font-size:12px;text-transform:uppercase;color:#888;padding:8px 12px;border-bottom:2px solid #eaeaea}}
+td{{padding:8px 12px;border-bottom:1px solid #eee}}
+tr:hover td{{background:#f5f5f5}}
+a{{color:#067df7;text-decoration:none}}
+a:hover{{text-decoration:underline}}
+.icon{{width:20px;display:inline-block;text-align:center;margin-right:8px;color:#888}}
+.size{{text-align:right;font-variant-numeric:tabular-nums;color:#666}}
+.date{{color:#888}}
+.folder .icon{{color:#f5a623}}
+.file .icon{{color:#666}}
+.parent{{font-weight:500}}
+.footer{{margin-top:20px;font-size:12px;color:#999;text-align:center}}
+</style>
+</head>
+<body>
+<h1>Index of {path}</h1>
+<table>
+<tr><th>Name</th><th class="size">Size</th><th class="date">Modified</th></tr>
+{parent_row}
+{entries}
+</table>
+<div class="footer">ssserve · Python port of vercel/serve</div>
+</body>
+</html>"""
+
+
+def render_listing(path: str, base_dir: str, entries: list[os.DirEntry]) -> str:
+    normalized = "/" + path.strip("/")
+    rows = []
+
+    if path != "/":
+        parent = "/" if normalized == "/" else normalized.rsplit("/", 1)[0] or "/"
+        rows.append(
+            '<tr class="parent">'
+            f'<td><a href="{html.escape(parent)}"><span class="icon">&#128193;</span>..</a></td>'
+            '<td class="size">-</td>'
+            '<td class="date">-</td>'
+            "</tr>"
+        )
+
+    for entry in sorted(entries, key=lambda e: (not e.is_dir(), e.name.lower())):
+        name = entry.name
+        href = normalized.rstrip("/") + "/" + name
+        is_dir = entry.is_dir()
+
+        if is_dir:
+            icon = "&#128193;"
+            size_display = "-"
+            cls = "folder"
+        else:
+            icon = "&#128196;"
+            try:
+                stat = entry.stat()
+                size_display = format_size(stat.st_size)
+                date_display = format_date(stat.st_mtime)
+            except OSError:
+                size_display = "?"
+                date_display = "-"
+            cls = "file"
+
+        try:
+            stat = entry.stat()
+            date_display = format_date(stat.st_mtime)
+        except OSError:
+            date_display = "-"
+
+        dir_slash = "/" if is_dir else ""
+        rows.append(
+            f'<tr class="{cls}">'
+            f'<td><a href="{html.escape(href)}"><span class="icon">{icon}</span>{html.escape(name)}{dir_slash}</a></td>'
+            f'<td class="size">{size_display}</td>'
+            f'<td class="date">{date_display}</td>'
+            "</tr>"
+        )
+
+    return LISTING_TEMPLATE.format(
+        path=html.escape(normalized),
+        parent_row="\n".join(rows[:1]) if path != "/" else "",
+        entries="\n".join(rows[1:] if path != "/" else rows),
+    )

ssserve-0.1.0/ssserve/network.py

@@ -0,0 +1,96 @@
+import os
+import socket
+import struct
+from dataclasses import dataclass
+
+
+@dataclass
+class Address:
+    scheme: str
+    host: str
+    port: int
+    path: str | None
+
+    def __str__(self) -> str:
+        if self.scheme == "unix":
+            return f"unix:{self.path}"
+        host = self.host or "0.0.0.0"
+        if ":" in host:
+            host = f"[{host}]"
+        return f"{host}:{self.port}"
+
+
+def parse_listen(value: str) -> Address:
+    value = value.strip()
+
+    if value.startswith("unix:"):
+        return Address(scheme="unix", host="", port=0, path=value[5:])
+
+    if value.startswith("tcp://"):
+        rest = value[6:]
+        if rest.startswith("["):
+            bracket_end = rest.find("]")
+            if bracket_end == -1:
+                raise ValueError(f"Invalid IPv6 address in listen URI: {value}")
+            host = rest[1:bracket_end]
+            after = rest[bracket_end + 1 :]
+            if after.startswith(":"):
+                port = int(after[1:])
+            else:
+                port = 3000
+        elif ":" in rest:
+            host, port_str = rest.rsplit(":", 1)
+            port = int(port_str)
+        else:
+            host = rest
+            port = 3000
+        return Address(scheme="tcp", host=host, port=port, path=None)
+
+    if value.startswith("pipe:"):
+        raise ValueError("Windows named pipes are not supported")
+
+    try:
+        port = int(value)
+        return Address(scheme="tcp", host="", port=port, path=None)
+    except ValueError:
+        pass
+
+    if ":" in value:
+        host, port_str = value.rsplit(":", 1)
+        try:
+            port = int(port_str)
+        except ValueError:
+            raise ValueError(f"Invalid listen URI: {value}")
+        return Address(scheme="tcp", host=host, port=port, path=None)
+
+    return Address(scheme="tcp", host=value, port=3000, path=None)
+
+
+def find_free_port(start: int = 3000, max_attempts: int = 100) -> int:
+    port = start
+    for _ in range(max_attempts):
+        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+            try:
+                s.bind(("", port))
+                return port
+            except OSError:
+                port += 1
+    raise RuntimeError("Could not find a free port")
+
+
+def get_lan_ip() -> str | None:
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    try:
+        s.connect(("10.255.255.255", 1))
+        ip = s.getsockname()[0]
+        return ip
+    except Exception:
+        pass
+    finally:
+        s.close()
+
+    try:
+        hostname = socket.gethostname()
+        return socket.gethostbyname(hostname)
+    except Exception:
+        return None

ssserve-0.1.0/ssserve.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: ssserve
+Version: 0.1.0
+Summary: Static file serving and directory listing — Python port of vercel/serve
+License: MIT
+Requires-Python: >=3.10
+Requires-Dist: click>=8.0

ssserve-0.1.0/ssserve.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+ssserve/__init__.py
+ssserve/__main__.py
+ssserve/cli.py
+ssserve/config.py
+ssserve/handler.py
+ssserve/listing.py
+ssserve/network.py
+ssserve.egg-info/PKG-INFO
+ssserve.egg-info/SOURCES.txt
+ssserve.egg-info/dependency_links.txt
+ssserve.egg-info/entry_points.txt
+ssserve.egg-info/requires.txt
+ssserve.egg-info/top_level.txt

ssserve-0.1.0/ssserve.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ssserve-0.1.0/ssserve.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ssserve = ssserve.cli:main

ssserve-0.1.0/ssserve.egg-info/requires.txt

@@ -0,0 +1 @@
+click>=8.0

ssserve-0.1.0/ssserve.egg-info/top_level.txt

@@ -0,0 +1 @@
+ssserve