A reactive notebook for Python — run reproducible experiments, query with SQL, execute as a script, deploy as an app, and version with git. Stored as pure Python. All in a modern, AI-native editor.
Python artificial-intelligencedagdata-sciencedata-visualizationdataflowdeveloper-toolsmachine-learningnotebookspipelinepythonreactivesqlweb-app
refactor: cleanup app-router (#7628)
Myles Scolnickbfb742acaef4
diff --git a/marimo/_pyodide/bootstrap.py b/marimo/_pyodide/bootstrap.pyindex de91ad5e02..7a301aaaf5 100644--- a/marimo/_pyodide/bootstrap.py+++ b/marimo/_pyodide/bootstrap.py@@ -20,6 +20,7 @@ from marimo._runtime.commands import (SerializedQueryParams,UpdateUIElementCommand,)+from marimo._server.app_defaults import AppDefaultsfrom marimo._server.models.models import SaveNotebookRequestfrom marimo._session.model import SessionModefrom marimo._session.notebook import AppFileManager@@ -103,8 +104,10 @@ def create_session(app_file_manager = AppFileManager(filename=filename,- default_width=user_config["display"]["default_width"],- default_sql_output=user_config["runtime"]["default_sql_output"],+ defaults=AppDefaults(+ width=user_config["display"]["default_width"],+ sql_output=user_config["runtime"]["default_sql_output"],+ ),)app = app_file_manager.appdiff --git a/marimo/_server/api/endpoints/assets.py b/marimo/_server/api/endpoints/assets.pyindex a222136883..394bc47a29 100644--- a/marimo/_server/api/endpoints/assets.py+++ b/marimo/_server/api/endpoints/assets.py@@ -16,7 +16,7 @@ from marimo._config.manager import get_default_config_managerfrom marimo._output.utils import uri_decode_component, uri_encode_componentfrom marimo._runtime.virtual_file import EMPTY_VIRTUAL_FILE, read_virtual_filefrom marimo._server.api.deps import AppState-from marimo._server.file_router import validate_inside_directory+from marimo._server.files.path_validator import PathValidatorfrom marimo._server.router import APIRouterfrom marimo._server.templates.templates import (home_page_template,@@ -313,7 +313,8 @@ async def serve_public_file(request: Request) -> Response:# Security check: ensure file is inside public directorytry:- validate_inside_directory(public_dir, file_path)+ validator = PathValidator(public_dir)+ validator.validate_file_access(file_path)except HTTPException:return Response(status_code=403, content="Access denied")diff --git a/marimo/_server/api/endpoints/home.py b/marimo/_server/api/endpoints/home.pyindex 72c95f839e..a54ac3f1c0 100644--- a/marimo/_server/api/endpoints/home.py+++ b/marimo/_server/api/endpoints/home.py@@ -13,10 +13,10 @@ from marimo import _loggersfrom marimo._server.api.deps import AppStatefrom marimo._server.api.utils import parse_requestfrom marimo._server.file_router import (- MAX_FILES,LazyListOfFilesAppFileRouter,count_files,)+from marimo._server.files.directory_scanner import DirectoryScannerfrom marimo._server.models.home import (MarimoFile,OpenTutorialRequest,@@ -34,6 +34,8 @@ from marimo._utils.paths import pretty_pathif TYPE_CHECKING:from starlette.requests import Request+MAX_FILES = DirectoryScanner.MAX_FILES+LOGGER = _loggers.marimo_logger()# Router for home endpointsdiff --git a/marimo/_server/app_defaults.py b/marimo/_server/app_defaults.pynew file mode 100644index 0000000000..199c749a68--- /dev/null+++ b/marimo/_server/app_defaults.py@@ -0,0 +1,27 @@+# Copyright 2024 Marimo. All rights reserved.+from __future__ import annotations++from dataclasses import dataclass+from typing import TYPE_CHECKING, Optional++from marimo._config.config import ExportType, SqlOutputType, WidthType++if TYPE_CHECKING:+ from marimo._config.manager import MarimoConfigManager+++@dataclass+class AppDefaults:+ """Default configuration for app file managers."""++ width: Optional[WidthType] = None+ auto_download: Optional[list[ExportType]] = None+ sql_output: Optional[SqlOutputType] = None++ @staticmethod+ def from_config_manager(config: MarimoConfigManager) -> AppDefaults:+ return AppDefaults(+ width=config.default_width,+ auto_download=config.default_auto_download,+ sql_output=config.default_sql_output,+ )diff --git a/marimo/_server/file_router.py b/marimo/_server/file_router.pyindex e743db1658..4c299dc596 100644--- a/marimo/_server/file_router.py+++ b/marimo/_server/file_router.py@@ -3,37 +3,27 @@ from __future__ import annotationsimport abcimport os-import signal-from contextlib import contextmanagerfrom pathlib import Path-from typing import TYPE_CHECKING, Optional+from typing import Optionalfrom marimo import _loggers-from marimo._config.config import ExportType, SqlOutputType, WidthType-from marimo._server.files.os_file_system import natural_sort_file+from marimo._server.app_defaults import AppDefaults+from marimo._server.files.directory_scanner import DirectoryScanner+from marimo._server.files.path_validator import PathValidatorfrom marimo._server.models.files import FileInfofrom marimo._server.models.home import MarimoFilefrom marimo._session.notebook import AppFileManagerfrom marimo._utils.http import HTTPException, HTTPStatusfrom marimo._utils.marimo_path import MarimoPath-if TYPE_CHECKING:- from collections.abc import Generator- from types import FrameType-LOGGER = _loggers.marimo_logger()-# Maximum number of files to return in workspace scan-MAX_FILES = 1000-# Some unique identifier for a fileMarimoFileKey = strclass AppFileRouter(abc.ABC):- """- Abstract class for routing files to an AppFileManager.- """+ """Abstract class for routing files to an AppFileManager."""NEW_FILE: MarimoFileKey = "__new__"@@ -79,41 +69,27 @@ class AppFileRouter(abc.ABC):def get_single_app_file_manager(self,- default_width: WidthType | None = None,- default_auto_download: list[ExportType] | None = None,- default_sql_output: SqlOutputType | None = None,+ defaults: Optional[AppDefaults] = None,) -> AppFileManager:key = self.get_unique_file_key()assert key is not None, "Expected a single file"- return self.get_file_manager(- key, default_width, default_auto_download, default_sql_output- )+ return self.get_file_manager(key, defaults)def get_file_manager(self,key: MarimoFileKey,- default_width: WidthType | None = None,- default_auto_download: list[ExportType] | None = None,- default_sql_output: SqlOutputType | None = None,+ defaults: Optional[AppDefaults] = None,) -> AppFileManager:"""Given a key, return an AppFileManager."""+ defaults = defaults or AppDefaults()+if key.startswith(AppFileRouter.NEW_FILE):- return AppFileManager(- None,- default_width=default_width,- default_auto_download=default_auto_download,- default_sql_output=default_sql_output,- )+ return AppFileManager(None, defaults=defaults)if os.path.exists(key):- return AppFileManager(- key,- default_width=default_width,- default_auto_download=default_auto_download,- default_sql_output=default_sql_output,- )+ return AppFileManager(key, defaults=defaults)raise HTTPException(status_code=HTTPStatus.NOT_FOUND,@@ -195,9 +171,11 @@ class LazyListOfFilesAppFileRouter(AppFileRouter):self._directory = str(Path(directory))self.include_markdown = include_markdownself._lazy_files: Optional[list[FileInfo]] = None- # Track temp directories that are allowed to be accessed- # (e.g., for tutorials created by marimo)- self._allowed_temp_dirs: set[Path] = set()++ # Use PathValidator for security validation+ self._validator = PathValidator(Path(directory))+ # Use DirectoryScanner for file discovery+ self._scanner = DirectoryScanner(directory, include_markdown)@propertydef directory(self) -> str:@@ -222,10 +200,7 @@ class LazyListOfFilesAppFileRouter(AppFileRouter):Args:temp_dir: The absolute path to the temp directory to allow."""- # Normalize the path to ensure consistency- normalized_path = Path(temp_dir).resolve()- self._allowed_temp_dirs.add(normalized_path)- LOGGER.debug("Registered allowed temp directory: %s", normalized_path)+ self._validator.register_temp_dir(temp_dir)def is_file_in_allowed_temp_dir(self, filepath: str) -> bool:"""Check if a file is inside an allowed temp directory.@@ -236,59 +211,38 @@ class LazyListOfFilesAppFileRouter(AppFileRouter):Returns:True if the file is in an allowed temp directory, False otherwise."""- if not self._allowed_temp_dirs:- return False-- try:- file_resolved = Path(filepath).resolve(strict=False)- for temp_dir in list(self._allowed_temp_dirs):- try:- file_resolved.relative_to(temp_dir)- return True- except ValueError:- # Not a child of this temp directory, try next- continue- return False- except Exception as e:- LOGGER.warning(- "Error checking if file %s is in allowed temp dir: %s",- filepath,- e,- )- return False+ return self._validator.is_file_in_allowed_temp_dir(filepath)def get_file_manager(self,key: MarimoFileKey,- default_width: WidthType | None = None,- default_auto_download: list[ExportType] | None = None,- default_sql_output: SqlOutputType | None = None,+ defaults: Optional[AppDefaults] = None,) -> AppFileManager:"""Given a key, return an AppFileManager.- For directory routers, if the key is a relative path, resolve it- relative to the router's directory. Absolute paths must be within- the router's directory for security.+ For directory sources, if the key is a relative path, resolve it+ relative to the source's directory. Absolute paths must be within+ the source's directory for security."""+ defaults = defaults or AppDefaults()+if key.startswith(AppFileRouter.NEW_FILE):- return AppFileManager(- None,- default_width=default_width,- default_auto_download=default_auto_download,- default_sql_output=default_sql_output,- )+ return AppFileManager(None, defaults=defaults)directory = Path(self._directory)filepath = Path(key)+ # Use PathValidator for security validation# Check if file is in an allowed temp directory (e.g., for tutorials)# If so, skip the directory validation- is_in_allowed_temp_dir = self.is_file_in_allowed_temp_dir(key)+ is_in_allowed_temp_dir = self._validator.is_file_in_allowed_temp_dir(+ key+ )if not is_in_allowed_temp_dir:# Validate that filepath is inside directory- validate_inside_directory(directory, filepath)+ self._validator.validate_inside_directory(directory, filepath)# Resolve filepath for use# If directory is absolute and filepath is relative, resolve relative to directory@@ -297,12 +251,7 @@ class LazyListOfFilesAppFileRouter(AppFileRouter):# Note: We don't call resolve() here to preserve the original path formatif filepath.exists():- return AppFileManager(- str(filepath),- default_width=default_width,- default_auto_download=default_auto_download,- default_sql_output=default_sql_output,- )+ return AppFileManager(str(filepath), defaults=defaults)raise HTTPException(status_code=HTTPStatus.NOT_FOUND,@@ -313,131 +262,19 @@ class LazyListOfFilesAppFileRouter(AppFileRouter):def files(self) -> list[FileInfo]:if self._lazy_files is None:try:- self._lazy_files = self._load_files()+ # Use DirectoryScanner to load files+ self._lazy_files = self._scanner.scan()except HTTPException as e:if e.status_code == HTTPStatus.REQUEST_TIMEOUT:# Return partial results on timeoutLOGGER.warning("Timeout during file scan, returning partial results")- # self._lazy_files will already contain partial results- # set in _load_files before the exception was raised- if self._lazy_files is None:- self._lazy_files = []+ self._lazy_files = self._scanner.partial_resultselse:raisereturn self._lazy_files- def _load_files(self) -> list[FileInfo]:- import time-- start_time = time.time()- MAX_EXECUTION_TIME = 10 # 10 seconds timeout- file_count = [0] # Use list for closure mutability- accumulated_results: list[- FileInfo- ] = [] # For partial results on timeout-- def recurse(- directory: str, depth: int = 0- ) -> Optional[list[FileInfo]]:- if depth > MAX_DEPTH:- return None-- # Check file limit- if file_count[0] >= MAX_FILES:- LOGGER.warning(f"Reached maximum file limit ({MAX_FILES})")- return None-- if time.time() - start_time > MAX_EXECUTION_TIME:- # Store accumulated results before raising timeout- self._lazy_files = accumulated_results- raise HTTPException(- status_code=HTTPStatus.REQUEST_TIMEOUT,- detail=f"Request timed out: Loading workspace files took too long. Showing first {file_count[0]} files.", # noqa: E501- )-- try:- entries = os.scandir(directory)- except OSError as e:- LOGGER.debug("OSError scanning directory: %s", str(e))- return None-- files: list[FileInfo] = []- folders: list[FileInfo] = []-- for entry in entries:- # Skip hidden files and directories- if entry.name.startswith("."):- continue-- if entry.is_dir():- if entry.name in skip_dirs or depth == MAX_DEPTH:- continue- children = recurse(entry.path, depth + 1)- if children:- folders.append(- FileInfo(- id=entry.path,- path=entry.path,- name=entry.name,- is_directory=True,- is_marimo_file=False,- children=children,- )- )- elif entry.name.endswith(allowed_extensions):- if is_marimo_app(entry.path):- file_count[0] += 1- file_info = FileInfo(- id=entry.path,- path=entry.path,- name=entry.name,- is_directory=False,- is_marimo_file=True,- last_modified=entry.stat().st_mtime,- )- files.append(file_info)- # Also add to accumulated results for partial loading- accumulated_results.append(file_info)- # Check if we've reached the limit- if file_count[0] >= MAX_FILES:- break-- # Sort folders then files, based on natural sort (alpha, then num)- return sorted(folders, key=natural_sort_file) + sorted(- files, key=natural_sort_file- )-- MAX_DEPTH = 5- skip_dirs = {- # Python virtual environments- "venv",- ".venv",- ".virtualenv",- "__pypackages__",- # Python cache and build- "__pycache__",- "build",- "dist",- "eggs",- # Package management- "node_modules",- "site-packages",- # Testing and tooling- ".tox",- ".nox",- ".pytest_cache",- ".mypy_cache",- # Version control- ".git",- }- allowed_extensions = (- (".py", ".md", ".qmd") if self.include_markdown else (".py",)- )-- return recurse(self.directory) or []-def get_unique_file_key(self) -> str | None:return None@@ -445,168 +282,6 @@ class LazyListOfFilesAppFileRouter(AppFileRouter):return None-@contextmanager-def timeout(seconds: int, message: str) -> Generator[None, None, None]:- def timeout_handler(signum: int, frame: Optional[FrameType]) -> None:- del signum, frame- raise HTTPException(- status_code=HTTPStatus.REQUEST_TIMEOUT,- detail=f"Request timed out: {message}",- )-- # Set the timeout handler- original_handler = signal.signal(signal.SIGALRM, timeout_handler)- try:- signal.alarm(seconds)- yield- finally:- signal.alarm(0)- signal.signal(signal.SIGALRM, original_handler)---def validate_inside_directory(directory: Path, filepath: Path) -> None:- """- Validate that a filepath is inside a directory.-- Handles all combinations of absolute/relative paths for both directory- and filepath. Resolves symlinks and prevents path traversal attacks.-- Args:- directory: The directory path (can be absolute or relative)- filepath: The file path to validate (can be absolute or relative)-- Raises:- HTTPException: If the filepath is outside the directory or if there's- an error resolving paths (e.g., broken symlinks, permission errors)- """- try:- # Handle empty paths - Path("") resolves to ".", so check for that- if str(directory) == "." and str(filepath) == ".":- # Both are current directory - this is ambiguous- raise HTTPException(- status_code=HTTPStatus.BAD_REQUEST,- detail="Empty or ambiguous directory or filepath provided",- )-- # Resolve directory to absolute path- # If directory is relative, resolve it relative to current working directory- directory_resolved = directory.resolve(strict=False)-- # If directory doesn't exist, we can't validate - this is an error- if not directory_resolved.exists():- raise HTTPException(- status_code=HTTPStatus.BAD_REQUEST,- detail=f"Directory {directory} does not exist",- )-- if not directory_resolved.is_dir():- raise HTTPException(- status_code=HTTPStatus.BAD_REQUEST,- detail=f"Path {directory} is not a directory",- )-- # Resolve filepath to absolute path- # If directory is absolute and filepath is relative, resolve relative to directory- # (matches behavior in get_file_manager)- # Otherwise, resolve relative to current working directory- if not filepath.is_absolute() and directory_resolved.is_absolute():- # Resolve relative filepath relative to the directory- filepath_resolved = (directory_resolved / filepath).resolve(- strict=False- )- elif filepath.is_absolute():- # Absolute filepath - resolve it directly (resolves symlinks)- filepath_resolved = filepath.resolve(strict=False)- else:- # Both are relative - resolve relative to current working directory- filepath_resolved = filepath.resolve(strict=False)-- # Check if filepath is inside directory- # Use resolve() to handle symlinks and normalize paths- try:- # Ensure both paths are fully resolved (handles symlinks)- # resolve(strict=False) resolves symlinks even if final path doesn't exist- filepath_absolute = filepath_resolved.resolve(strict=False)- directory_absolute = directory_resolved.resolve(strict=False)-- # A directory is not inside itself- if filepath_absolute == directory_absolute:- raise HTTPException(- status_code=HTTPStatus.FORBIDDEN,- detail=f"Access denied: File {filepath} is the same as directory {directory}",- )-- # Check if filepath is inside directory using relative_to- # This prevents path traversal attacks- try:- filepath_absolute.relative_to(directory_absolute)- except ValueError:- # filepath is not inside directory- raise HTTPException(- status_code=HTTPStatus.FORBIDDEN,- detail=f"Access denied: File {filepath} is outside the allowed directory {directory}",- ) from None-- except OSError as e:- # Handle errors like broken symlinks, permission errors, etc.- raise HTTPException(- status_code=HTTPStatus.BAD_REQUEST,- detail=f"Error resolving path {filepath}: {str(e)}",- ) from e-- except HTTPException:- # Re-raise HTTPException as-is- raise- except Exception as e:- # Catch any other unexpected errors- raise HTTPException(- status_code=HTTPStatus.SERVER_ERROR,- detail=f"Unexpected error validating path: {str(e)}",- ) from e---def is_marimo_app(full_path: str) -> bool:- """- Detect whether a file is a marimo app.-- Rules:- - Markdown (`.md`/`.qmd`) files are marimo apps if the first 512 bytes- contain `marimo-version:`.- - Python (`.py`) files are marimo apps if the header (first 512 bytes)- contains both `marimo.App` and `import marimo`.- - If the header contains `# /// script`, read the full file and check for- the same Python markers, to handle large script headers.- - Any errors while reading result in `False`.- """- READ_LIMIT = 512-- def contains_marimo_app(content: bytes) -> bool:- return b"marimo.App" in content and b"import marimo" in content-- try:- path = MarimoPath(full_path)-- with open(full_path, "rb") as f:- header = f.read(READ_LIMIT)-- if path.is_markdown():- return b"marimo-version:" in header-- if path.is_python():- if contains_marimo_app(header):- return True-- if b"# /// script" in header:- full_content = path.read_bytes()- if contains_marimo_app(full_content):- return True-- return False- except Exception as e:- LOGGER.debug("Error reading file %s: %s", full_path, e)- return False--# Count total marimo files (not directories)def count_files(file_list: list[FileInfo]) -> int:count = 0diff --git a/marimo/_server/files/directory_scanner.py b/marimo/_server/files/directory_scanner.pynew file mode 100644index 0000000000..66df3453b4--- /dev/null+++ b/marimo/_server/files/directory_scanner.py@@ -0,0 +1,219 @@+# Copyright 2024 Marimo. All rights reserved.+from __future__ import annotations++import os+import time+from typing import Optional++from marimo import _loggers+from marimo._server.files.os_file_system import natural_sort_file+from marimo._server.models.files import FileInfo+from marimo._utils.http import HTTPException, HTTPStatus+from marimo._utils.marimo_path import MarimoPath++LOGGER = _loggers.marimo_logger()+++def is_marimo_app(full_path: str) -> bool:+ """+ Detect whether a file is a marimo app.++ Rules:+ - Markdown (`.md`/`.qmd`) files are marimo apps if the first 512 bytes+ contain `marimo-version:`.+ - Python (`.py`) files are marimo apps if the header (first 512 bytes)+ contains both `marimo.App` and `import marimo`.+ - If the header contains `# /// script`, read the full file and check for+ the same Python markers, to handle large script headers.+ - Any errors while reading result in `False`.+ """+ READ_LIMIT = 512++ def contains_marimo_app(content: bytes) -> bool:+ return b"marimo.App" in content and b"import marimo" in content++ try:+ path = MarimoPath(full_path)++ with open(full_path, "rb") as f:+ header = f.read(READ_LIMIT)++ if path.is_markdown():+ return b"marimo-version:" in header++ if path.is_python():+ if contains_marimo_app(header):+ return True++ if b"# /// script" in header:+ full_content = path.read_bytes()+ if contains_marimo_app(full_content):+ return True++ return False+ except Exception as e:+ LOGGER.debug("Error reading file %s: %s", full_path, e)+ return False+++class DirectoryScanner:+ """Scans directories for marimo files with filtering and limits.++ Features:+ - Recursive directory traversal (max depth)+ - File type filtering (.py, .md, .qmd)+ - Skip common directories (venv, node_modules, etc.)+ - File count limits and timeouts+ - Marimo app detection+ """++ MAX_DEPTH = 5+ MAX_FILES = 1000+ MAX_EXECUTION_TIME = 10 # seconds++ SKIP_DIRS = {+ # Python virtual environments+ "venv",+ ".venv",+ ".virtualenv",+ "__pypackages__",+ # Python cache and build+ "__pycache__",+ "build",+ "dist",+ "eggs",+ # Package management+ "node_modules",+ "site-packages",+ # Testing and tooling+ ".tox",+ ".nox",+ ".pytest_cache",+ ".mypy_cache",+ # Version control+ ".git",+ }++ def __init__(+ self,+ directory: str,+ include_markdown: bool = False,+ max_files: Optional[int] = None,+ max_depth: Optional[int] = None,+ max_execution_time: Optional[int] = None,+ ):+ """Initialize DirectoryScanner.++ Args:+ directory: The directory to scan+ include_markdown: Whether to include .md and .qmd files+ max_files: Maximum number of files to find+ max_depth: Maximum directory depth to recurse+ max_execution_time: Maximum time in seconds before timeout+ """+ self.directory = directory+ self.include_markdown = include_markdown+ self.max_files = max_files if max_files is not None else self.MAX_FILES+ self.max_depth = max_depth if max_depth is not None else self.MAX_DEPTH+ self.max_execution_time = (+ max_execution_time+ if max_execution_time is not None+ else self.MAX_EXECUTION_TIME+ )+ # Stores partial results in case of timeout+ self.partial_results: list[FileInfo] = []++ @property+ def allowed_extensions(self) -> tuple[str, ...]:+ """Get allowed file extensions based on settings."""+ if self.include_markdown:+ return (".py", ".md", ".qmd")+ return (".py",)++ def scan(self) -> list[FileInfo]:+ """Scan directory and return file tree.++ Returns:+ List of FileInfo with nested children++ Raises:+ HTTPException: On timeout with REQUEST_TIMEOUT status.+ On timeout, partial_results will contain files found so far.+ """+ start_time = time.time()+ file_count = [0] # Use list for closure mutability+ self.partial_results = [] # Reset partial results++ def recurse(+ directory: str, depth: int = 0+ ) -> Optional[list[FileInfo]]:+ if depth > self.max_depth:+ return None++ # Check file limit+ if file_count[0] >= self.max_files:+ LOGGER.warning(+ f"Reached maximum file limit ({self.max_files})"+ )+ return None++ if time.time() - start_time > self.max_execution_time:+ # Store accumulated results before raising timeout+ raise HTTPException(+ status_code=HTTPStatus.REQUEST_TIMEOUT,+ detail=f"Request timed out: Loading workspace files took too long. Showing first {file_count[0]} files.", # noqa: E501+ )++ try:+ entries = os.scandir(directory)+ except OSError as e:+ LOGGER.debug("OSError scanning directory: %s", str(e))+ return None++ files: list[FileInfo] = []+ folders: list[FileInfo] = []++ for entry in entries:+ # Skip hidden files and directories+ if entry.name.startswith("."):+ continue++ if entry.is_dir():+ if entry.name in self.SKIP_DIRS or depth == self.max_depth:+ continue+ children = recurse(entry.path, depth + 1)+ if children:+ folders.append(+ FileInfo(+ id=entry.path,+ path=entry.path,+ name=entry.name,+ is_directory=True,+ is_marimo_file=False,+ children=children,+ )+ )+ elif entry.name.endswith(self.allowed_extensions):+ if is_marimo_app(entry.path):+ file_count[0] += 1+ file_info = FileInfo(+ id=entry.path,+ path=entry.path,+ name=entry.name,+ is_directory=False,+ is_marimo_file=True,+ last_modified=entry.stat().st_mtime,+ )+ files.append(file_info)+ # Also add to partial results for timeout recovery+ self.partial_results.append(file_info)+ # Check if we've reached the limit+ if file_count[0] >= self.max_files:+ break++ # Sort folders then files, based on natural sort (alpha, then num)+ return sorted(folders, key=natural_sort_file) + sorted(+ files, key=natural_sort_file+ )++ return recurse(self.directory) or []diff --git a/marimo/_server/files/path_validator.py b/marimo/_server/files/path_validator.pynew file mode 100644index 0000000000..eccf8b9844--- /dev/null+++ b/marimo/_server/files/path_validator.py@@ -0,0 +1,195 @@+# Copyright 2024 Marimo. All rights reserved.+from __future__ import annotations++from pathlib import Path+from typing import Optional++from marimo import _loggers+from marimo._utils.http import HTTPException, HTTPStatus++LOGGER = _loggers.marimo_logger()+++class PathValidator:+ """Validates file paths for security and access control.++ Handles:+ - Directory containment validation (prevent path traversal)+ - Temporary directory allowlisting (for tutorials)+ - Symlink resolution and security+ """++ def __init__(self, base_directory: Optional[Path] = None):+ """Initialize PathValidator.++ Args:+ base_directory: The base directory to validate paths against.+ If None, validation is skipped.+ """+ self.base_directory = base_directory+ self._allowed_temp_dirs: set[Path] = set()++ def register_temp_dir(self, temp_dir: str) -> None:+ """Register a temp directory as allowed for file access.++ Args:+ temp_dir: The absolute path to the temp directory to allow.+ """+ # Normalize the path to ensure consistency+ normalized_path = Path(temp_dir).resolve()+ self._allowed_temp_dirs.add(normalized_path)+ LOGGER.debug("Registered allowed temp directory: %s", normalized_path)++ def is_file_in_allowed_temp_dir(self, filepath: str) -> bool:+ """Check if a file is inside an allowed temp directory.++ Args:+ filepath: The file path to check.++ Returns:+ True if the file is in an allowed temp directory, False otherwise.+ """+ if not self._allowed_temp_dirs:+ return False++ try:+ file_resolved = Path(filepath).resolve(strict=False)+ for temp_dir in list(self._allowed_temp_dirs):+ try:+ file_resolved.relative_to(temp_dir)+ return True+ except ValueError:+ # Not a child of this temp directory, try next+ continue+ return False+ except Exception as e:+ LOGGER.warning(+ "Error checking if file %s is in allowed temp dir: %s",+ filepath,+ e,+ )+ return False++ def validate_inside_directory(+ self, directory: Path, filepath: Path+ ) -> None:+ """+ Validate that a filepath is inside a directory.++ Handles all combinations of absolute/relative paths for both directory+ and filepath. Resolves symlinks and prevents path traversal attacks.++ Args:+ directory: The directory path (can be absolute or relative)+ filepath: The file path to validate (can be absolute or relative)++ Raises:+ HTTPException: If the filepath is outside the directory or if there's+ an error resolving paths (e.g., broken symlinks, permission errors)+ """+ try:+ # Handle empty paths - Path("") resolves to ".", so check for that+ if str(directory) == "." and str(filepath) == ".":+ # Both are current directory - this is ambiguous+ raise HTTPException(+ status_code=HTTPStatus.BAD_REQUEST,+ detail="Empty or ambiguous directory or filepath provided",+ )++ # Resolve directory to absolute path+ # If directory is relative, resolve it relative to current working directory+ directory_resolved = directory.resolve(strict=False)++ # If directory doesn't exist, we can't validate - this is an error+ if not directory_resolved.exists():+ raise HTTPException(+ status_code=HTTPStatus.BAD_REQUEST,+ detail=f"Directory {directory} does not exist",+ )++ if not directory_resolved.is_dir():+ raise HTTPException(+ status_code=HTTPStatus.BAD_REQUEST,+ detail=f"Path {directory} is not a directory",+ )++ # Resolve filepath to absolute path+ # If directory is absolute and filepath is relative, resolve relative to directory+ # (matches behavior in get_file_manager)+ # Otherwise, resolve relative to current working directory+ if not filepath.is_absolute() and directory_resolved.is_absolute():+ # Resolve relative filepath relative to the directory+ filepath_resolved = (directory_resolved / filepath).resolve(+ strict=False+ )+ elif filepath.is_absolute():+ # Absolute filepath - resolve it directly (resolves symlinks)+ filepath_resolved = filepath.resolve(strict=False)+ else:+ # Both are relative - resolve relative to current working directory+ filepath_resolved = filepath.resolve(strict=False)++ # Check if filepath is inside directory+ # Use resolve() to handle symlinks and normalize paths+ try:+ # Ensure both paths are fully resolved (handles symlinks)+ # resolve(strict=False) resolves symlinks even if final path doesn't exist+ filepath_absolute = filepath_resolved.resolve(strict=False)+ directory_absolute = directory_resolved.resolve(strict=False)++ # A directory is not inside itself+ if filepath_absolute == directory_absolute:+ raise HTTPException(+ status_code=HTTPStatus.FORBIDDEN,+ detail=f"Access denied: File {filepath} is the same as directory {directory}",+ )++ # Check if filepath is inside directory using relative_to+ # This prevents path traversal attacks+ try:+ filepath_absolute.relative_to(directory_absolute)+ except ValueError:+ # filepath is not inside directory+ raise HTTPException(+ status_code=HTTPStatus.FORBIDDEN,+ detail=f"Access denied: File {filepath} is outside the allowed directory {directory}",+ ) from None++ except OSError as e:+ # Handle errors like broken symlinks, permission errors, etc.+ raise HTTPException(+ status_code=HTTPStatus.BAD_REQUEST,+ detail=f"Error resolving path {filepath}: {str(e)}",+ ) from e++ except HTTPException:+ # Re-raise HTTPException as-is+ raise+ except Exception as e:+ # Catch any other unexpected errors+ raise HTTPException(+ status_code=HTTPStatus.SERVER_ERROR,+ detail=f"Unexpected error validating path: {str(e)}",+ ) from e++ def validate_file_access(self, filepath: Path) -> None:+ """Validate file can be accessed (combines checks).++ Checks if the file is in an allowed temp directory, and if not,+ validates it's inside the base directory.++ Args:+ filepath: The file path to validate++ Raises:+ HTTPException: If validation fails+ """+ if self.base_directory is None:+ return++ # Check if file is in an allowed temp directory first+ if self.is_file_in_allowed_temp_dir(str(filepath)):+ return++ # Otherwise, validate it's inside the base directory+ self.validate_inside_directory(self.base_directory, filepath)diff --git a/marimo/_server/session_manager.py b/marimo/_server/session_manager.pyindex 5b8915335d..84e72d0c73 100644--- a/marimo/_server/session_manager.py+++ b/marimo/_server/session_manager.py@@ -18,6 +18,7 @@ from marimo._runtime.commands import (SerializedCLIArgs,SerializedQueryParams,)+from marimo._server.app_defaults import AppDefaultsfrom marimo._server.file_router import AppFileRouter, MarimoFileKeyfrom marimo._server.lsp import LspServerfrom marimo._server.recents import RecentFilesManager@@ -91,11 +92,8 @@ class SessionManager:self._repository = SessionRepository()def _get_code() -> str:- app = file_router.get_single_app_file_manager(- default_width=config_manager.default_width,- default_auto_download=config_manager.default_auto_download,- default_sql_output=config_manager.default_sql_output,- ).app+ defaults = AppDefaults.from_config_manager(config_manager)+ app = file_router.get_single_app_file_manager(defaults).appreturn "".join(code for code in app.cell_manager.codes())source_code = None if mode == SessionMode.EDIT else _get_code()@@ -134,12 +132,8 @@ class SessionManager:def app_manager(self, key: MarimoFileKey) -> AppFileManager:"""Get the app manager for the given key."""- return self.file_router.get_file_manager(- key,- default_width=self._config_manager.default_width,- default_auto_download=self._config_manager.default_auto_download,- default_sql_output=self._config_manager.default_sql_output,- )+ defaults = AppDefaults.from_config_manager(self._config_manager)+ return self.file_router.get_file_manager(key, defaults)def create_session(self,@@ -158,11 +152,9 @@ class SessionManager:return existing# Get app file manager+ defaults = AppDefaults.from_config_manager(self._config_manager)app_file_manager = self.file_router.get_file_manager(- file_key,- default_width=self._config_manager.default_width,- default_auto_download=self._config_manager.default_auto_download,- default_sql_output=self._config_manager.default_sql_output,+ file_key, defaults)# Create the sessiondiff --git a/marimo/_session/notebook/file_manager.py b/marimo/_session/notebook/file_manager.pyindex 0014c3615f..838004d302 100644--- a/marimo/_session/notebook/file_manager.py+++ b/marimo/_session/notebook/file_manager.py@@ -10,13 +10,13 @@ from marimo._ast import loadfrom marimo._ast.app import App, InternalAppfrom marimo._ast.app_config import overloads_from_envfrom marimo._ast.cell import CellConfig-from marimo._config.config import ExportType, SqlOutputType, WidthTypefrom marimo._runtime.layout.layout import (LayoutConfig,read_layout_config,save_layout_config,)from marimo._schemas.serialization import Header, NotebookSerializationV1+from marimo._server.app_defaults import AppDefaultsfrom marimo._session.notebook.serializer import get_format_handlerfrom marimo._session.notebook.storage import (FilesystemStorage,@@ -56,20 +56,14 @@ class AppFileManager:filename: Optional[str | Path],*,storage: Optional[StorageInterface] = None,- default_width: WidthType | None = None,- default_auto_download: list[ExportType] | None = None,- default_sql_output: SqlOutputType | None = None,+ defaults: Optional[AppDefaults] = None,) -> None:self._filename = _maybe_path(filename)self.storage: StorageInterface = storage or FilesystemStorage()# Configuration defaults- self._default_width: WidthType | None = default_width- self._default_auto_download: list[ExportType] | None = (- default_auto_download- )- self._default_sql_output: SqlOutputType | None = default_sql_output+ self._defaults = defaults or AppDefaults()# Load the appself.app = self._load_app(self.path)@@ -232,12 +226,12 @@ class AppFileManager:kwargs: dict[str, Any] = default.asdict()# Add custom defaults if provided- if self._default_width is not None:- kwargs["width"] = self._default_width- if self._default_auto_download is not None:- kwargs["auto_download"] = self._default_auto_download- if self._default_sql_output is not None:- kwargs["sql_output"] = self._default_sql_output+ if self._defaults.width is not None:+ kwargs["width"] = self._defaults.width+ if self._defaults.auto_download is not None:+ kwargs["auto_download"] = self._defaults.auto_download+ if self._defaults.sql_output is not None:+ kwargs["sql_output"] = self._defaults.sql_outputempty_app = InternalApp(App(**kwargs))empty_app.cell_manager.register_cell(diff --git a/tests/_server/rtc/test_rtc_doc.py b/tests/_server/rtc/test_rtc_doc.pyindex 64831a70c8..07be31cdf6 100644--- a/tests/_server/rtc/test_rtc_doc.py+++ b/tests/_server/rtc/test_rtc_doc.py@@ -1,7 +1,8 @@+from __future__ import annotations+import asyncioimport sys-from collections.abc import AsyncGenerator-from typing import cast+from typing import TYPE_CHECKING, castimport pytest@@ -15,6 +16,10 @@ if sys.version_info >= (3, 11) and sys.version_info < (3, 14):doc_manager = LoroDocManager()+if TYPE_CHECKING:+ from collections.abc import AsyncGenerator++@pytest.fixture # type: ignoreasync def setup_doc_manager() -> AsyncGenerator[None, None]:"""Setup and teardown for loro_docs tests"""diff --git a/tests/_server/test_directory_scanner.py b/tests/_server/test_directory_scanner.pynew file mode 100644index 0000000000..0dd1a1cdbd--- /dev/null+++ b/tests/_server/test_directory_scanner.py@@ -0,0 +1,148 @@+# Copyright 2024 Marimo. All rights reserved.+from __future__ import annotations++import os+import shutil+import tempfile+import unittest++from marimo._server.files.directory_scanner import (+ DirectoryScanner,+ is_marimo_app,+)+++def test_python_app_detected():+ """Test that Python marimo apps are detected."""+ with tempfile.NamedTemporaryFile(+ mode="w", suffix=".py", delete=False+ ) as f:+ f.write("import marimo\napp = marimo.App()\n")+ f.flush()+ assert is_marimo_app(f.name)+ os.unlink(f.name)+++def test_python_non_app():+ """Test that non-marimo Python files return False."""+ with tempfile.NamedTemporaryFile(+ mode="w", suffix=".py", delete=False+ ) as f:+ f.write("import sys\nprint('hello')\n")+ f.flush()+ assert not is_marimo_app(f.name)+ os.unlink(f.name)+++def test_markdown_app_detected():+ """Test that markdown files with marimo-version are detected."""+ with tempfile.NamedTemporaryFile(+ mode="w", suffix=".md", delete=False+ ) as f:+ f.write("---\nmarimo-version: 0.1.0\n---\n")+ f.flush()+ assert is_marimo_app(f.name)+ os.unlink(f.name)+++class TestDirectoryScanner(unittest.TestCase):+ def setUp(self):+ self.temp_root = tempfile.mkdtemp()+ self.test_dir = os.path.join(self.temp_root, "test_directory")+ os.makedirs(self.test_dir)++ # Create marimo files+ with open(os.path.join(self.test_dir, "app1.py"), "w") as f:+ f.write("import marimo\napp = marimo.App()\n")+ with open(os.path.join(self.test_dir, "app2.py"), "w") as f:+ f.write("import marimo\napp = marimo.App()\n")++ # Create markdown file+ with open(os.path.join(self.test_dir, "notebook.md"), "w") as f:+ f.write("---\nmarimo-version: 0.1.0\n---\n")++ # Create nested directory with marimo file+ self.nested_dir = os.path.join(self.test_dir, "nested")+ os.makedirs(self.nested_dir)+ with open(os.path.join(self.nested_dir, "nested_app.py"), "w") as f:+ f.write("import marimo\napp = marimo.App()\n")++ def tearDown(self):+ shutil.rmtree(self.temp_root)++ def test_basic_scan(self):+ """Test basic directory scanning."""+ scanner = DirectoryScanner(self.test_dir)+ files = scanner.scan()+ file_names = [f.name for f in files if not f.is_directory]+ assert len(file_names) == 2+ assert "app1.py" in file_names+ assert "app2.py" in file_names++ def test_scan_with_markdown(self):+ """Test scanning with markdown files included."""+ scanner = DirectoryScanner(self.test_dir, include_markdown=True)+ files = scanner.scan()+ file_names = [f.name for f in files if not f.is_directory]+ assert len(file_names) == 3+ assert "notebook.md" in file_names++ def test_scan_nested_directories(self):+ """Test scanning nested directories."""+ scanner = DirectoryScanner(self.test_dir)+ files = scanner.scan()+ nested_dirs = [+ f for f in files if f.is_directory and f.name == "nested"+ ]+ assert len(nested_dirs) == 1+ assert nested_dirs[0].children is not None+ assert nested_dirs[0].children[0].name == "nested_app.py"++ def test_max_files_limit(self):+ """Test that max_files limit is enforced."""+ for i in range(10):+ with open(os.path.join(self.test_dir, f"app{i + 3}.py"), "w") as f:+ f.write("import marimo\napp = marimo.App()\n")++ scanner = DirectoryScanner(self.test_dir, max_files=5)+ files = scanner.scan()+ file_count = sum(1 for f in files if not f.is_directory)+ assert file_count == 5++ def test_skip_common_directories(self):+ """Test that common directories are skipped."""+ for dirname in ["venv", "node_modules", "__pycache__", ".git"]:+ skip_dir = os.path.join(self.test_dir, dirname)+ os.makedirs(skip_dir)+ with open(os.path.join(skip_dir, "app.py"), "w") as f:+ f.write("import marimo\napp = marimo.App()\n")++ scanner = DirectoryScanner(self.test_dir)+ files = scanner.scan()+ file_paths = [f.path for f in files if not f.is_directory]+ for path in file_paths:+ assert "venv" not in path+ assert "node_modules" not in path++ def test_skip_hidden_files(self):+ """Test that hidden files are skipped."""+ with open(os.path.join(self.test_dir, ".hidden_app.py"), "w") as f:+ f.write("import marimo\napp = marimo.App()\n")++ scanner = DirectoryScanner(self.test_dir)+ files = scanner.scan()+ file_names = [f.name for f in files if not f.is_directory]+ assert ".hidden_app.py" not in file_names++ def test_partial_results_populated_during_scan(self):+ """Test that partial_results is populated during scanning."""+ scanner = DirectoryScanner(self.test_dir)+ # partial_results starts empty+ assert scanner.partial_results == []+ files = scanner.scan()+ # After scan, partial_results contains all found files (flat list)+ assert len(scanner.partial_results) >= 2+ # All items in partial_results should be non-directory files+ for f in scanner.partial_results:+ assert not f.is_directory+ assert f.is_marimo_filediff --git a/tests/_server/test_file_manager.py b/tests/_server/test_file_manager.pyindex bb9061adae..4034ee96fc 100644--- a/tests/_server/test_file_manager.py+++ b/tests/_server/test_file_manager.py@@ -9,6 +9,7 @@ import pytestfrom marimo import __version__from marimo._ast.app import App, InternalAppfrom marimo._ast.cell import CellConfig+from marimo._server.app_defaults import AppDefaultsfrom marimo._server.models.models import SaveNotebookRequestfrom marimo._session.notebook import AppFileManagerfrom marimo._types.ids import CellId_t@@ -628,8 +629,10 @@ def test_default_app_settings(tmp_path: Path) -> None:# Test with custom defaultsmanager = AppFileManager(filename=None,- default_width="full",- default_sql_output="polars",+ defaults=AppDefaults(+ width="full",+ sql_output="polars",+ ),)assert manager.app.config.width == "full"assert manager.app.config.sql_output == "polars"@@ -650,8 +653,10 @@ app = marimo.App(sql_output="lazy-polars", width="columns"))manager = AppFileManager(filename=tmp_file,- default_width="full",- default_sql_output="polars",+ defaults=AppDefaults(+ width="full",+ sql_output="polars",+ ),)assert manager.app.config.width == "columns"assert manager.app.config.sql_output == "lazy-polars"diff --git a/tests/_server/test_file_router.py b/tests/_server/test_file_router.pyindex 7c125a6f3d..baa2be55cd 100644--- a/tests/_server/test_file_router.py+++ b/tests/_server/test_file_router.py@@ -14,9 +14,9 @@ from marimo._server.file_router import (ListOfFilesAppFileRouter,NewFileAppFileRouter,count_files,- is_marimo_app,- validate_inside_directory,)+from marimo._server.files.directory_scanner import is_marimo_app+from marimo._server.files.path_validator import PathValidatorfrom marimo._server.models.home import MarimoFilefrom marimo._utils.http import HTTPException, HTTPStatus@@ -192,14 +192,14 @@ class TestValidateInsideDirectory(unittest.TestCase):directory = Path(self.test_dir).resolve()filepath = Path(self.test_file).resolve()# Should not raise- validate_inside_directory(directory, filepath)+ PathValidator().validate_inside_directory(directory, filepath)def test_absolute_directory_absolute_filepath_outside(self):"""Test: absolute directory, absolute filepath, file outside directory"""directory = Path(self.test_dir).resolve()filepath = Path(self.outside_file).resolve()with pytest.raises(HTTPException) as exc_info:- validate_inside_directory(directory, filepath)+ PathValidator().validate_inside_directory(directory, filepath)assert exc_info.value.status_code == HTTPStatus.FORBIDDENdef test_absolute_directory_relative_filepath_inside(self):@@ -209,7 +209,7 @@ class TestValidateInsideDirectory(unittest.TestCase):# Change to test_dir so relative path resolves correctlyos.chdir(self.test_dir)# Should not raise- validate_inside_directory(directory, filepath)+ PathValidator().validate_inside_directory(directory, filepath)def test_absolute_directory_relative_filepath_outside(self):"""Test: absolute directory, relative filepath, file outside directory"""@@ -220,7 +220,7 @@ class TestValidateInsideDirectory(unittest.TestCase):# to use a path that goes outside even when resolved relative to directory.filepath = Path("..") / ".." / "etc" / "passwd"with pytest.raises(HTTPException) as exc_info:- validate_inside_directory(directory, filepath)+ PathValidator().validate_inside_directory(directory, filepath)assert exc_info.value.status_code == HTTPStatus.FORBIDDENdef test_relative_directory_absolute_filepath_inside(self):@@ -229,7 +229,7 @@ class TestValidateInsideDirectory(unittest.TestCase):directory = Path(".")filepath = Path(self.test_file).resolve()# Should not raise- validate_inside_directory(directory, filepath)+ PathValidator().validate_inside_directory(directory, filepath)def test_relative_directory_absolute_filepath_outside(self):"""Test: relative directory, absolute filepath, file outside directory"""@@ -237,7 +237,7 @@ class TestValidateInsideDirectory(unittest.TestCase):directory = Path(".")filepath = Path(self.outside_file).resolve()with pytest.raises(HTTPException) as exc_info:- validate_inside_directory(directory, filepath)+ PathValidator().validate_inside_directory(directory, filepath)assert exc_info.value.status_code == HTTPStatus.FORBIDDENdef test_relative_directory_relative_filepath_inside(self):@@ -246,7 +246,7 @@ class TestValidateInsideDirectory(unittest.TestCase):directory = Path(".")filepath = Path("test.py")# Should not raise- validate_inside_directory(directory, filepath)+ PathValidator().validate_inside_directory(directory, filepath)def test_relative_directory_relative_filepath_outside(self):"""Test: relative directory, relative filepath, file outside directory"""@@ -256,7 +256,7 @@ class TestValidateInsideDirectory(unittest.TestCase):relative_path = os.path.relpath(self.test_file, self.outside_dir)filepath = Path(relative_path)with pytest.raises(HTTPException) as exc_info:- validate_inside_directory(directory, filepath)+ PathValidator().validate_inside_directory(directory, filepath)assert exc_info.value.status_code == HTTPStatus.FORBIDDENdef test_path_traversal_dotdot(self):@@ -265,7 +265,7 @@ class TestValidateInsideDirectory(unittest.TestCase):# Try to escape using ../filepath = Path(self.test_dir) / ".." / ".." / "etc" / "passwd"with pytest.raises(HTTPException) as exc_info:- validate_inside_directory(directory, filepath)+ PathValidator().validate_inside_directory(directory, filepath)assert exc_info.value.status_code == HTTPStatus.FORBIDDENdef test_path_traversal_nested_dotdot(self):@@ -276,7 +276,7 @@ class TestValidateInsideDirectory(unittest.TestCase):Path(self.nested_dir) / ".." / ".." / ".." / "etc" / "passwd")with pytest.raises(HTTPException) as exc_info:- validate_inside_directory(directory, filepath)+ PathValidator().validate_inside_directory(directory, filepath)assert exc_info.value.status_code == HTTPStatus.FORBIDDENdef test_symlink_inside_directory(self):@@ -286,7 +286,7 @@ class TestValidateInsideDirectory(unittest.TestCase):symlink_path = Path(self.test_dir) / "symlink.py"symlink_path.symlink_to(self.test_file)# Should not raise- validate_inside_directory(directory, symlink_path)+ PathValidator().validate_inside_directory(directory, symlink_path)symlink_path.unlink()def test_symlink_outside_directory(self):@@ -297,7 +297,7 @@ class TestValidateInsideDirectory(unittest.TestCase):symlink_path.symlink_to(self.outside_file)# Should raise - symlink resolves to outside filewith pytest.raises(HTTPException) as exc_info:- validate_inside_directory(directory, symlink_path)+ PathValidator().validate_inside_directory(directory, symlink_path)assert exc_info.value.status_code == HTTPStatus.FORBIDDENsymlink_path.unlink()@@ -312,7 +312,7 @@ class TestValidateInsideDirectory(unittest.TestCase):# First test: broken symlink inside directory (should work if resolved path is inside)# The symlink itself is inside, so it should pass validation# (the actual file doesn't need to exist for validation)- validate_inside_directory(directory, broken_symlink)+ PathValidator().validate_inside_directory(directory, broken_symlink)# Test: broken symlink that resolves outsidebroken_symlink.unlink()@@ -321,7 +321,9 @@ class TestValidateInsideDirectory(unittest.TestCase):broken_symlink.symlink_to("../../etc/passwd")# Should fail because resolved path is outsidewith pytest.raises(HTTPException) as exc_info:- validate_inside_directory(directory, broken_symlink)+ PathValidator().validate_inside_directory(+ directory, broken_symlink+ )assert exc_info.value.status_code == HTTPStatus.FORBIDDENbroken_symlink.unlink()@@ -332,7 +334,7 @@ class TestValidateInsideDirectory(unittest.TestCase):symlink_path = Path(self.test_dir) / "nested_link"symlink_path.symlink_to(self.nested_dir)# Should not raise - symlink resolves to directory inside- validate_inside_directory(directory, symlink_path)+ PathValidator().validate_inside_directory(directory, symlink_path)symlink_path.unlink()def test_nested_file(self):@@ -340,14 +342,14 @@ class TestValidateInsideDirectory(unittest.TestCase):directory = Path(self.test_dir).resolve()filepath = Path(self.nested_file).resolve()# Should not raise- validate_inside_directory(directory, filepath)+ PathValidator().validate_inside_directory(directory, filepath)def test_nonexistent_directory(self):"""Test: directory doesn't exist"""directory = Path(self.test_dir) / "nonexistent"filepath = Path(self.test_file).resolve()with pytest.raises(HTTPException) as exc_info:- validate_inside_directory(directory, filepath)+ PathValidator().validate_inside_directory(directory, filepath)assert exc_info.value.status_code == HTTPStatus.BAD_REQUESTdef test_file_as_directory(self):@@ -355,7 +357,7 @@ class TestValidateInsideDirectory(unittest.TestCase):directory = Path(self.test_file).resolve()filepath = Path(self.test_file).resolve()with pytest.raises(HTTPException) as exc_info:- validate_inside_directory(directory, filepath)+ PathValidator().validate_inside_directory(directory, filepath)assert exc_info.value.status_code == HTTPStatus.BAD_REQUESTdef test_same_path(self):@@ -364,7 +366,7 @@ class TestValidateInsideDirectory(unittest.TestCase):filepath = Path(self.test_dir).resolve()# Directory is not inside itselfwith pytest.raises(HTTPException) as exc_info:- validate_inside_directory(directory, filepath)+ PathValidator().validate_inside_directory(directory, filepath)assert exc_info.value.status_code == HTTPStatus.FORBIDDENdef test_empty_paths(self):@@ -373,7 +375,7 @@ class TestValidateInsideDirectory(unittest.TestCase):directory = Path("")filepath = Path("")with pytest.raises(HTTPException) as exc_info:- validate_inside_directory(directory, filepath)+ PathValidator().validate_inside_directory(directory, filepath)assert exc_info.value.status_code == HTTPStatus.BAD_REQUESTdef test_absolute_path_with_dotdot_resolved(self):@@ -382,7 +384,9 @@ class TestValidateInsideDirectory(unittest.TestCase):# Create path with .. that still resolves insidefilepath = Path(self.nested_file).resolve() / ".." / "test.py"# Should not raise - resolves to test.py inside directory- validate_inside_directory(directory, filepath.resolve())+ PathValidator().validate_inside_directory(+ directory, filepath.resolve()+ )def test_relative_path_with_dotdot(self):"""Test: relative path with .. that resolves inside"""@@ -394,7 +398,7 @@ class TestValidateInsideDirectory(unittest.TestCase):nested_rel_path = Path("nested") / ".." / "test.py"filepath = nested_rel_path# Should not raise - resolves to test.py inside directory- validate_inside_directory(directory, filepath)+ PathValidator().validate_inside_directory(directory, filepath)def test_relative_path_with_dotdot_outside(self):"""Test: relative path with .. that goes outside"""@@ -402,7 +406,7 @@ class TestValidateInsideDirectory(unittest.TestCase):directory = Path(self.nested_dir).resolve()filepath = Path("..") / ".." / ".." / "etc" / "passwd"with pytest.raises(HTTPException) as exc_info:- validate_inside_directory(directory, filepath)+ PathValidator().validate_inside_directory(directory, filepath)assert exc_info.value.status_code == HTTPStatus.FORBIDDEN@@ -453,12 +457,12 @@ def test_lazy_router_respects_max_files(tmp_path: Path):# Create a directory with more files than MAX_FILES# To make this test fast, we'll use a monkey-patch approach# by temporarily reducing MAX_FILES- import marimo._server.file_router as file_router_module+ from marimo._server.files.directory_scanner import DirectoryScanner- original_max_files = file_router_module.MAX_FILES+ original_max_files = DirectoryScanner.MAX_FILEStry:# Set a small limit for testing- file_router_module.MAX_FILES = 5+ DirectoryScanner.MAX_FILES = 5# Create 10 marimo filesfor i in range(10):@@ -477,7 +481,7 @@ def test_lazy_router_respects_max_files(tmp_path: Path):finally:# Restore original value- file_router_module.MAX_FILES = original_max_files+ DirectoryScanner.MAX_FILES = original_max_filesdef test_lazy_router_skips_common_dirs(tmp_path: Path):diff --git a/tests/_server/test_path_validator.py b/tests/_server/test_path_validator.pynew file mode 100644index 0000000000..04bb04eadc--- /dev/null+++ b/tests/_server/test_path_validator.py@@ -0,0 +1,106 @@+# Copyright 2024 Marimo. All rights reserved.+from __future__ import annotations++import os+import shutil+import tempfile+import unittest+from pathlib import Path++import pytest++from marimo._server.files.path_validator import PathValidator+from marimo._utils.http import HTTPException, HTTPStatus+++class TestPathValidator(unittest.TestCase):+ def setUp(self):+ self.temp_root = tempfile.mkdtemp()+ self.test_dir = os.path.join(self.temp_root, "test_directory")+ os.makedirs(self.test_dir)++ self.test_file = os.path.join(self.test_dir, "test.py")+ with open(self.test_file, "w") as f:+ f.write("# test")++ self.outside_dir = os.path.join(self.temp_root, "outside_directory")+ os.makedirs(self.outside_dir)++ self.outside_file = os.path.join(self.outside_dir, "outside.py")+ with open(self.outside_file, "w") as f:+ f.write("# outside")++ self.original_cwd = os.getcwd()++ def tearDown(self):+ os.chdir(self.original_cwd)+ shutil.rmtree(self.temp_root)++ def test_file_inside_directory(self):+ """Test that files inside directory pass validation."""+ validator = PathValidator()+ directory = Path(self.test_dir).resolve()+ filepath = Path(self.test_file).resolve()+ validator.validate_inside_directory(directory, filepath)++ def test_file_outside_directory(self):+ """Test that files outside directory fail validation."""+ validator = PathValidator()+ directory = Path(self.test_dir).resolve()+ filepath = Path(self.outside_file).resolve()+ with pytest.raises(HTTPException) as exc_info:+ validator.validate_inside_directory(directory, filepath)+ assert exc_info.value.status_code == HTTPStatus.FORBIDDEN++ def test_path_traversal_attack(self):+ """Test that path traversal attacks are prevented."""+ validator = PathValidator()+ directory = Path(self.test_dir).resolve()+ filepath = Path(self.test_dir) / ".." / ".." / "etc" / "passwd"+ with pytest.raises(HTTPException) as exc_info:+ validator.validate_inside_directory(directory, filepath)+ assert exc_info.value.status_code == HTTPStatus.FORBIDDEN++ def test_symlink_inside_directory(self):+ """Test that symlinks pointing inside directory are allowed."""+ validator = PathValidator()+ directory = Path(self.test_dir).resolve()+ symlink_path = Path(self.test_dir) / "symlink.py"+ symlink_path.symlink_to(self.test_file)+ validator.validate_inside_directory(directory, symlink_path)+ symlink_path.unlink()++ def test_symlink_escape_prevented(self):+ """Test that symlinks pointing outside directory are blocked."""+ validator = PathValidator()+ directory = Path(self.test_dir).resolve()+ symlink_path = Path(self.test_dir) / "symlink.py"+ symlink_path.symlink_to(self.outside_file)+ with pytest.raises(HTTPException) as exc_info:+ validator.validate_inside_directory(directory, symlink_path)+ assert exc_info.value.status_code == HTTPStatus.FORBIDDEN+ symlink_path.unlink()++ def test_temp_directory_registration(self):+ """Test registering and checking temp directories."""+ validator = PathValidator()+ validator.register_temp_dir(self.outside_dir)++ assert validator.is_file_in_allowed_temp_dir(self.outside_file)+ assert not validator.is_file_in_allowed_temp_dir(self.test_file)++ def test_validate_file_access_with_temp_dir(self):+ """Test that temp directory files bypass validation."""+ validator = PathValidator(base_directory=Path(self.test_dir))+ validator.register_temp_dir(self.outside_dir)+ filepath = Path(self.outside_file)+ # Should not raise - file is in allowed temp dir+ validator.validate_file_access(filepath)++ def test_validate_file_access_outside_base_dir(self):+ """Test that files outside base directory are blocked."""+ validator = PathValidator(base_directory=Path(self.test_dir))+ filepath = Path(self.outside_file)+ with pytest.raises(HTTPException) as exc_info:+ validator.validate_file_access(filepath)+ assert exc_info.value.status_code == HTTPStatus.FORBIDDEN