sharedserver 0.1.0__py3-none-any.whl

sharedserver/__init__.py

@@ -0,0 +1,4 @@
+"""SharedServer package."""
+
+__version__ = "0.1.0"
+

sharedserver/__main__.py

@@ -0,0 +1,6 @@
+from .cli import main
+
+
+if __name__ == "__main__":
+    main()
+

sharedserver/cli.py

@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+import argparse
+import copy
+import socket
+from pathlib import Path
+from typing import Sequence
+
+import uvicorn
+
+from . import __version__
+from .config import load_config
+from .server import create_app
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="sharedserver",
+        description="LAN file sharing and real-time text clipboard",
+    )
+    parser.add_argument("port", nargs="?", type=int, help="port to listen on")
+    parser.add_argument("--host", help="host to bind (default: 0.0.0.0)")
+    parser.add_argument("-d", "--directory", type=Path, help="directory to share")
+    parser.add_argument("-c", "--config", type=Path, help="YAML configuration file")
+    parser.add_argument(
+        "--max-upload-size",
+        type=int,
+        metavar="MB",
+        help="maximum upload size in MiB",
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    return parser
+
+
+def get_lan_ip() -> str:
+    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    try:
+        sock.connect(("8.8.8.8", 80))
+        return str(sock.getsockname()[0])
+    except OSError:
+        try:
+            return socket.gethostbyname(socket.gethostname())
+        except OSError:
+            return "127.0.0.1"
+    finally:
+        sock.close()
+
+
+def main(argv: Sequence[str] | None = None) -> None:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    try:
+        config = load_config(args.config).with_cli_overrides(
+            host=args.host,
+            port=args.port,
+            directory=args.directory.expanduser().resolve() if args.directory else None,
+            max_upload_size=(
+                args.max_upload_size * 1024 * 1024
+                if args.max_upload_size is not None
+                else None
+            ),
+        )
+        app = create_app(config)
+    except (FileNotFoundError, NotADirectoryError, ValueError) as exc:
+        parser.error(str(exc))
+
+    port = config.server.port
+    print(
+        "SharedServer running:\n\n"
+        f"Local:\nhttp://127.0.0.1:{port}\n\n"
+        f"LAN:\nhttp://{get_lan_ip()}:{port}\n\n"
+        f"Sharing: {config.share.directory}\n"
+    )
+    log_config = copy.deepcopy(uvicorn.config.LOGGING_CONFIG)
+    log_config["loggers"]["uvicorn.error"]["level"] = "WARNING"
+    uvicorn.run(app, host=config.server.host, port=port, log_config=log_config)

sharedserver/clipboard.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Literal
+
+from .config import ClipboardConfig
+
+CopyKind = Literal["text", "image"]
+
+
+class ClipboardPolicy:
+    def __init__(self, config: ClipboardConfig):
+        self.text_extensions = frozenset(config.text_extensions)
+        self.image_extensions = frozenset(config.image_extensions)
+        self.max_text_size = config.max_text_size
+
+    def copy_kind(self, path: Path) -> CopyKind | None:
+        suffix = path.suffix.lower()
+        if suffix in self.text_extensions:
+            return "text"
+        if suffix in self.image_extensions:
+            return "image"
+        return None
+
+    def read_text(self, path: Path) -> str:
+        if self.copy_kind(path) != "text":
+            raise ValueError("file type is not allowed for text copying")
+        with path.open("rb") as source:
+            content = source.read(self.max_text_size + 1)
+        if len(content) > self.max_text_size:
+            raise ValueError("text file is too large to copy")
+        return content.decode("utf-8-sig", errors="replace")

sharedserver/config.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field, replace
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+DEFAULT_TEXT_EXTENSIONS = (
+    ".txt", ".md", ".json", ".xml", ".yaml", ".yml", ".csv", ".log",
+    ".py", ".js", ".html", ".css", ".java", ".c", ".cpp",
+)
+DEFAULT_IMAGE_EXTENSIONS = (".png", ".jpg", ".jpeg", ".webp")
+
+
+@dataclass(frozen=True)
+class ServerConfig:
+    host: str = "0.0.0.0"
+    port: int = 8000
+
+
+@dataclass(frozen=True)
+class ShareConfig:
+    directory: Path = field(default_factory=Path.cwd)
+    max_upload_size: int = 1024 * 1024 * 1024
+
+
+@dataclass(frozen=True)
+class ClipboardConfig:
+    text_extensions: tuple[str, ...] = DEFAULT_TEXT_EXTENSIONS
+    image_extensions: tuple[str, ...] = DEFAULT_IMAGE_EXTENSIONS
+    max_text_size: int = 2 * 1024 * 1024
+
+
+@dataclass(frozen=True)
+class AppConfig:
+    server: ServerConfig = field(default_factory=ServerConfig)
+    share: ShareConfig = field(default_factory=ShareConfig)
+    clipboard: ClipboardConfig = field(default_factory=ClipboardConfig)
+
+    def with_cli_overrides(
+        self,
+        *,
+        host: str | None = None,
+        port: int | None = None,
+        directory: Path | None = None,
+        max_upload_size: int | None = None,
+    ) -> "AppConfig":
+        server = replace(
+            self.server,
+            host=host if host is not None else self.server.host,
+            port=port if port is not None else self.server.port,
+        )
+        share = replace(
+            self.share,
+            directory=directory if directory is not None else self.share.directory,
+            max_upload_size=(
+                max_upload_size
+                if max_upload_size is not None
+                else self.share.max_upload_size
+            ),
+        )
+        result = replace(self, server=server, share=share)
+        _validate(result)
+        return result
+
+
+def _extensions(value: Any, default: tuple[str, ...]) -> tuple[str, ...]:
+    if value is None:
+        return default
+    if not isinstance(value, list) or not all(isinstance(item, str) for item in value):
+        raise ValueError("clipboard extension lists must contain strings")
+    normalized = tuple(
+        dict.fromkeys(
+            (
+                item.strip().lower()
+                if item.strip().startswith(".")
+                else f".{item.strip().lower()}"
+            )
+            for item in value
+            if item.strip()
+        )
+    )
+    if any("/" in item or "\\" in item for item in normalized):
+        raise ValueError("clipboard extensions cannot contain path separators")
+    return normalized
+
+
+def _section(data: dict[str, Any], name: str) -> dict[str, Any]:
+    value = data.get(name, {})
+    if not isinstance(value, dict):
+        raise ValueError(f"{name} must be a mapping")
+    return value
+
+
+def load_config(path: Path | None = None) -> AppConfig:
+    config_path = path or Path.cwd() / "sharedserver.yaml"
+    if path is None and not config_path.exists():
+        result = AppConfig()
+        _validate(result)
+        return result
+    if not config_path.is_file():
+        raise FileNotFoundError(f"configuration file not found: {config_path}")
+
+    raw = yaml.safe_load(config_path.read_text(encoding="utf-8")) or {}
+    if not isinstance(raw, dict):
+        raise ValueError("configuration root must be a mapping")
+    server_data = _section(raw, "server")
+    share_data = _section(raw, "share")
+    clipboard_data = _section(raw, "clipboard")
+
+    directory_value = Path(str(share_data.get("directory", "."))).expanduser()
+    if not directory_value.is_absolute():
+        directory_value = config_path.resolve().parent / directory_value
+
+    result = AppConfig(
+        server=ServerConfig(
+            host=str(server_data.get("host", "0.0.0.0")),
+            port=int(server_data.get("port", 8000)),
+        ),
+        share=ShareConfig(
+            directory=directory_value.resolve(),
+            max_upload_size=int(
+                share_data.get("max_upload_size", 1024 * 1024 * 1024)
+            ),
+        ),
+        clipboard=ClipboardConfig(
+            text_extensions=_extensions(
+                clipboard_data.get("text_extensions"), DEFAULT_TEXT_EXTENSIONS
+            ),
+            image_extensions=_extensions(
+                clipboard_data.get("image_extensions"), DEFAULT_IMAGE_EXTENSIONS
+            ),
+            max_text_size=int(
+                clipboard_data.get("max_text_size", 2 * 1024 * 1024)
+            ),
+        ),
+    )
+    _validate(result)
+    return result
+
+
+def _validate(config: AppConfig) -> None:
+    if not config.server.host:
+        raise ValueError("server.host cannot be empty")
+    if not 1 <= config.server.port <= 65535:
+        raise ValueError("server.port must be between 1 and 65535")
+    if config.share.max_upload_size <= 0:
+        raise ValueError("share.max_upload_size must be positive")
+    if config.clipboard.max_text_size <= 0:
+        raise ValueError("clipboard.max_text_size must be positive")

sharedserver/file_manager.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+import os
+import shutil
+import tempfile
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import AsyncIterable
+
+from .clipboard import ClipboardPolicy
+from .models import DirectoryListing, FileEntry, UploadResult
+from .security import SecurityError, resolve_within, sanitize_filename
+
+
+class UploadTooLargeError(ValueError):
+    pass
+
+
+class FileManager:
+    def __init__(self, root: Path, max_upload_size: int, policy: ClipboardPolicy):
+        if not root.exists():
+            raise FileNotFoundError(f"shared directory does not exist: {root}")
+        if not root.is_dir():
+            raise NotADirectoryError(f"shared path is not a directory: {root}")
+        self.root = root.resolve(strict=True)
+        self.max_upload_size = max_upload_size
+        self.policy = policy
+
+    def path(self, relative: str, *, must_exist: bool = True) -> Path:
+        return resolve_within(self.root, relative, must_exist=must_exist)
+
+    def relative(self, path: Path) -> str:
+        return "" if path == self.root else path.relative_to(self.root).as_posix()
+
+    def list_directory(self, relative: str = "") -> DirectoryListing:
+        directory = self.path(relative)
+        if not directory.is_dir():
+            raise NotADirectoryError(relative)
+
+        entries: list[FileEntry] = []
+        for child in directory.iterdir():
+            if child.is_symlink() or child.name.startswith(".sharedserver-"):
+                continue
+            try:
+                stat = child.stat()
+            except OSError:
+                continue
+            is_directory = child.is_dir()
+            entries.append(
+                FileEntry(
+                    name=child.name,
+                    path=self.relative(child),
+                    is_directory=is_directory,
+                    size=None if is_directory else stat.st_size,
+                    modified=datetime.fromtimestamp(
+                        stat.st_mtime, tz=timezone.utc
+                    ).isoformat(),
+                    copy_kind=None if is_directory else self.policy.copy_kind(child),
+                )
+            )
+        entries.sort(key=lambda entry: (not entry.is_directory, entry.name.casefold()))
+        current = self.relative(directory)
+        parent = None if directory == self.root else self.relative(directory.parent)
+        return DirectoryListing(path=current, parent=parent, entries=entries)
+
+    def create_directory(self, relative: str, raw_name: str) -> str:
+        parent = self.path(relative)
+        if not parent.is_dir():
+            raise NotADirectoryError(relative)
+        name = sanitize_filename(raw_name)
+        destination = resolve_within(parent, name, must_exist=False)
+        destination.mkdir()
+        return self.relative(destination)
+
+    def regular_file(self, relative: str) -> Path:
+        path = self.path(relative)
+        if not path.is_file() or path.is_symlink():
+            raise FileNotFoundError(relative)
+        return path
+
+    async def save_upload(
+        self,
+        relative: str,
+        raw_name: str,
+        chunks: AsyncIterable[bytes],
+    ) -> UploadResult:
+        directory = self.path(relative)
+        if not directory.is_dir():
+            raise NotADirectoryError(relative)
+        name = sanitize_filename(raw_name)
+        destination = resolve_within(directory, name, must_exist=False)
+        if destination.exists() or destination.is_symlink():
+            raise FileExistsError(name)
+
+        size = 0
+        temp_path: Path | None = None
+        fallback_destination_created = False
+        try:
+            with tempfile.NamedTemporaryFile(
+                mode="wb", prefix=".sharedserver-", dir=directory, delete=False
+            ) as temporary:
+                temp_path = Path(temporary.name)
+                async for chunk in chunks:
+                    size += len(chunk)
+                    if size > self.max_upload_size:
+                        raise UploadTooLargeError(
+                            f"upload exceeds {self.max_upload_size} bytes"
+                        )
+                    temporary.write(chunk)
+                temporary.flush()
+                os.fsync(temporary.fileno())
+
+            try:
+                os.link(temp_path, destination)
+            except FileExistsError:
+                raise
+            except OSError:
+                # Some network and removable filesystems do not support hard links.
+                with temp_path.open("rb") as source, destination.open("xb") as target:
+                    fallback_destination_created = True
+                    shutil.copyfileobj(source, target)
+            return UploadResult(name=name, path=self.relative(destination), size=size)
+        except FileExistsError:
+            raise
+        except Exception:
+            if fallback_destination_created:
+                destination.unlink(missing_ok=True)
+            raise
+        finally:
+            if temp_path is not None:
+                temp_path.unlink(missing_ok=True)

sharedserver/models.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import BaseModel, Field
+
+
+class FileEntry(BaseModel):
+    name: str
+    path: str
+    is_directory: bool
+    size: int | None
+    modified: str
+    copy_kind: Literal["text", "image"] | None = None
+
+
+class DirectoryListing(BaseModel):
+    path: str
+    parent: str | None
+    entries: list[FileEntry]
+
+
+class DirectoryCreate(BaseModel):
+    path: str = ""
+    name: str = Field(min_length=1, max_length=255)
+
+
+class ClipboardUpdate(BaseModel):
+    type: Literal["clipboard"]
+    content: str = Field(max_length=1_000_000)
+
+
+class TextContent(BaseModel):
+    content: str
+
+
+class UploadResult(BaseModel):
+    name: str
+    path: str
+    size: int
+

sharedserver/security.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+import re
+import unicodedata
+from pathlib import Path, PurePosixPath, PureWindowsPath
+
+
+class SecurityError(ValueError):
+    """Raised when user input attempts to escape the shared directory."""
+
+
+WINDOWS_RESERVED = {
+    "CON", "PRN", "AUX", "NUL",
+    *(f"COM{number}" for number in range(1, 10)),
+    *(f"LPT{number}" for number in range(1, 10)),
+}
+INVALID_FILENAME_CHARS = re.compile(r'[<>:"/\\|?*\x00-\x1f]')
+
+
+def resolve_within(root: Path, supplied: str = "", *, must_exist: bool = True) -> Path:
+    root = root.resolve(strict=True)
+    if "\x00" in supplied:
+        raise SecurityError("path contains a null byte")
+
+    normalized = supplied.replace("\\", "/")
+    posix_path = PurePosixPath(normalized)
+    windows_path = PureWindowsPath(supplied)
+    if posix_path.is_absolute() or windows_path.is_absolute() or windows_path.drive:
+        raise SecurityError("absolute paths are not allowed")
+    if ".." in posix_path.parts:
+        raise SecurityError("parent path segments are not allowed")
+
+    try:
+        candidate = (root / Path(*posix_path.parts)).resolve(strict=must_exist)
+        candidate.relative_to(root)
+    except (OSError, ValueError) as exc:
+        raise SecurityError("path is outside the shared directory") from exc
+    return candidate
+
+
+def sanitize_filename(raw_name: str) -> str:
+    name = unicodedata.normalize("NFC", raw_name.replace("\\", "/").split("/")[-1])
+    name = INVALID_FILENAME_CHARS.sub("_", name).strip().rstrip(". ")
+    if name in {"", ".", ".."}:
+        name = "upload"
+    if name.split(".", 1)[0].upper() in WINDOWS_RESERVED:
+        name = f"_{name}"
+    while len(name.encode("utf-8")) > 240:
+        name = name[:-1]
+    return name
+

sharedserver/server.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+from pathlib import Path
+from urllib.parse import urlsplit
+
+from fastapi import FastAPI, HTTPException, Query, Request, WebSocket
+from fastapi.responses import FileResponse, HTMLResponse
+from fastapi.staticfiles import StaticFiles
+
+from .clipboard import ClipboardPolicy
+from .config import AppConfig
+from .file_manager import FileManager, UploadTooLargeError
+from .models import (
+    DirectoryCreate,
+    DirectoryListing,
+    TextContent,
+    UploadResult,
+)
+from .security import SecurityError
+from .websocket import ClipboardHub
+
+
+def _http_error(exc: Exception) -> HTTPException:
+    if isinstance(exc, SecurityError):
+        return HTTPException(status_code=403, detail=str(exc))
+    if isinstance(exc, (FileNotFoundError, NotADirectoryError)):
+        return HTTPException(status_code=404, detail="file or directory not found")
+    if isinstance(exc, FileExistsError):
+        return HTTPException(status_code=409, detail="a file with that name already exists")
+    if isinstance(exc, UploadTooLargeError):
+        return HTTPException(status_code=413, detail=str(exc))
+    return HTTPException(status_code=400, detail=str(exc))
+
+
+def _same_origin(websocket: WebSocket) -> bool:
+    origin = websocket.headers.get("origin")
+    host = websocket.headers.get("host")
+    return not origin or not host or urlsplit(origin).netloc.casefold() == host.casefold()
+
+
+def create_app(config: AppConfig) -> FastAPI:
+    package_dir = Path(__file__).parent
+    policy = ClipboardPolicy(config.clipboard)
+    manager = FileManager(config.share.directory, config.share.max_upload_size, policy)
+    hub = ClipboardHub()
+
+    app = FastAPI(title="SharedServer", version="0.1.0", docs_url=None, redoc_url=None)
+    app.state.config = config
+    app.state.file_manager = manager
+    app.state.clipboard_hub = hub
+    app.mount("/static", StaticFiles(directory=package_dir / "static"), name="static")
+
+    @app.middleware("http")
+    async def security_headers(request: Request, call_next):
+        response = await call_next(request)
+        response.headers["X-Content-Type-Options"] = "nosniff"
+        response.headers["X-Frame-Options"] = "DENY"
+        response.headers["Referrer-Policy"] = "no-referrer"
+        response.headers["Content-Security-Policy"] = (
+            "default-src 'self'; connect-src 'self' ws: wss:; "
+            "img-src 'self' blob: data:; object-src 'none'; frame-ancestors 'none'"
+        )
+        return response
+
+    @app.get("/", response_class=HTMLResponse, include_in_schema=False)
+    async def index() -> HTMLResponse:
+        html = (package_dir / "templates" / "index.html").read_text(encoding="utf-8")
+        return HTMLResponse(html, headers={"Cache-Control": "no-store"})
+
+    @app.get("/api/files", response_model=DirectoryListing)
+    async def list_files(path: str = Query(default="")) -> DirectoryListing:
+        try:
+            return manager.list_directory(path)
+        except (SecurityError, FileNotFoundError, NotADirectoryError, OSError) as exc:
+            raise _http_error(exc) from exc
+
+    @app.post("/api/directories", status_code=201)
+    async def create_directory(body: DirectoryCreate) -> dict[str, str]:
+        try:
+            return {"path": manager.create_directory(body.path, body.name)}
+        except (SecurityError, FileNotFoundError, NotADirectoryError, FileExistsError, OSError) as exc:
+            raise _http_error(exc) from exc
+
+    @app.put("/api/upload", response_model=UploadResult, status_code=201)
+    async def upload(
+        request: Request,
+        path: str = Query(default=""),
+        filename: str = Query(min_length=1, max_length=1024),
+    ) -> UploadResult:
+        content_length = request.headers.get("content-length")
+        if content_length:
+            try:
+                if int(content_length) > config.share.max_upload_size:
+                    raise HTTPException(status_code=413, detail="upload is too large")
+            except ValueError as exc:
+                raise HTTPException(status_code=400, detail="invalid Content-Length") from exc
+        try:
+            return await manager.save_upload(path, filename, request.stream())
+        except (
+            SecurityError,
+            FileNotFoundError,
+            NotADirectoryError,
+            FileExistsError,
+            UploadTooLargeError,
+            OSError,
+        ) as exc:
+            raise _http_error(exc) from exc
+
+    @app.get("/api/download")
+    async def download(path: str = Query(min_length=1)) -> FileResponse:
+        try:
+            file = manager.regular_file(path)
+            return FileResponse(file, filename=file.name)
+        except (SecurityError, FileNotFoundError, OSError) as exc:
+            raise _http_error(exc) from exc
+
+    @app.get("/api/text", response_model=TextContent)
+    async def text_content(path: str = Query(min_length=1)) -> TextContent:
+        try:
+            file = manager.regular_file(path)
+            return TextContent(content=policy.read_text(file))
+        except (SecurityError, FileNotFoundError, ValueError, OSError) as exc:
+            raise _http_error(exc) from exc
+
+    @app.get("/api/image")
+    async def image_content(path: str = Query(min_length=1)) -> FileResponse:
+        try:
+            file = manager.regular_file(path)
+            if policy.copy_kind(file) != "image":
+                raise ValueError("file type is not allowed for image copying")
+            return FileResponse(file, headers={"Cache-Control": "no-store"})
+        except (SecurityError, FileNotFoundError, ValueError, OSError) as exc:
+            raise _http_error(exc) from exc
+
+    @app.websocket("/ws")
+    async def clipboard_socket(websocket: WebSocket) -> None:
+        if not _same_origin(websocket):
+            await websocket.close(code=1008, reason="origin not allowed")
+            return
+        await hub.handle(websocket)
+
+    return app