Skip to content

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.

refactor: cleanup app-router (#7628)

Myles Scolnickbfb742acaef4
diff --git a/marimo/_pyodide/bootstrap.py b/marimo/_pyodide/bootstrap.py
index 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 AppDefaults
from marimo._server.models.models import SaveNotebookRequest
from marimo._session.model import SessionMode
from 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.app
diff --git a/marimo/_server/api/endpoints/assets.py b/marimo/_server/api/endpoints/assets.py
index 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_manager
from marimo._output.utils import uri_decode_component, uri_encode_component
from marimo._runtime.virtual_file import EMPTY_VIRTUAL_FILE, read_virtual_file
from marimo._server.api.deps import AppState
-from marimo._server.file_router import validate_inside_directory
+from marimo._server.files.path_validator import PathValidator
from marimo._server.router import APIRouter
from 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 directory
try:
- 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.py
index 72c95f839e..a54ac3f1c0 100644
--- a/marimo/_server/api/endpoints/home.py
+++ b/marimo/_server/api/endpoints/home.py
@@ -13,10 +13,10 @@ from marimo import _loggers
from marimo._server.api.deps import AppState
from marimo._server.api.utils import parse_request
from marimo._server.file_router import (
- MAX_FILES,
LazyListOfFilesAppFileRouter,
count_files,
)
+from marimo._server.files.directory_scanner import DirectoryScanner
from marimo._server.models.home import (
MarimoFile,
OpenTutorialRequest,
@@ -34,6 +34,8 @@ from marimo._utils.paths import pretty_path
if TYPE_CHECKING:
from starlette.requests import Request
+MAX_FILES = DirectoryScanner.MAX_FILES
+
LOGGER = _loggers.marimo_logger()
# Router for home endpoints
diff --git a/marimo/_server/app_defaults.py b/marimo/_server/app_defaults.py
new file mode 100644
index 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.py
index e743db1658..4c299dc596 100644
--- a/marimo/_server/file_router.py
+++ b/marimo/_server/file_router.py
@@ -3,37 +3,27 @@ from __future__ import annotations
import abc
import os
-import signal
-from contextlib import contextmanager
from pathlib import Path
-from typing import TYPE_CHECKING, Optional
+from typing import Optional
from 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 PathValidator
from marimo._server.models.files import FileInfo
from marimo._server.models.home import MarimoFile
from marimo._session.notebook import AppFileManager
from marimo._utils.http import HTTPException, HTTPStatus
from 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 file
MarimoFileKey = str
class 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_markdown
self._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)
@property
def 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 format
if 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 timeout
LOGGER.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_results
else:
raise
return 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 = 0
diff --git a/marimo/_server/files/directory_scanner.py b/marimo/_server/files/directory_scanner.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
index 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 AppDefaults
from marimo._server.file_router import AppFileRouter, MarimoFileKey
from marimo._server.lsp import LspServer
from 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).app
return "".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 session
diff --git a/marimo/_session/notebook/file_manager.py b/marimo/_session/notebook/file_manager.py
index 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 load
from marimo._ast.app import App, InternalApp
from marimo._ast.app_config import overloads_from_env
from marimo._ast.cell import CellConfig
-from marimo._config.config import ExportType, SqlOutputType, WidthType
from 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 AppDefaults
from marimo._session.notebook.serializer import get_format_handler
from 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 app
self.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_output
empty_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.py
index 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 asyncio
import sys
-from collections.abc import AsyncGenerator
-from typing import cast
+from typing import TYPE_CHECKING, cast
import 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: ignore
async 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.py
new file mode 100644
index 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_file
diff --git a/tests/_server/test_file_manager.py b/tests/_server/test_file_manager.py
index bb9061adae..4034ee96fc 100644
--- a/tests/_server/test_file_manager.py
+++ b/tests/_server/test_file_manager.py
@@ -9,6 +9,7 @@ import pytest
from marimo import __version__
from marimo._ast.app import App, InternalApp
from marimo._ast.cell import CellConfig
+from marimo._server.app_defaults import AppDefaults
from marimo._server.models.models import SaveNotebookRequest
from marimo._session.notebook import AppFileManager
from marimo._types.ids import CellId_t
@@ -628,8 +629,10 @@ def test_default_app_settings(tmp_path: Path) -> None:
# Test with custom defaults
manager = 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.py
index 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 PathValidator
from marimo._server.models.home import MarimoFile
from 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.FORBIDDEN
def test_absolute_directory_relative_filepath_inside(self):
@@ -209,7 +209,7 @@ class TestValidateInsideDirectory(unittest.TestCase):
# Change to test_dir so relative path resolves correctly
os.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.FORBIDDEN
def 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.FORBIDDEN
def 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.FORBIDDEN
def 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.FORBIDDEN
def 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.FORBIDDEN
def 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 file
with 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.FORBIDDEN
symlink_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 outside
broken_symlink.unlink()
@@ -321,7 +321,9 @@ class TestValidateInsideDirectory(unittest.TestCase):
broken_symlink.symlink_to("../../etc/passwd")
# Should fail because resolved path is outside
with 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.FORBIDDEN
broken_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_REQUEST
def 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_REQUEST
def test_same_path(self):
@@ -364,7 +366,7 @@ class TestValidateInsideDirectory(unittest.TestCase):
filepath = Path(self.test_dir).resolve()
# Directory is not inside itself
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
def 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_REQUEST
def test_absolute_path_with_dotdot_resolved(self):
@@ -382,7 +384,9 @@ class TestValidateInsideDirectory(unittest.TestCase):
# Create path with .. that still resolves inside
filepath = 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_FILES
try:
# Set a small limit for testing
- file_router_module.MAX_FILES = 5
+ DirectoryScanner.MAX_FILES = 5
# Create 10 marimo files
for 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_files
def test_lazy_router_skips_common_dirs(tmp_path: Path):
diff --git a/tests/_server/test_path_validator.py b/tests/_server/test_path_validator.py
new file mode 100644
index 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