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
fix: relative path fixes for home mode (#7722)
Dylan Madisettie1b996360bab
diff --git a/marimo/_server/api/endpoints/assets.py b/marimo/_server/api/endpoints/assets.pyindex ad24df8db6..ed2640e7d6 100644--- a/marimo/_server/api/endpoints/assets.py+++ b/marimo/_server/api/endpoints/assets.py@@ -144,6 +144,15 @@ async def index(request: Request) -> HTMLResponse:app_manager = app_state.session_manager.app_manager(file_key)app_config = app_manager.app.config+ # Make filename relative to file router's directory if possible+ filename = app_manager.filename+ directory = app_state.session_manager.file_router.directory+ if filename and directory:+ try:+ filename = str(Path(filename).relative_to(directory))+ except ValueError:+ pass # Keep absolute if not under directory+html = notebook_page_template(html=html,base_url=app_state.base_url,@@ -151,7 +160,7 @@ async def index(request: Request) -> HTMLResponse:config_overrides=config_manager.get_config_overrides(),server_token=app_state.skew_protection_token,app_config=app_config,- filename=app_manager.filename,+ filename=filename,mode=app_state.mode,runtime_config=[{"url": app_state.remote_url}]if app_state.remote_urldiff --git a/marimo/_server/api/endpoints/file_explorer.py b/marimo/_server/api/endpoints/file_explorer.pyindex ac51db862c..7c7f0a6789 100644--- a/marimo/_server/api/endpoints/file_explorer.py+++ b/marimo/_server/api/endpoints/file_explorer.py@@ -65,8 +65,11 @@ async def list_files(schema:$ref: "#/components/schemas/FileListResponse""""+ app_state = AppState(request)body = await parse_request(request, cls=FileListRequest)- root = body.path or file_system.get_root()+ # Use file router's directory as default, fall back to cwd+ directory = app_state.session_manager.file_router.directory+ root = body.path or directory or file_system.get_root()files = file_system.list_files(root)return FileListResponse(files=files, root=root)diff --git a/marimo/_server/api/endpoints/files.py b/marimo/_server/api/endpoints/files.pyindex c9044a026c..d7080670db 100644--- a/marimo/_server/api/endpoints/files.py+++ b/marimo/_server/api/endpoints/files.py@@ -1,6 +1,7 @@# Copyright 2026 Marimo. All rights reserved.from __future__ import annotations+from pathlib import Pathfrom typing import TYPE_CHECKINGfrom starlette.authentication import requires@@ -109,9 +110,15 @@ async def rename_file("""body = await parse_request(request, cls=RenameNotebookRequest)app_state = AppState(request)++ # Resolve relative filenames against the file router's directory+ if not Path(body.filename).is_absolute():+ directory = app_state.session_manager.file_router.directory+ if directory:+ body.filename = str(Path(directory) / body.filename)+filename = await abspath(body.filename)- # Convert to absolute pathapp_state.require_current_session().put_control_request(RenameNotebookCommand(filename=filename),from_consumer_id=ConsumerId(app_state.require_current_session_id()),@@ -152,6 +159,13 @@ async def save("""app_state = AppState(request)body = await parse_request(request, cls=SaveNotebookRequest)++ # Resolve relative filenames against the file router's directory+ if body.filename and not Path(body.filename).is_absolute():+ directory = app_state.session_manager.file_router.directory+ if directory:+ body.filename = str(Path(directory) / body.filename)+session = app_state.require_current_session()contents = session.app_file_manager.save(body)@@ -186,6 +200,13 @@ async def copy("""app_state = AppState(request)body = await parse_request(request, cls=CopyNotebookRequest)++ # Resolve relative filenames against the file router's directory+ if body.destination and not Path(body.destination).is_absolute():+ directory = app_state.session_manager.file_router.directory+ if directory:+ body.destination = str(Path(directory) / body.destination)+session = app_state.require_current_session()contents = session.app_file_manager.copy(body)diff --git a/marimo/_server/api/endpoints/home.py b/marimo/_server/api/endpoints/home.pyindex a54ac3f1c0..807d99e7dd 100644--- a/marimo/_server/api/endpoints/home.py+++ b/marimo/_server/api/endpoints/home.py@@ -3,6 +3,7 @@ from __future__ import annotationsimport asyncioimport os+import pathlibimport tempfilefrom typing import TYPE_CHECKING@@ -58,7 +59,12 @@ async def read_code($ref: "#/components/schemas/RecentFilesResponse""""app_state = AppState(request)- files = app_state.session_manager.recents.get_recents()+ # Pass the file router's directory to filter and relativize paths+ directory = None+ dir_str = app_state.session_manager.file_router.directory+ if dir_str:+ directory = pathlib.Path(dir_str)+ files = app_state.session_manager.recents.get_recents(directory)return RecentFilesResponse(files=files)diff --git a/marimo/_server/file_router.py b/marimo/_server/file_router.pyindex 4c299dc596..3410d9d20e 100644--- a/marimo/_server/file_router.py+++ b/marimo/_server/file_router.py@@ -167,15 +167,16 @@ class ListOfFilesAppFileRouter(AppFileRouter):class LazyListOfFilesAppFileRouter(AppFileRouter):def __init__(self, directory: str, include_markdown: bool) -> None:- # pass through Path to canonicalize, strips trailing slashes- self._directory = str(Path(directory))+ # Make directory absolute but don't resolve symlinks to preserve user paths+ abs_directory = Path(directory).absolute()+ self._directory = str(abs_directory)self.include_markdown = include_markdownself._lazy_files: Optional[list[FileInfo]] = None# Use PathValidator for security validation- self._validator = PathValidator(Path(directory))- # Use DirectoryScanner for file discovery- self._scanner = DirectoryScanner(directory, include_markdown)+ self._validator = PathValidator(abs_directory)+ # Use DirectoryScanner for file discovery (use absolute path)+ self._scanner = DirectoryScanner(str(abs_directory), include_markdown)@propertydef directory(self) -> str:@@ -233,23 +234,22 @@ class LazyListOfFilesAppFileRouter(AppFileRouter):directory = Path(self._directory)filepath = Path(key)+ # Resolve filepath for use+ # If filepath is relative, resolve it relative to directory+ if not filepath.is_absolute():+ filepath = directory / filepath+# Use PathValidator for security validation# Check if file is in an allowed temp directory (e.g., for tutorials)# If so, skip the directory validationis_in_allowed_temp_dir = self._validator.is_file_in_allowed_temp_dir(- key+ str(filepath))if not is_in_allowed_temp_dir:# Validate that filepath is inside directoryself._validator.validate_inside_directory(directory, filepath)- # Resolve filepath for use- # If directory is absolute and filepath is relative, resolve relative to directory- if directory.is_absolute() and not filepath.is_absolute():- filepath = directory / filepath- # Note: We don't call resolve() here to preserve the original path format-if filepath.exists():return AppFileManager(str(filepath), defaults=defaults)diff --git a/marimo/_server/files/directory_scanner.py b/marimo/_server/files/directory_scanner.pyindex 66df3453b4..1ea9b36b86 100644--- a/marimo/_server/files/directory_scanner.py+++ b/marimo/_server/files/directory_scanner.py@@ -3,6 +3,7 @@ from __future__ import annotationsimport osimport time+from pathlib import Pathfrom typing import Optionalfrom marimo import _loggers@@ -183,10 +184,14 @@ class DirectoryScanner:continuechildren = recurse(entry.path, depth + 1)if children:+ entry_path = Path(entry.path)+ relative_path = str(+ entry_path.relative_to(self.directory)+ )folders.append(FileInfo(- id=entry.path,- path=entry.path,+ id=relative_path,+ path=relative_path,name=entry.name,is_directory=True,is_marimo_file=False,@@ -196,9 +201,13 @@ class DirectoryScanner:elif entry.name.endswith(self.allowed_extensions):if is_marimo_app(entry.path):file_count[0] += 1+ entry_path = Path(entry.path)+ relative_path = str(+ entry_path.relative_to(self.directory)+ )file_info = FileInfo(- id=entry.path,- path=entry.path,+ id=relative_path,+ path=relative_path,name=entry.name,is_directory=False,is_marimo_file=True,diff --git a/marimo/_server/recents.py b/marimo/_server/recents.pyindex 2c10cee2c2..7037c45ff2 100644--- a/marimo/_server/recents.py+++ b/marimo/_server/recents.py@@ -1,14 +1,12 @@# Copyright 2026 Marimo. All rights reserved.from __future__ import annotations-import osimport pathlibfrom dataclasses import dataclass, fieldfrom marimo import _loggersfrom marimo._server.models.home import MarimoFilefrom marimo._utils.config.config import ConfigReader-from marimo._utils.paths import pretty_path@dataclass@@ -77,7 +75,9 @@ class RecentFilesManager:self.config.write_toml(state)- def get_recents(self) -> list[MarimoFile]:+ def get_recents(+ self, directory: pathlib.Path | None = None+ ) -> list[MarimoFile]:if not self.config:return []@@ -86,19 +86,21 @@ class RecentFilesManager:)files: list[MarimoFile] = []- cwd = pathlib.Path.cwd()+ base_dir = directory or pathlib.Path.cwd()limited_files = state.files[: self.MAX_FILES]for file in limited_files:file_path = pathlib.Path(file)- if _is_tmp_file(file) or cwd not in file_path.parents:+ if _is_tmp_file(file) or not file_path.is_relative_to(base_dir):continue- if not os.path.exists(file):+ if not file_path.exists():continue+ # Return path relative to base_dir+ relative_path = file_path.relative_to(base_dir)files.append(MarimoFile(- name=os.path.basename(file),- path=pretty_path(file),- last_modified=os.path.getmtime(file),+ name=file_path.name,+ path=str(relative_path),+ last_modified=file_path.stat().st_mtime,))diff --git a/marimo/_server/session_manager.py b/marimo/_server/session_manager.pyindex 84e72d0c73..a4a6139632 100644--- a/marimo/_server/session_manager.py+++ b/marimo/_server/session_manager.py@@ -109,6 +109,7 @@ class SessionManager:# Add recents tracking listenerself.recents = RecentFilesManager()self._event_bus = SessionEventBus()+ self._event_bus.subscribe(RecentsTrackerListener(self.recents))# Initialize file watching componentsself._watcher_manager = FileWatcherManager()@@ -160,9 +161,7 @@ class SessionManager:# Create the sessionfrom marimo._runtime.commands import AppMetadata- extensions: list[SessionExtension] = [- RecentsTrackerListener(self.recents)- ]+ extensions: list[SessionExtension] = []if self.watch:extensions.append(SessionFileWatcherExtension(diff --git a/tests/_server/test_file_manager_absolute_path.py b/tests/_server/test_file_manager_absolute_path.pyindex 029ad4af75..cb8b8de53e 100644--- a/tests/_server/test_file_manager_absolute_path.py+++ b/tests/_server/test_file_manager_absolute_path.py@@ -4,6 +4,7 @@from __future__ import annotationsimport os+import sysfrom pathlib import Pathimport pytest@@ -11,6 +12,8 @@ import pytestfrom marimo._server.file_router import AppFileRouterfrom marimo._utils.http import HTTPException, HTTPStatus+is_windows = sys.platform == "win32"+class TestAbsoluteDirectoryPath:"""Test that absolute directory paths work correctly."""@@ -43,19 +46,21 @@ if __name__ == "__main__":absolute_dir = str(test_dir.absolute())router = AppFileRouter.from_directory(absolute_dir)- # The directory should be stored correctly+ # The directory should be stored correctly (always absolute)assert router.directory == absolute_dir- # Get the files - they should have absolute paths+ # Get the files - they have relative paths (relative to directory)files = router.filesassert len(files) > 0file_info = files[0]assert file_info.is_marimo_file- assert file_info.path == str(test_file)+ # Path is relative to the directory+ assert file_info.path == "notebook.py"- # Try to get a file manager using the file path+ # Try to get a file manager using the relative path from files listfile_manager = router.get_file_manager(file_info.path)assert file_manager is not None+ # File manager resolves to absolute pathassert file_manager.filename == str(test_file)assert file_manager.is_notebook_named@@ -92,19 +97,22 @@ if __name__ == "__main__":relative_dir = "test_dir"router = AppFileRouter.from_directory(relative_dir)- # The directory should be stored correctly- assert router.directory == relative_dir+ # The directory is converted to absolute for consistency+ assert router.directory == str(test_dir.absolute())- # Get the files+ # Get the files - paths are relative to the directoryfiles = router.filesassert len(files) > 0file_info = files[0]assert file_info.is_marimo_file+ assert file_info.path == "notebook.py"- # Try to get a file manager using the file path+ # Try to get a file manager using the relative file pathfile_manager = router.get_file_manager(file_info.path)assert file_manager is not Noneassert file_manager.is_notebook_named+ # File manager resolves to absolute path+ assert file_manager.filename == str(test_file.absolute())finally:os.chdir(original_cwd)@@ -406,7 +414,7 @@ if __name__ == "__main__":file_manager_from_basename = router.get_file_manager(basename)assert file_manager_from_basename is not Noneassert file_manager_from_basename.is_notebook_named- except HTTPException as e:+ except HTTPException:# This is the bug - it should have resolved relative to router.directorypytest.fail(f"Should be able to open file with basename '{basename}' "@@ -459,13 +467,13 @@ if __name__ == "__main__":os.chdir(other_dir)# Try to open with relative path- relative_path = "subdir/notebook.py"+ relative_path = os.path.join("subdir", "notebook.py")try:file_manager = router.get_file_manager(relative_path)assert file_manager is not Noneassert file_manager.is_notebook_named- except HTTPException as e:+ except HTTPException:pytest.fail(f"Should be able to open file with relative path '{relative_path}' "f"when router has absolute directory '{absolute_dir}'"@@ -494,12 +502,15 @@ if __name__ == "__main__":files = router.filesassert len(files) == 2- # All paths should be absolute+ # All paths are now relative to the directoryfor file_info in files:- assert Path(file_info.path).is_absolute()- assert file_info.path.startswith(absolute_dir)+ # Paths are relative (just the filename for top-level files)+ assert not Path(file_info.path).is_absolute()+ # When joined with directory, should form a valid path+ full_path = Path(absolute_dir) / file_info.path+ assert full_path.exists()- # Verify each file can be opened using its path+ # Verify each file can be opened using its relative pathfor file_info in files:file_manager = router.get_file_manager(file_info.path)assert file_manager is not None@@ -562,3 +573,259 @@ if __name__ == "__main__":router.get_file_manager(str(secret_file.absolute()))assert exc_info.value.status_code == HTTPStatus.FORBIDDEN+++class TestRelativePathsInFileListing:+ """Test that files list returns correct relative paths for various structures."""++ def test_nested_directory_returns_relative_paths(+ self, tmp_path: Path+ ) -> None:+ """Test that files in subdirectories have correct relative paths."""+ # Create nested structure+ test_dir = tmp_path / "test_dir"+ test_dir.mkdir()+ subdir = test_dir / "subdir"+ subdir.mkdir()++ # Create files at different levels+ root_file = test_dir / "root.py"+ root_file.write_text("import marimo\napp = marimo.App()")++ nested_file = subdir / "nested.py"+ nested_file.write_text("import marimo\napp = marimo.App()")++ # Create router+ router = AppFileRouter.from_directory(str(test_dir.absolute()))++ files = router.files+ file_paths = _collect_file_paths(files)++ # Should have both files with relative paths+ assert "root.py" in file_paths+ assert os.path.join("subdir", "nested.py") in file_paths++ # Both should be openable using their relative paths+ for path in _collect_file_paths(files):+ file_manager = router.get_file_manager(path)+ assert file_manager is not None+ assert file_manager.is_notebook_named++ def test_deep_nesting_returns_correct_paths(self, tmp_path: Path) -> None:+ """Test deeply nested directories have correct relative paths."""+ # Create deep structure: test_dir/a/b/c/notebook.py+ test_dir = tmp_path / "test_dir"+ test_dir.mkdir()+ dir_a = test_dir / "a"+ dir_a.mkdir()+ dir_b = dir_a / "b"+ dir_b.mkdir()+ dir_c = dir_b / "c"+ dir_c.mkdir()++ deep_file = dir_c / "notebook.py"+ deep_file.write_text("import marimo\napp = marimo.App()")++ # Create router+ router = AppFileRouter.from_directory(str(test_dir.absolute()))++ files = router.files+ file_paths = _collect_file_paths(files)++ # Should have the deep file with correct relative path+ expected_path = os.path.join("a", "b", "c", "notebook.py")+ assert expected_path in file_paths++ # Should be openable using the actual path from the files list+ actual_paths = _collect_file_paths(files)+ file_manager = router.get_file_manager(actual_paths[0])+ assert file_manager is not None+ assert file_manager.filename == str(deep_file.absolute())++ def test_both_relative_and_absolute_paths_work(+ self, tmp_path: Path+ ) -> None:+ """Test that both relative and absolute paths can open the same file."""+ test_dir = tmp_path / "test_dir"+ test_dir.mkdir()++ test_file = test_dir / "notebook.py"+ test_file.write_text("import marimo\napp = marimo.App()")++ router = AppFileRouter.from_directory(str(test_dir.absolute()))++ # Get the relative path from files list+ files = router.files+ assert len(files) == 1+ relative_path = files[0].path+ assert relative_path == "notebook.py"++ # Open with relative path+ manager_from_relative = router.get_file_manager(relative_path)+ assert manager_from_relative is not None++ # Open with absolute path+ absolute_path = str(test_file.absolute())+ manager_from_absolute = router.get_file_manager(absolute_path)+ assert manager_from_absolute is not None++ # Both should point to the same file+ assert manager_from_relative.filename == manager_from_absolute.filename++ def test_path_traversal_in_relative_path_blocked(+ self, tmp_path: Path+ ) -> None:+ """Test that path traversal attacks using relative paths are blocked."""+ test_dir = tmp_path / "test_dir"+ test_dir.mkdir()++ # Create a file outside test_dir+ outside_file = tmp_path / "outside.py"+ outside_file.write_text("import marimo\napp = marimo.App()")++ router = AppFileRouter.from_directory(str(test_dir.absolute()))++ # Try to access file outside using path traversal+ with pytest.raises(HTTPException) as exc_info:+ router.get_file_manager("../outside.py")++ assert exc_info.value.status_code == HTTPStatus.FORBIDDEN++ @pytest.mark.skipif(is_windows, reason="Non-windows tests")+ def test_path_traversal_multiple_levels_blocked(+ self, tmp_path: Path+ ) -> None:+ """Test that multi-level path traversal is blocked."""+ test_dir = tmp_path / "test_dir"+ test_dir.mkdir()++ router = AppFileRouter.from_directory(str(test_dir.absolute()))++ # Try various path traversal attempts+ traversal_attempts = [+ "../../../etc/passwd",+ "subdir/../../outside.py",+ "a/../../../etc/passwd",+ ]++ for attempt in traversal_attempts:+ with pytest.raises(HTTPException) as exc_info:+ router.get_file_manager(str(attempt))+ assert exc_info.value.status_code == HTTPStatus.FORBIDDEN, (+ f"Path traversal '{attempt}' should be blocked"+ )+++class TestFileManagerPathResolution:+ """Test file manager path resolution edge cases."""++ @pytest.mark.skipif(is_windows, reason="Non-windows tests")+ def test_file_manager_with_dot_path(self, tmp_path: Path) -> None:+ """Test that '.' in paths is handled correctly."""+ test_dir = tmp_path / "test_dir"+ test_dir.mkdir()++ test_file = test_dir / "notebook.py"+ test_file.write_text("import marimo\napp = marimo.App()")++ router = AppFileRouter.from_directory(str(test_dir.absolute()))++ # Try to open with ./ prefix+ file_manager = router.get_file_manager("./notebook.py")+ assert file_manager is not None+ assert file_manager.filename == str(test_file.absolute())++ @pytest.mark.skipif(is_windows, reason="// has special meaning on Windows")+ def test_file_manager_with_redundant_slashes(self, tmp_path: Path) -> None:+ """Test that redundant slashes in paths are handled."""+ test_dir = tmp_path / "test_dir"+ test_dir.mkdir()+ subdir = test_dir / "subdir"+ subdir.mkdir()++ test_file = subdir / "notebook.py"+ test_file.write_text("import marimo\napp = marimo.App()")++ router = AppFileRouter.from_directory(str(test_dir.absolute()))++ # Path normalization should handle redundant slashes+ file_manager = router.get_file_manager("subdir//notebook.py")+ assert file_manager is not None+ assert file_manager.filename == str(test_file.absolute())++ def test_nonexistent_file_returns_not_found(self, tmp_path: Path) -> None:+ """Test that accessing a nonexistent file returns NOT_FOUND."""+ test_dir = tmp_path / "test_dir"+ test_dir.mkdir()++ router = AppFileRouter.from_directory(str(test_dir.absolute()))++ with pytest.raises(HTTPException) as exc_info:+ router.get_file_manager("nonexistent.py")++ assert exc_info.value.status_code == HTTPStatus.NOT_FOUND++ def test_directory_stored_as_absolute(self, tmp_path: Path) -> None:+ """Test that directory is always stored as absolute path."""+ test_dir = tmp_path / "test_dir"+ test_dir.mkdir()++ original_cwd = os.getcwd()+ try:+ os.chdir(tmp_path)++ # Create router with relative path+ router = AppFileRouter.from_directory("test_dir")++ # Directory should be stored as absolute+ assert router.directory is not None+ assert Path(router.directory).is_absolute()+ assert router.directory == str(test_dir.absolute())+ finally:+ os.chdir(original_cwd)++ def test_files_accessible_after_cwd_change(self, tmp_path: Path) -> None:+ """Test that files remain accessible after changing working directory."""+ test_dir = tmp_path / "test_dir"+ test_dir.mkdir()+ other_dir = tmp_path / "other_dir"+ other_dir.mkdir()++ test_file = test_dir / "notebook.py"+ test_file.write_text("import marimo\napp = marimo.App()")++ original_cwd = os.getcwd()+ try:+ # Create router while in tmp_path+ os.chdir(tmp_path)+ router = AppFileRouter.from_directory(str(test_dir.absolute()))++ # Get files list+ files = router.files+ assert len(files) == 1+ relative_path = files[0].path++ # Change to a completely different directory+ os.chdir(other_dir)++ # Should still be able to open file using relative path+ file_manager = router.get_file_manager(relative_path)+ assert file_manager is not None+ assert file_manager.filename == str(test_file.absolute())++ # Should still be able to read content+ content = file_manager.read_file()+ assert "marimo.App" in content+ finally:+ os.chdir(original_cwd)+++# Find all file paths (including in nested children)+def _collect_file_paths(items: list) -> list[str]:+ paths = []+ for item in items:+ if not item.is_directory:+ paths.append(item.path)+ if item.children:+ paths.extend(_collect_file_paths(item.children))+ return pathsdiff --git a/tests/_server/test_file_router.py b/tests/_server/test_file_router.pyindex 323ca50336..74c818e0d2 100644--- a/tests/_server/test_file_router.py+++ b/tests/_server/test_file_router.py@@ -145,7 +145,7 @@ class TestAppFileRouter(unittest.TestCase):filename = self.test_file1.nameassert os.path.exists(filename), f"File {filename} does not exist"file_manager = router.get_file_manager(key=filename)- assert file_manager.filename == os.path.join(self.test_dir, filename)+ assert file_manager.filename == filenamedef test_lazy_list_of_get_app_file_manager_nested(self):router = LazyListOfFilesAppFileRouter(@@ -510,7 +510,8 @@ def test_lazy_router_skips_common_dirs(tmp_path: Path):# Should only find the root file, not files in skipped directoriesfile_paths = [f.path for f in files if not f.is_directory]assert len(file_paths) == 1- assert str(root_file) in file_paths+ # Paths are now relative to the router's directory+ assert root_file.name in file_pathsdef test_lazy_router_counts_nested_files(tmp_path: Path):diff --git a/tests/_server/test_session_manager.py b/tests/_server/test_session_manager.pyindex fb9a6e869e..2f3149047f 100644--- a/tests/_server/test_session_manager.py+++ b/tests/_server/test_session_manager.py@@ -9,6 +9,7 @@ import pytestfrom marimo._config.manager import get_default_config_managerfrom marimo._server.file_router import AppFileRouterfrom marimo._server.lsp import LspServer+from marimo._server.session.listeners import RecentsTrackerListenerfrom marimo._server.session_manager import SessionManagerfrom marimo._server.tokens import AuthToken, SkewProtectionTokenfrom marimo._session import (@@ -395,3 +396,72 @@ def test_session_manager_auth_token_run_mode_without_provided_token(assert str(session_manager.skew_protection_token) == str(session_manager2.skew_protection_token)+++def test_recents_listener_subscribed_to_event_bus(+ session_manager: SessionManager,+) -> None:+ """Test that RecentsTrackerListener is subscribed to session manager's event bus.++ This is a regression test for a bug where the listener was moved to be a+ session extension (subscribing to the session's event bus) but the+ emit_session_created event was still fired on the session manager's event bus,+ causing recent files to not be tracked.+ """+ # Verify that RecentsTrackerListener is in the event bus listeners+ listeners = session_manager._event_bus._listeners+ recents_listeners = [+ listen+ for listen in listeners+ if isinstance(listen, RecentsTrackerListener)+ ]+ assert len(recents_listeners) == 1, (+ "RecentsTrackerListener should be subscribed to session manager's event bus"+ )+++async def test_recents_touch_called_on_session_create(+ session_manager: SessionManager,+ mock_session_consumer: SessionConsumer,+ tmp_path: Path,+) -> None:+ """Test that recents.touch() is called when a session is created with a file.++ This verifies the full integration: when a session is created for a file,+ the RecentsTrackerListener receives the event and calls touch().+ """+ # Create a temp marimo file+ tmp_file = tmp_path / "test_recents.py"+ tmp_file.write_text(+ "import marimo\napp = marimo.App()\[email protected]\ndef _(): pass"+ )++ # Track calls to touch()+ original_touch = session_manager.recents.touch+ touched_files: list[str] = []++ def mock_touch(filename: str) -> None:+ touched_files.append(filename)+ original_touch(filename)++ session_manager.recents.touch = mock_touch # type: ignore++ # Create a session+ session = session_manager.create_session(+ SessionId("recents_test_session"),+ mock_session_consumer,+ query_params={},+ file_key=str(tmp_file),+ auto_instantiate=False,+ )++ # Allow async event to process+ import asyncio++ await asyncio.sleep(0.1)++ # Verify touch was called with the file path+ assert len(touched_files) == 1+ assert str(tmp_file) in touched_files[0]++ session.close()