griptape-nodes 0.42.0__py3-none-any.whl → 0.43.0__py3-none-any.whl

griptape_nodes/retained_mode/managers/os_manager.py

@@ -1,27 +1,38 @@
-import logging
+import base64
+import mimetypes
 import os
 import shutil
 import subprocess
 import sys
+from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, NamedTuple
+from typing import Any
 
+from binaryornot.check import is_binary
 from rich.console import Console
 
 from griptape_nodes.retained_mode.events.base_events import ResultPayload
 from griptape_nodes.retained_mode.events.os_events import (
+    FileSystemEntry,
+    ListDirectoryRequest,
+    ListDirectoryResultFailure,
+    ListDirectoryResultSuccess,
     OpenAssociatedFileRequest,
     OpenAssociatedFileResultFailure,
     OpenAssociatedFileResultSuccess,
+    ReadFileRequest,
+    ReadFileResultFailure,
+    ReadFileResultSuccess,
 )
+from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes, logger
 from griptape_nodes.retained_mode.managers.event_manager import EventManager
 
 console = Console()
-logger = logging.getLogger("griptape_nodes")
 
 
-class DiskSpaceInfo(NamedTuple):
-    """Disk space information in bytes."""
+@dataclass
+class DiskSpaceInfo:
+    """Information about disk space usage."""
 
     total: int
     used: int
@@ -40,6 +51,127 @@ class OSManager:
             event_manager.assign_manager_to_request_type(
                 request_type=OpenAssociatedFileRequest, callback=self.on_open_associated_file_request
             )
+            event_manager.assign_manager_to_request_type(
+                request_type=ListDirectoryRequest, callback=self.on_list_directory_request
+            )
+
+            event_manager.assign_manager_to_request_type(
+                request_type=ReadFileRequest, callback=self.on_read_file_request
+            )
+
+    def _get_workspace_path(self) -> Path:
+        """Get the workspace path from config."""
+        return GriptapeNodes.ConfigManager().workspace_path
+
+    def _expand_path(self, path_str: str) -> Path:
+        """Expand a path string, handling tilde and environment variables.
+
+        Args:
+            path_str: Path string that may contain ~ or environment variables
+
+        Returns:
+            Expanded Path object
+        """
+        # Expand environment variables first, then tilde
+        expanded_vars = os.path.expandvars(path_str)
+        return Path(expanded_vars).expanduser().resolve()
+
+    def _resolve_file_path(self, path_str: str, *, workspace_only: bool = False) -> Path:
+        """Resolve a file path, handling absolute, relative, and tilde paths.
+
+        Args:
+            path_str: Path string that may be absolute, relative, or start with ~
+            workspace_only: If True and path is invalid, fall back to workspace directory
+
+        Returns:
+            Resolved Path object
+        """
+        try:
+            if Path(path_str).is_absolute() or path_str.startswith("~"):
+                # Expand tilde and environment variables for absolute paths or paths starting with ~
+                return self._expand_path(path_str)
+            # Both workspace and system-wide modes resolve relative to current directory
+            return (self._get_workspace_path() / path_str).resolve()
+        except (ValueError, RuntimeError):
+            if workspace_only:
+                msg = f"Path '{path_str}' not found, using workspace directory: {self._get_workspace_path()}"
+                logger.warning(msg)
+                return self._get_workspace_path()
+            # Re-raise the exception for non-workspace mode
+            raise
+
+    def _validate_workspace_path(self, path: Path) -> tuple[bool, Path]:
+        """Check if a path is within workspace and return relative path if it is.
+
+        Args:
+            path: Path to validate
+
+        Returns:
+            Tuple of (is_workspace_path, relative_or_absolute_path)
+        """
+        workspace = GriptapeNodes.ConfigManager().workspace_path
+
+        # Ensure both paths are resolved for comparison
+        path = path.resolve()
+        workspace = workspace.resolve()
+
+        msg = f"Validating path: {path} against workspace: {workspace}"
+        logger.debug(msg)
+
+        try:
+            relative = path.relative_to(workspace)
+        except ValueError:
+            msg = f"Path is outside workspace: {path}"
+            logger.debug(msg)
+            return False, path
+
+        msg = f"Path is within workspace, relative path: {relative}"
+        logger.debug(msg)
+        return True, relative
+
+    def _validate_read_file_request(self, request: ReadFileRequest) -> tuple[Path, str]:
+        """Validate read file request and return resolved file path and path string."""
+        # Validate that exactly one of file_path or file_entry is provided
+        if request.file_path is None and request.file_entry is None:
+            msg = "Either file_path or file_entry must be provided"
+            logger.error(msg)
+            raise ValueError(msg)
+
+        if request.file_path is not None and request.file_entry is not None:
+            msg = "Only one of file_path or file_entry should be provided, not both"
+            logger.error(msg)
+            raise ValueError(msg)
+
+        # Get the file path to read - handle paths consistently
+        if request.file_entry is not None:
+            file_path_str = request.file_entry.path
+        elif request.file_path is not None:
+            file_path_str = request.file_path
+        else:
+            msg = "No valid file path provided"
+            logger.error(msg)
+            raise ValueError(msg)
+
+        file_path = self._resolve_file_path(file_path_str, workspace_only=request.workspace_only is True)
+
+        # Check if file exists and is actually a file
+        if not file_path.exists():
+            msg = f"File does not exist: {file_path}"
+            logger.error(msg)
+            raise FileNotFoundError(msg)
+        if not file_path.is_file():
+            msg = f"File is not a file: {file_path}"
+            logger.error(msg)
+            raise FileNotFoundError(msg)
+
+        # Check workspace constraints
+        is_workspace_path, _ = self._validate_workspace_path(file_path)
+        if request.workspace_only and not is_workspace_path:
+            msg = f"File is outside workspace: {file_path}"
+            logger.error(msg)
+            raise ValueError(msg)
+
+        return file_path, file_path_str
 
     @staticmethod
     def platform() -> str:
@@ -72,12 +204,43 @@ class OSManager:
             sys.stdout.flush()  # Recommended here https://docs.python.org/3/library/os.html#os.execvpe
             os.execvp(args[0], args)  # noqa: S606
 
-    def on_open_associated_file_request(self, request: OpenAssociatedFileRequest) -> ResultPayload:  # noqa: PLR0911
+    def on_open_associated_file_request(self, request: OpenAssociatedFileRequest) -> ResultPayload:  # noqa: C901, PLR0911, PLR0912
+        # Validate that exactly one of path_to_file or file_entry is provided
+        if request.path_to_file is None and request.file_entry is None:
+            msg = "Either path_to_file or file_entry must be provided"
+            logger.error(msg)
+            return OpenAssociatedFileResultFailure()
+
+        if request.path_to_file is not None and request.file_entry is not None:
+            msg = "Only one of path_to_file or file_entry should be provided, not both"
+            logger.error(msg)
+            return OpenAssociatedFileResultFailure()
+
+        # Get the file path to open
+        if request.file_entry is not None:
+            # Use the path from the FileSystemEntry
+            file_path_str = request.file_entry.path
+        elif request.path_to_file is not None:
+            # Use the provided path_to_file
+            file_path_str = request.path_to_file
+        else:
+            # This should never happen due to validation above, but type checker needs it
+            msg = "No valid file path provided"
+            logger.error(msg)
+            return OpenAssociatedFileResultFailure()
+
+        # At this point, file_path_str is guaranteed to be a string
+        if file_path_str is None:
+            msg = "No valid file path provided"
+            logger.error(msg)
+            return OpenAssociatedFileResultFailure()
+
         # Sanitize and validate the file path
         try:
-            path = Path(request.path_to_file).resolve(strict=True)
+            # Resolve the path (no workspace fallback for open requests)
+            path = self._resolve_file_path(file_path_str, workspace_only=False)
         except (ValueError, RuntimeError):
-            details = f"Invalid file path: '{request.path_to_file}'"
+            details = f"Invalid file path: '{file_path_str}'"
             logger.info(details)
             return OpenAssociatedFileResultFailure()
 
@@ -90,12 +253,12 @@ class OSManager:
 
         try:
             platform_name = sys.platform
-            if self.is_windows:
+            if self.is_windows():
                 # Linter complains but this is the recommended way on Windows
                 # We can ignore this warning as we've validated the path
                 os.startfile(str(path))  # noqa: S606 # pyright: ignore[reportAttributeAccessIssue]
                 logger.info("Started file on Windows: %s", path)
-            elif self.is_mac:
+            elif self.is_mac():
                 # On macOS, open should be in a standard location
                 subprocess.run(  # noqa: S603
                     ["/usr/bin/open", str(path)],
@@ -104,7 +267,7 @@ class OSManager:
                     text=True,
                 )
                 logger.info("Started file on macOS: %s", path)
-            elif self.is_linux:
+            elif self.is_linux():
                 # Use full path to xdg-open to satisfy linter
                 # Common locations for xdg-open:
                 xdg_paths = ["/usr/bin/xdg-open", "/bin/xdg-open", "/usr/local/bin/xdg-open"]
@@ -139,6 +302,214 @@ class OSManager:
             logger.error("Exception occurred when trying to open file: %s", type(e).__name__)
             return OpenAssociatedFileResultFailure()
 
+    def on_list_directory_request(self, request: ListDirectoryRequest) -> ResultPayload:  # noqa: C901, PLR0911
+        """Handle a request to list directory contents."""
+        try:
+            # Get the directory path to list
+            if request.directory_path is None:
+                directory = self._get_workspace_path()
+            # Handle paths consistently - always resolve relative paths relative to current directory
+            elif Path(request.directory_path).is_absolute() or request.directory_path.startswith("~"):
+                # Expand tilde and environment variables for absolute paths or paths starting with ~
+                directory = self._expand_path(request.directory_path)
+            else:
+                # Both workspace and system-wide modes resolve relative to current directory
+                directory = (self._get_workspace_path() / request.directory_path).resolve()
+
+            # Check if directory exists
+            if not directory.exists():
+                msg = f"Directory does not exist: {directory}"
+                logger.error(msg)
+                return ListDirectoryResultFailure()
+            if not directory.is_dir():
+                msg = f"Directory is not a directory: {directory}"
+                logger.error(msg)
+                return ListDirectoryResultFailure()
+
+            # Check workspace constraints
+            is_workspace_path, relative_or_abs_path = self._validate_workspace_path(directory)
+            if request.workspace_only and not is_workspace_path:
+                msg = f"Directory is outside workspace: {directory}"
+                logger.error(msg)
+                return ListDirectoryResultFailure()
+
+            entries = []
+            try:
+                # List directory contents
+                for entry in directory.iterdir():
+                    # Skip hidden files if not requested
+                    if not request.show_hidden and entry.name.startswith("."):
+                        continue
+
+                    try:
+                        stat = entry.stat()
+                        # Get path relative to workspace if within workspace
+                        is_entry_in_workspace, entry_path = self._validate_workspace_path(entry)
+                        entries.append(
+                            FileSystemEntry(
+                                name=entry.name,
+                                path=str(entry_path),
+                                is_dir=entry.is_dir(),
+                                size=stat.st_size,
+                                modified_time=stat.st_mtime,
+                            )
+                        )
+                    except (OSError, PermissionError) as e:
+                        msg = f"Could not stat entry {entry}: {e}"
+                        logger.warning(msg)
+                        continue
+
+            except (OSError, PermissionError) as e:
+                msg = f"Error listing directory {directory}: {e}"
+                logger.error(msg)
+                return ListDirectoryResultFailure()
+
+            # Return appropriate path format based on mode
+            if request.workspace_only:
+                # In workspace mode, return relative path if within workspace, absolute if outside
+                return ListDirectoryResultSuccess(
+                    entries=entries, current_path=str(relative_or_abs_path), is_workspace_path=is_workspace_path
+                )
+            # In system-wide mode, always return the full absolute path
+            return ListDirectoryResultSuccess(
+                entries=entries, current_path=str(directory), is_workspace_path=is_workspace_path
+            )
+
+        except Exception as e:
+            msg = f"Unexpected error in list_directory: {type(e).__name__}: {e}"
+            logger.error(msg)
+            return ListDirectoryResultFailure()
+
+    def on_read_file_request(self, request: ReadFileRequest) -> ResultPayload:
+        """Handle a request to read file contents with automatic text/binary detection."""
+        # Initialize variables that might be used in exception handlers
+        file_path: Path | None = None
+        file_path_str: str | None = None
+
+        try:
+            # Validate request and get file path
+            file_path, file_path_str = self._validate_read_file_request(request)
+
+            # Read file content
+            content, encoding, mime_type, compression_encoding, file_size = self._read_file_content(file_path, request)
+
+            return ReadFileResultSuccess(
+                content=content,
+                file_size=file_size,
+                mime_type=mime_type,
+                encoding=encoding,
+                compression_encoding=compression_encoding,
+            )
+
+        except (ValueError, FileNotFoundError) as e:
+            file_info = f" for file: {file_path}" if file_path is not None else ""
+            msg = f"Validation error in read_file{file_info}: {e}"
+            logger.error(msg)
+            return ReadFileResultFailure()
+        except Exception as e:
+            # Try to include file path in error message if available
+            path_info = ""
+            if file_path is not None:
+                path_info = f" for {file_path}"
+            elif file_path_str is not None:
+                path_info = f" for {file_path_str}"
+
+            msg = f"Unexpected error in read_file{path_info}: {type(e).__name__}: {e}"
+            logger.error(msg)
+            return ReadFileResultFailure()
+
+    def _read_file_content(
+        self, file_path: Path, request: ReadFileRequest
+    ) -> tuple[bytes | str, str | None, str, str | None, int]:
+        """Read file content and return content, encoding, mime_type, compression_encoding, and file_size."""
+        # Get file size
+        file_size = file_path.stat().st_size
+
+        # Determine MIME type and compression encoding
+        mime_type, compression_encoding = mimetypes.guess_type(str(file_path), strict=True)
+        if mime_type is None:
+            mime_type = "text/plain"
+
+        # Determine if file is binary
+        try:
+            is_binary_file = is_binary(str(file_path))
+        except Exception as e:
+            msg = f"binaryornot detection failed for {file_path}: {e}"
+            logger.warning(msg)
+            is_binary_file = not mime_type.startswith(
+                ("text/", "application/json", "application/xml", "application/yaml")
+            )
+
+        # Read file content
+        if not is_binary_file:
+            content, encoding = self._read_text_file(file_path, request.encoding)
+        else:
+            content, encoding = self._read_binary_file(file_path, mime_type)
+
+        return content, encoding, mime_type, compression_encoding, file_size
+
+    def _read_text_file(self, file_path: Path, requested_encoding: str) -> tuple[bytes | str, str | None]:
+        """Read file as text with fallback encodings."""
+        try:
+            with file_path.open(encoding=requested_encoding) as f:
+                return f.read(), requested_encoding
+        except UnicodeDecodeError:
+            try:
+                with file_path.open(encoding="utf-8") as f:
+                    return f.read(), "utf-8"
+            except UnicodeDecodeError:
+                with file_path.open("rb") as f:
+                    return f.read(), None
+
+    def _read_binary_file(self, file_path: Path, mime_type: str) -> tuple[bytes | str, None]:
+        """Read file as binary, with special handling for images."""
+        with file_path.open("rb") as f:
+            content = f.read()
+
+        if mime_type.startswith("image/"):
+            content = self._handle_image_content(content, file_path, mime_type)
+
+        return content, None
+
+    def _handle_image_content(self, content: bytes, file_path: Path, mime_type: str) -> str:
+        """Handle image content by creating previews or returning static URLs."""
+        # Store original bytes for preview creation
+        original_image_bytes = content
+
+        # Check if file is already in the static files directory
+        config_manager = GriptapeNodes.ConfigManager()
+        static_files_directory = config_manager.get_config_value("static_files_directory", default="staticfiles")
+        static_dir = config_manager.workspace_path / static_files_directory
+
+        try:
+            # Check if file is within the static files directory
+            file_relative_to_static = file_path.relative_to(static_dir)
+            # File is in static directory, construct URL directly
+            static_url = f"http://localhost:8124/static/{file_relative_to_static}"
+            msg = f"Image already in static directory, returning URL: {static_url}"
+            logger.debug(msg)
+        except ValueError:
+            # File is not in static directory, create small preview
+            from griptape_nodes.utils.image_preview import create_image_preview_from_bytes
+
+            preview_data_url = create_image_preview_from_bytes(
+                original_image_bytes,  # type: ignore[arg-type]
+                max_width=200,
+                max_height=200,
+                quality=85,
+                image_format="WEBP",
+            )
+
+            if preview_data_url:
+                logger.debug("Image preview created (file not moved)")
+                return preview_data_url
+            # Fallback to data URL if preview creation fails
+            data_url = f"data:{mime_type};base64,{base64.b64encode(original_image_bytes).decode('utf-8')}"
+            logger.debug("Fallback to full image data URL")
+            return data_url
+        else:
+            return static_url
+
     @staticmethod
     def get_disk_space_info(path: Path) -> DiskSpaceInfo:
         """Get disk space information for a given path.
@@ -197,4 +568,138 @@ class OSManager:
 
             return error_msg  # noqa: TRY300
         except OSError:
-            return f"Disk space error at {path}. Unable to retrieve disk space information."
+            return f"Could not determine disk space at {path}. Please check disk space manually."
+
+    @staticmethod
+    def cleanup_directory_if_needed(full_directory_path: Path, max_size_gb: float) -> bool:
+        """Check directory size and cleanup old files if needed.
+
+        Args:
+            full_directory_path: Path to the directory to check and clean
+            max_size_gb: Target size in GB
+
+        Returns:
+            True if cleanup was performed, False otherwise
+        """
+        if max_size_gb < 0:
+            logger.warning(
+                "Asked to clean up directory to be below a negative threshold. Overriding to a size of 0 GB."
+            )
+            max_size_gb = 0
+
+        # Calculate current directory size
+        current_size_gb = OSManager._get_directory_size_gb(full_directory_path)
+
+        if current_size_gb <= max_size_gb:
+            return False
+
+        logger.info(
+            "Directory %s size (%.1f GB) exceeds limit (%s GB). Starting cleanup...",
+            full_directory_path,
+            current_size_gb,
+            max_size_gb,
+        )
+
+        # Perform cleanup
+        return OSManager._cleanup_old_files(full_directory_path, max_size_gb)
+
+    @staticmethod
+    def _get_directory_size_gb(path: Path) -> float:
+        """Get total size of directory in GB.
+
+        Args:
+            path: Path to the directory
+
+        Returns:
+            Total size in GB
+        """
+        total_size = 0.0
+
+        if not path.exists():
+            logger.error("Directory %s does not exist. Skipping cleanup.", path)
+            return 0.0
+
+        for _, _, files in os.walk(path):
+            for f in files:
+                fp = path / f
+                if not fp.is_symlink():
+                    total_size += fp.stat().st_size
+        return total_size / (1024 * 1024 * 1024)  # Convert to GB
+
+    @staticmethod
+    def _cleanup_old_files(directory_path: Path, target_size_gb: float) -> bool:
+        """Remove oldest files until directory is under target size.
+
+        Args:
+            directory_path: Path to the directory to clean
+            target_size_gb: Target size in GB
+
+        Returns:
+            True if files were removed, False otherwise
+        """
+        if not directory_path.exists():
+            logger.error("Directory %s does not exist. Skipping cleanup.", directory_path)
+            return False
+
+        # Get all files with their modification times
+        files_with_times: list[tuple[Path, float]] = []
+
+        for file_path in directory_path.rglob("*"):
+            if file_path.is_file():
+                try:
+                    mtime = file_path.stat().st_mtime
+                    files_with_times.append((file_path, mtime))
+                except (OSError, FileNotFoundError) as err:
+                    # Skip files that can't be accessed
+                    logger.error(
+                        "While cleaning up old files, saw file %s. File could not be accessed; skipping. Error: %s",
+                        file_path,
+                        err,
+                    )
+                    continue
+
+        if not files_with_times:
+            logger.error(
+                "Attempted to clean up files to get below a target directory size, but no suitable files were found that could be deleted."
+            )
+            return False
+
+        # Sort by modification time (oldest first)
+        files_with_times.sort(key=lambda x: x[1])
+
+        # Remove files until we're under the target size
+        removed_count = 0
+
+        for file_path, _ in files_with_times:
+            try:
+                # Delete the file.
+                file_path.unlink()
+                removed_count += 1
+
+                # Check if we're now under the target size
+                current_size_gb = OSManager._get_directory_size_gb(directory_path)
+                if current_size_gb <= target_size_gb:
+                    # We're done!
+                    break
+
+            except (OSError, FileNotFoundError) as err:
+                # Skip files that can't be deleted
+                logger.error(
+                    "While cleaning up old files, attempted to delete file %s. File could not be deleted; skipping. Deletion error: %s",
+                    file_path,
+                    err,
+                )
+
+        if removed_count > 0:
+            final_size_gb = OSManager._get_directory_size_gb(directory_path)
+            logger.info(
+                "Cleaned up %d old files from %s. Directory size reduced to %.1f GB",
+                removed_count,
+                directory_path,
+                final_size_gb,
+            )
+        else:
+            # None deleted.
+            logger.error("Attempted to clean up old files from %s, but no files could be deleted.")
+
+        return removed_count > 0

griptape_nodes/retained_mode/managers/version_compatibility_manager.py

@@ -15,7 +15,7 @@ from griptape_nodes.retained_mode.griptape_nodes import GriptapeNodes, Version
 if TYPE_CHECKING:
     from griptape_nodes.node_library.library_registry import LibrarySchema
     from griptape_nodes.retained_mode.managers.event_manager import EventManager
-    from griptape_nodes.retained_mode.managers.library_manager import LibraryManager
+    from griptape_nodes.retained_mode.managers.library_lifecycle.library_status import LibraryStatus
 
 logger = logging.getLogger("griptape_nodes")
 
@@ -24,7 +24,7 @@ class LibraryVersionCompatibilityIssue(NamedTuple):
     """Represents a library version compatibility issue found in a library."""
 
     message: str
-    severity: LibraryManager.LibraryStatus
+    severity: LibraryStatus
 
 
 class LibraryVersionCompatibilityCheck(ABC):