linux-mcp-server 1.2.0__tar.gz → 1.2.1__tar.gz

{linux_mcp_server-1.2.0 → linux_mcp_server-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: linux-mcp-server
-Version: 1.2.0
+Version: 1.2.1
 Summary: MCP server for read-only Linux system administration, diagnostics, and troubleshooting
 Project-URL: Source code, https://github.com/rhel-lightspeed/linux-mcp-server
 Project-URL: Bug Tracker, https://github.com/rhel-lightspeed/linux-mcp-server/issues
@@ -26,7 +26,7 @@ Classifier: Topic :: System :: Systems Administration
 Classifier: Topic :: Utilities
 Requires-Python: >=3.10
 Requires-Dist: asyncssh[bcrypt]>=2.22.0
-Requires-Dist: fastmcp<3,>=2
+Requires-Dist: fastmcp<3,>=2.14.3
 Requires-Dist: pydantic-settings>=2.12.0
 Requires-Dist: pydantic>=2.12.5
 Provides-Extra: gssapi

{linux_mcp_server-1.2.0 → linux_mcp_server-1.2.1}/docs/clients.md

@@ -273,11 +273,9 @@ Edit `~/.gemini/settings.json`:
 
     ```json
     {
-      // your other settings
-      ,
       "mcpServers": {
         "linux-mcp-server": {
-          "command": "/home/$USER/.local/bin/linux-mcp-server",
+          "command": "/home/YOUR_USER/.local/bin/linux-mcp-server",
           "args": [],
           "env": {
             "LINUX_MCP_USER": "your-ssh-username"
@@ -287,6 +285,9 @@ Edit `~/.gemini/settings.json`:
     }
     ```
 
+    !!! note "Merging with Existing Settings"
+        If you have other settings in your `settings.json`, add the `mcpServers` object alongside them.
+
 === "Container (Podman)"
 
     ```json
@@ -500,24 +501,22 @@ Add to your VS Code `mcp.json`:
 
     ```json
     {
-      "mcp": {
-        "servers": {
-          "linux-mcp-server": {
-            "command": "podman",
-            "args": [
-              "run", "--rm", "--interactive",
-              "--userns", "keep-id:uid=1001,gid=0",
-              "-e", "LINUX_MCP_KEY_PASSPHRASE",
-              "-e", "LINUX_MCP_USER",
-              "-v", "/home/YOUR_USER/.ssh/id_ed25519:/var/lib/mcp/.ssh/id_ed25519:ro,Z",
-              "-v", "/home/YOUR_USER/.ssh/config:/var/lib/mcp/.ssh/config:ro,Z",
-              "-v", "/home/YOUR_USER/.local/share/linux-mcp-server/logs:/var/lib/mcp/.local/share/linux-mcp-server/logs:rw,Z",
-              "quay.io/redhat-services-prod/rhel-lightspeed-tenant/linux-mcp-server:latest"
-            ],
-            "env": {
-              "LINUX_MCP_KEY_PASSPHRASE": "<secret>",
-              "LINUX_MCP_USER": "YOUR_USER"
-            }
+      "servers": {
+        "linux-mcp-server": {
+          "command": "podman",
+          "args": [
+            "run", "--rm", "--interactive",
+            "--userns", "keep-id:uid=1001,gid=0",
+            "-e", "LINUX_MCP_KEY_PASSPHRASE",
+            "-e", "LINUX_MCP_USER",
+            "-v", "/home/YOUR_USER/.ssh/id_ed25519:/var/lib/mcp/.ssh/id_ed25519:ro,Z",
+            "-v", "/home/YOUR_USER/.ssh/config:/var/lib/mcp/.ssh/config:ro,Z",
+            "-v", "/home/YOUR_USER/.local/share/linux-mcp-server/logs:/var/lib/mcp/.local/share/linux-mcp-server/logs:rw,Z",
+            "quay.io/redhat-services-prod/rhel-lightspeed-tenant/linux-mcp-server:latest"
+          ],
+          "env": {
+            "LINUX_MCP_KEY_PASSPHRASE": "<secret>",
+            "LINUX_MCP_USER": "YOUR_USER"
           }
         }
       }

{linux_mcp_server-1.2.0 → linux_mcp_server-1.2.1}/pyproject.toml

@@ -12,7 +12,7 @@ readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
     "asyncssh[bcrypt] >= 2.22.0",
-    "fastmcp >=2, <3",
+    "fastmcp >=2.14.3, <3",
     "pydantic-settings >= 2.12.0",
     "pydantic >= 2.12.5",
 ]

{linux_mcp_server-1.2.0 → linux_mcp_server-1.2.1}/src/linux_mcp_server/commands.py

@@ -184,7 +184,7 @@ COMMANDS: Mapping[str, CommandGroup] = MappingProxyType(
         ),
         "list_directories_size": CommandGroup(
             commands={
-                "default": CommandSpec(args=("du", "-b", "--max-depth=1", "{path}")),
+                "default": CommandSpec(args=("du", "-b", "--one-file-system", "--max-depth=1", "{path}")),
             }
         ),
         "list_directories_name": CommandGroup(

{linux_mcp_server-1.2.0 → linux_mcp_server-1.2.1}/src/linux_mcp_server/formatters.py

@@ -5,6 +5,7 @@ human-readable strings for tool output.
 """
 
 from datetime import datetime
+from pathlib import Path
 
 from linux_mcp_server.utils import format_bytes
 from linux_mcp_server.utils.types import CpuInfo
@@ -364,7 +365,7 @@ def format_journal_logs(
     return "\n".join(lines)
 
 
-def format_log_file(stdout: str, log_path: str, lines_count: int) -> str:
+def format_log_file(stdout: str, log_path: Path, lines_count: int) -> str:
     """Format log file output.
 
     Args:
@@ -456,7 +457,7 @@ def format_hardware_info(results: dict[str, str]) -> str:
 
 def format_directory_listing(
     entries: list[NodeEntry],
-    path: str,
+    path: str | Path,
     sort_by: str,
     reverse: bool = False,
 ) -> str:
@@ -496,7 +497,7 @@ def format_directory_listing(
 
 def format_file_listing(
     entries: list[NodeEntry],
-    path: str,
+    path: str | Path,
     sort_by: str,
     reverse: bool = False,
 ) -> str:

{linux_mcp_server-1.2.0 → linux_mcp_server-1.2.1}/src/linux_mcp_server/tools/logs.py

@@ -4,8 +4,10 @@ import typing as t
 
 from pathlib import Path
 
+from fastmcp.exceptions import ToolError
 from mcp.types import ToolAnnotations
 from pydantic import Field
+from pydantic.functional_validators import BeforeValidator
 
 from linux_mcp_server.audit import log_tool_call
 from linux_mcp_server.commands import get_command
@@ -17,7 +19,6 @@ from linux_mcp_server.utils import StrEnum
 from linux_mcp_server.utils.decorators import disallow_local_execution_in_containers
 from linux_mcp_server.utils.types import Host
 from linux_mcp_server.utils.validation import is_empty_output
-from linux_mcp_server.utils.validation import PathValidationError
 from linux_mcp_server.utils.validation import validate_path
 
 
@@ -87,14 +88,26 @@ async def _get_journal_logs(
 @log_tool_call
 @disallow_local_execution_in_containers
 async def get_journal_logs(
-    unit: t.Annotated[str | None, "Filter by systemd unit name or pattern (e.g., 'nginx.service', 'ssh*')"] = None,
+    unit: t.Annotated[
+        str | None,
+        Field(
+            description="Filter by systemd unit name or pattern",
+            examples=["sshd.service", "nginx", "httpd", "systemd-*", "audit*"],
+        ),
+    ] = None,
     priority: t.Annotated[
         str | None,
-        "Filter by priority. Possible values: priority level (0-7), syslog level name ('emerg' to 'debug'), or range (e.g., 'err..info')",
+        Field(
+            description="Filter by syslog priority level (0-7), name, or range",
+            examples=["err", "warning", "info", "debug", "3", "err..warning"],
+        ),
     ] = None,
     since: t.Annotated[
         str | None,
-        "Filter entries since specified time. Date/time filter (format: 'YYYY-MM-DD HH:MM:SS', 'today', 'yesterday', 'now', or relative like '-1h')",
+        Field(
+            description="Filter entries since specified time (absolute or relative)",
+            examples=["today", "yesterday", "-1h", "-30m", "-7d", "2025-01-15 10:00:00"],
+        ),
     ] = None,
     transport: t.Annotated[
         Transport | None,
@@ -131,8 +144,15 @@ async def get_journal_logs(
 )
 @log_tool_call
 @disallow_local_execution_in_containers
-async def read_log_file(  # noqa: C901
-    log_path: t.Annotated[str, "Path to the log file"],
+async def read_log_file(
+    log_path: t.Annotated[
+        Path,
+        BeforeValidator(validate_path),
+        Field(
+            description="Absolute path to the log file (must be in allowed list)",
+            examples=["/var/log/messages", "/var/log/secure", "/var/log/audit/audit.log", "/var/log/dnf.log"],
+        ),
+    ],
     lines: t.Annotated[int, Field(description="Number of lines to retrieve from the end.", ge=1, le=10_000)] = 100,
     host: Host = None,
 ) -> str:
@@ -145,22 +165,16 @@ async def read_log_file(  # noqa: C901
     allowed_paths_env = CONFIG.allowed_log_paths
 
     if not allowed_paths_env:
-        return (
+        raise ToolError(
             "No log files are allowed. Set LINUX_MCP_ALLOWED_LOG_PATHS environment variable "
             "with comma-separated list of allowed log file paths."
         )
 
-    allowed_paths = [p.strip() for p in allowed_paths_env.split(",") if p.strip()]
-
-    # Validate path for injection attacks (applies to both local and remote)
-    try:
-        validated_path = validate_path(log_path)
-    except PathValidationError as e:
-        return f"Invalid log file path: {e}"
+    allowed_paths = [Path(p.strip()) for p in allowed_paths_env.split(",") if p.strip()]
 
     if not host:
         # For local execution, resolve and check against allowlist
-        requested_path = Path(validated_path).resolve()
+        requested_path = log_path.resolve()
 
         is_allowed = False
         for allowed_path in allowed_paths:
@@ -170,36 +184,32 @@ async def read_log_file(  # noqa: C901
                 break
 
         if not is_allowed:
-            return (
-                f"Access to log file '{log_path}' is not allowed.\n"
-                f"Allowed log files: {', '.join(allowed_paths)}"
-            )  # nofmt
+            raise ToolError(f"Access to log file '{log_path}' is not allowed.")
 
         if not requested_path.exists():
-            return f"Log file not found: {log_path}"
+            raise ToolError(f"Log file not found: {log_path}")
 
         if not requested_path.is_file():
-            return f"Path is not a file: {log_path}"
+            raise ToolError(f"Path is not a file: {log_path}")
 
         log_path_str = str(requested_path)
     else:
         # For remote execution, check against allowlist without resolving
-        if validated_path not in allowed_paths:
-            return (
-                f"Access to log file '{log_path}' is not allowed.\n"
-                f"Allowed log files: {', '.join(allowed_paths)}"
-            )  # nofmt
-        log_path_str = validated_path
+        if log_path not in allowed_paths:
+            raise ToolError(f"Access to log file '{log_path}' is not allowed.")
+
+        log_path_str = str(log_path)
 
     cmd = get_command("read_log_file")
     returncode, stdout, stderr = await cmd.run(host=host, lines=lines, log_path=log_path_str)
 
     if returncode != 0:
         if "Permission denied" in stderr:
-            return f"Permission denied reading log file: {log_path}"
-        return f"Error reading log file: {stderr}"
+            raise ToolError(f"Permission denied reading log file: {log_path}")
+
+        raise ToolError(f"Error reading log file: {stderr}")
 
     if is_empty_output(stdout):
-        return f"Log file is empty: {log_path}"
+        raise ToolError(f"Log file is empty: {log_path}")
 
     return format_log_file(stdout, log_path, lines)

{linux_mcp_server-1.2.0 → linux_mcp_server-1.2.1}/src/linux_mcp_server/tools/processes.py

@@ -51,7 +51,10 @@ async def list_processes(
 @log_tool_call
 @disallow_local_execution_in_containers
 async def get_process_info(
-    pid: t.Annotated[int, Field(description="Process ID", ge=1)],
+    pid: t.Annotated[
+        int,
+        Field(description="Process ID", ge=1, examples=[1, 1234, 65535]),
+    ],
     host: Host = None,
 ) -> str:
     """Get detailed information about a specific process.

{linux_mcp_server-1.2.0 → linux_mcp_server-1.2.1}/src/linux_mcp_server/tools/services.py

@@ -59,7 +59,13 @@ async def list_services(
 @log_tool_call
 @disallow_local_execution_in_containers
 async def get_service_status(
-    service_name: t.Annotated[str, "Name of the service"],
+    service_name: t.Annotated[
+        str,
+        Field(
+            description="Name of the systemd service",
+            examples=["sshd", "NetworkManager", "auditd", "rsyslog", "crond", "firewalld"],
+        ),
+    ],
     host: Host = None,
 ) -> str:
     """Get status of a specific systemd service.
@@ -93,7 +99,13 @@ async def get_service_status(
 @log_tool_call
 @disallow_local_execution_in_containers
 async def get_service_logs(
-    service_name: t.Annotated[str, "Name of the service"],
+    service_name: t.Annotated[
+        str,
+        Field(
+            description="Name of the systemd service",
+            examples=["sshd", "NetworkManager", "auditd", "rsyslog", "crond", "firewalld"],
+        ),
+    ],
     lines: t.Annotated[int, Field(description="Number of log lines to retrieve.", ge=1, le=10_000)] = 50,
     host: Host = None,
 ) -> str:

{linux_mcp_server-1.2.0 → linux_mcp_server-1.2.1}/src/linux_mcp_server/tools/storage.py

@@ -3,9 +3,12 @@
 import os
 import typing as t
 
+from pathlib import Path
+
 from fastmcp.exceptions import ToolError
 from mcp.types import ToolAnnotations
 from pydantic import Field
+from pydantic.functional_validators import BeforeValidator
 
 from linux_mcp_server.audit import log_tool_call
 from linux_mcp_server.commands import get_command
@@ -19,7 +22,6 @@ from linux_mcp_server.utils import StrEnum
 from linux_mcp_server.utils.decorators import disallow_local_execution_in_containers
 from linux_mcp_server.utils.types import Host
 from linux_mcp_server.utils.validation import is_successful_output
-from linux_mcp_server.utils.validation import PathValidationError
 from linux_mcp_server.utils.validation import validate_path
 
 
@@ -47,14 +49,6 @@ FILE_COMMANDS: dict[OrderBy, str] = {
 }
 
 
-def _validate_path(path: str) -> str:
-    """Validate path, converting PathValidationError to ToolError for MCP compatibility."""
-    try:
-        return validate_path(path)
-    except PathValidationError as e:
-        raise ToolError(str(e)) from e
-
-
 @mcp.tool(
     title="List block devices",
     description="List block devices on the system",
@@ -89,7 +83,14 @@ async def list_block_devices(
 @log_tool_call
 @disallow_local_execution_in_containers
 async def list_directories(
-    path: t.Annotated[str, "The directory path to analyze"],
+    path: t.Annotated[
+        Path,
+        BeforeValidator(validate_path),
+        Field(
+            description="Absolute path to the directory to analyze",
+            examples=["/var/log", "/etc", "/home", "/opt", "/tmp"],
+        ),
+    ],
     order_by: t.Annotated[OrderBy, "Sort order - 'size', 'name', or 'modified' (default: 'name')"] = OrderBy.NAME,
     sort: t.Annotated[SortBy, "Sort direction - 'ascending' or 'descending' (default: 'ascending')"] = SortBy.ASCENDING,
     top_n: t.Annotated[
@@ -107,15 +108,15 @@ async def list_directories(
     Retrieves subdirectories with their size (when ordered by size) or
     modification time, supporting flexible sorting and result limiting.
     """
-    path = _validate_path(path)
-
     # Get the appropriate command for the order_by field
     cmd_name = DIRECTORY_COMMANDS[order_by]
     cmd = get_command(cmd_name)
 
     returncode, stdout, stderr = await cmd.run(host=host, path=path)
 
-    if returncode != 0:
+    # The du command will exit with code 1 even if it gets some valid results.
+    # Only error in the case where we got non-zero exit code and no data in stdout.
+    if returncode != 0 and not stdout:
         raise ToolError(f"Error running command: command failed with return code {returncode}: {stderr}")
 
     # Parse the output
@@ -145,7 +146,14 @@ async def list_directories(
 @log_tool_call
 @disallow_local_execution_in_containers
 async def list_files(
-    path: t.Annotated[str, "The path to analyze"],
+    path: t.Annotated[
+        Path,
+        BeforeValidator(validate_path),
+        Field(
+            description="Absolute path to the directory to analyze",
+            examples=["/var/log", "/etc", "/home", "/opt", "/tmp"],
+        ),
+    ],
     order_by: t.Annotated[OrderBy, "Sort order - 'size', 'name', or 'modified' (default: 'name')"] = OrderBy.NAME,
     sort: t.Annotated[SortBy, "Sort direction - 'ascending' or 'descending' (default: 'ascending')"] = SortBy.ASCENDING,
     top_n: t.Annotated[
@@ -163,10 +171,6 @@ async def list_files(
     Retrieves files with their size or modification time, supporting flexible
     sorting and result limiting. Useful for finding large or recently modified files.
     """
-    # For local execution, validate path
-    if not host:
-        path = _validate_path(path)
-
     # Get the appropriate command for the order_by field
     cmd_name = FILE_COMMANDS[order_by]
     cmd = get_command(cmd_name)
@@ -203,7 +207,14 @@ async def list_files(
 @log_tool_call
 @disallow_local_execution_in_containers
 async def read_file(
-    path: t.Annotated[str, "The file path to read"],
+    path: t.Annotated[
+        Path,
+        BeforeValidator(validate_path),
+        Field(
+            description="Absolute path to the file to read",
+            examples=["/etc/hosts", "/etc/resolv.conf", "/etc/os-release", "/proc/cpuinfo"],
+        ),
+    ],
     host: Host = None,
 ) -> str:
     """Read the contents of a file.
@@ -211,10 +222,6 @@ async def read_file(
     Retrieves the full contents of a text file. The path must be absolute
     and the file must exist. Binary files may not display correctly.
     """
-
-    # Validate path
-    path = _validate_path(path)
-
     if not host:
         # For local execution, check early if file exists
         if not os.path.isfile(path):

{linux_mcp_server-1.2.0 → linux_mcp_server-1.2.1}/src/linux_mcp_server/utils/validation.py

@@ -11,7 +11,7 @@ class PathValidationError(ValueError):
     pass
 
 
-def validate_path(path: str) -> str:
+def validate_path(path: str) -> Path:
     """Validate a filesystem path for security and correctness.
 
     Performs security checks to prevent command injection and path traversal attacks:
@@ -53,7 +53,7 @@ def validate_path(path: str) -> str:
     if not Path(path).is_absolute():
         raise PathValidationError(f"Path must be absolute: {path}")
 
-    return Path(path).as_posix()
+    return Path(path)
 
 
 def is_empty_output(stdout: str | None) -> bool:

{linux_mcp_server-1.2.0 → linux_mcp_server-1.2.1}/tests/test_formatters.py

@@ -1,5 +1,7 @@
 """Tests for formatters module."""
 
+from pathlib import Path
+
 from linux_mcp_server.formatters import format_block_devices
 from linux_mcp_server.formatters import format_cpu_info
 from linux_mcp_server.formatters import format_directory_listing
@@ -416,7 +418,7 @@ class TestFormatLogFile:
     def test_format_log_file(self):
         """Test formatting log file."""
         stdout = "2024-01-01 10:00:00 INFO Application started"
-        result = format_log_file(stdout, "/var/log/app.log", 100)
+        result = format_log_file(stdout, Path("/var/log/app.log"), 100)
         assert "=== Log File: /var/log/app.log (last 100 lines) ===" in result
         assert "Application started" in result
 

linux_mcp_server-1.2.1/tests/test_tool_schemas.py

@@ -0,0 +1,50 @@
+"""Verify tool schemas contain expected metadata for LLM guidance."""
+
+import pytest
+
+from linux_mcp_server.server import mcp
+
+
+@pytest.fixture(scope="module")
+async def mcp_tools() -> dict:
+    """Fetch all MCP tools using the public API."""
+    return await mcp.get_tools()
+
+
+@pytest.fixture
+def tool_properties(mcp_tools: dict):
+    """Get the properties dict for a tool's parameters schema."""
+
+    def _tool_properties(tool_name: str) -> dict:
+        tool = mcp_tools.get(tool_name)
+        if tool is None:
+            raise ValueError(f"Tool '{tool_name}' not found")  # pragma: no cover
+        return tool.parameters.get("properties", {})
+
+    return _tool_properties
+
+
+class TestToolSchemaExamples:
+    """Verify parameters have examples for LLM guidance."""
+
+    @pytest.mark.parametrize(
+        ("tool_name", "param_name"),
+        [
+            ("get_journal_logs", "unit"),
+            ("get_journal_logs", "priority"),
+            ("get_journal_logs", "since"),
+            ("read_log_file", "log_path"),
+            ("get_service_status", "service_name"),
+            ("get_service_logs", "service_name"),
+            ("get_process_info", "pid"),
+            ("list_directories", "path"),
+            ("list_files", "path"),
+            ("read_file", "path"),
+        ],
+    )
+    def test_parameter_has_examples(self, tool_name: str, param_name: str, tool_properties) -> None:
+        props = tool_properties(tool_name)
+
+        assert param_name in props, f"Parameter '{param_name}' not found in {tool_name}"
+        assert "examples" in props[param_name], f"Parameter '{param_name}' in {tool_name} missing examples"
+        assert len(props[param_name]["examples"]) > 0, f"Parameter '{param_name}' in {tool_name} has empty examples"

{linux_mcp_server-1.2.0 → linux_mcp_server-1.2.1}/tests/tools/test_logs.py

@@ -198,7 +198,7 @@ class TestReadLogFile:
         log_file = setup_log_file()
         mock_execute_with_fallback.return_value = (0, "Test log content\nLine 2", "")
 
-        params = {"log_path": str(log_file)}
+        params = {"log_path": log_file}
         if lines != 100:
             params["lines"] = lines
 
@@ -217,23 +217,19 @@ class TestReadLogFile:
         """Test read_log_file when no allowed paths are configured."""
         mock_allowed_log_paths("")
 
-        result = await mcp_client.call_tool("read_log_file", {"log_path": "/var/log/test.log"})
-        result_text = result.content[0].text.casefold()
-
-        assert "no log files are allowed" in result_text
-        assert "linux_mcp_allowed_log_paths" in result_text
+        with pytest.raises(ToolError, match="No log files are allowed"):
+            await mcp_client.call_tool("read_log_file", {"log_path": "/var/log/test.log"})
 
     @pytest.mark.parametrize(
-        "test_scenario,path_resolver,expected_error",
+        "test_scenario,log_path,match",
         [
-            # Invalid path
-            ("invalid_path", lambda tp: "\x00invalid", "invalid log file path"),
-            # Path not in allowed list
-            ("not_allowed", lambda tp: str(tp / "restricted.log"), "not allowed"),
+            ("invalid_path", "\x00invalid", "Path contains invalid characters"),
+            ("not_allowed", "restricted.log", "not allowed"),
         ],
+        ids=["invalid-path", "path-not-in-list"],
     )
     async def test_read_log_file_path_validation(
-        self, mcp_client, mock_allowed_log_paths, tmp_path, test_scenario, path_resolver, expected_error
+        self, mcp_client, mock_allowed_log_paths, tmp_path, test_scenario, log_path, match
     ):
         """Test read_log_file path validation scenarios."""
         # Setup allowed path
@@ -241,26 +237,20 @@ class TestReadLogFile:
         allowed_file.write_text("allowed")
         mock_allowed_log_paths(str(allowed_file))
 
-        # Create restricted file for not_allowed scenario
-        if test_scenario == "not_allowed":
-            restricted_file = tmp_path / "restricted.log"
-            restricted_file.write_text("restricted")
-
-        test_path = path_resolver(tmp_path)
-        result = await mcp_client.call_tool("read_log_file", {"log_path": test_path})
-        result_text = result.content[0].text.casefold()
+        restricted_file = tmp_path / "restricted.log"
+        restricted_file.write_text("restricted")
 
-        assert expected_error in result_text
+        test_path = tmp_path / log_path
+        with pytest.raises(ToolError, match=match):
+            await mcp_client.call_tool("read_log_file", {"log_path": test_path})
 
     async def test_read_log_file_nonexistent_but_allowed(self, mcp_client, mock_allowed_log_paths, tmp_path):
         """Test read_log_file when path is allowed but file doesn't exist."""
         nonexistent_file = tmp_path / "nonexistent.log"
         mock_allowed_log_paths(str(nonexistent_file))
 
-        result = await mcp_client.call_tool("read_log_file", {"log_path": str(nonexistent_file)})
-        result_text = result.content[0].text.casefold()
-
-        assert "log file not found" in result_text
+        with pytest.raises(ToolError, match="Log file not found"):
+            await mcp_client.call_tool("read_log_file", {"log_path": nonexistent_file})
 
     async def test_read_log_file_path_is_directory(self, mcp_client, mock_allowed_log_paths, tmp_path):
         """Test read_log_file when path is a directory, not a file."""
@@ -268,41 +258,35 @@ class TestReadLogFile:
         log_dir.mkdir()
         mock_allowed_log_paths(str(log_dir))
 
-        result = await mcp_client.call_tool("read_log_file", {"log_path": str(log_dir)})
-        result_text = result.content[0].text.casefold()
-
-        assert "path is not a file" in result_text
+        with pytest.raises(ToolError, match="Path is not a file"):
+            await mcp_client.call_tool("read_log_file", {"log_path": log_dir})
 
     @pytest.mark.parametrize(
-        "returncode,stderr,expected_error",
+        "returncode,stderr,match",
         [
             # Permission denied
-            (1, "tail: cannot open: Permission denied", "permission denied"),
+            (1, "tail: cannot open: Permission denied", "Permission denied"),
             # general error
-            (1, "tail: error reading file", "error reading log file"),
+            (1, "tail: error reading file", "Error reading log file"),
         ],
     )
     async def test_read_log_file_command_errors(
-        self, mcp_client, mock_execute_with_fallback, setup_log_file, returncode, stderr, expected_error
+        self, mcp_client, mock_execute_with_fallback, setup_log_file, returncode, stderr, match
     ):
         """Test read_log_file command error handling."""
         log_file = setup_log_file()
         mock_execute_with_fallback.return_value = (returncode, "", stderr)
 
-        result = await mcp_client.call_tool("read_log_file", {"log_path": str(log_file)})
-        result_text = result.content[0].text.casefold()
-
-        assert expected_error in result_text
+        with pytest.raises(ToolError, match=match):
+            await mcp_client.call_tool("read_log_file", {"log_path": log_file})
 
     async def test_read_log_file_empty(self, mcp_client, mock_execute_with_fallback, setup_log_file):
         """Test read_log_file with empty log file."""
         log_file = setup_log_file(content="")
         mock_execute_with_fallback.return_value = (0, "", "")
 
-        result = await mcp_client.call_tool("read_log_file", {"log_path": str(log_file)})
-        result_text = result.content[0].text.casefold()
-
-        assert "log file is empty" in result_text
+        with pytest.raises(ToolError, match="Log file is empty"):
+            await mcp_client.call_tool("read_log_file", {"log_path": log_file})
 
     async def test_read_log_file_tail_not_found(self, mcp_client, mock_execute_with_fallback, setup_log_file):
         """Test read_log_file when tail command is not available."""
@@ -310,7 +294,7 @@ class TestReadLogFile:
         mock_execute_with_fallback.side_effect = FileNotFoundError("tail not found")
 
         with pytest.raises(ToolError, match="tail not found"):
-            await mcp_client.call_tool("read_log_file", {"log_path": str(log_file)})
+            await mcp_client.call_tool("read_log_file", {"log_path": log_file})
 
     async def test_read_log_file_multiple_allowed_paths(
         self, mcp_client, mock_execute_with_fallback, mock_allowed_log_paths, tmp_path
@@ -325,7 +309,7 @@ class TestReadLogFile:
         mock_allowed_log_paths(f"{log_file1},{log_file2}")
         mock_execute_with_fallback.return_value = (0, "content2", "")
 
-        result = await mcp_client.call_tool("read_log_file", {"log_path": str(log_file2)})
+        result = await mcp_client.call_tool("read_log_file", {"log_path": log_file2})
         result_text = result.content[0].text.casefold()
 
         assert "content2" in result_text
@@ -368,9 +352,5 @@ class TestReadLogFile:
 
         mock_allowed_log_paths(str(allowed_path))
 
-        result = await mcp_client.call_tool(
-            "read_log_file", {"log_path": str(restricted_path), "host": "remote.server.com"}
-        )
-        result_text = result.content[0].text.casefold()
-
-        assert "not allowed" in result_text
+        with pytest.raises(ToolError, match="not allowed"):
+            await mcp_client.call_tool("read_log_file", {"log_path": restricted_path, "host": "remote.server.com"})

{linux_mcp_server-1.2.0 → linux_mcp_server-1.2.1}/tests/tools/test_storage.py

@@ -282,11 +282,9 @@ class TestListDirectories:
         """Test list_directories with nonexistent path raises ToolError."""
         nonexistent = tmp_path / "nonexistent"
 
-        with pytest.raises(ToolError) as exc_info:
+        with pytest.raises(ToolError, match="Error running command: command failed with return code 1"):
             await mcp_client.call_tool("list_directories", arguments={"path": str(nonexistent)})
 
-        assert "Error running command: command failed with return code 1" in str(exc_info.value)
-
     async def test_list_directories_restricted_path(self, restricted_path, mcp_client):
         """Test list_directories with restricted path raises ToolError."""
         with pytest.raises(ToolError) as exc_info:

{linux_mcp_server-1.2.0 → linux_mcp_server-1.2.1}/tests/utils/test_validation.py

@@ -1,5 +1,7 @@
 """Tests for input validation utilities."""
 
+from pathlib import Path
+
 import pytest
 
 from linux_mcp_server.utils.validation import is_empty_output
@@ -77,11 +79,11 @@ class TestValidatePath:
     @pytest.mark.parametrize(
         "path,expected",
         [
-            ("/var/log/messages", "/var/log/messages"),
-            ("/home/user/file.txt", "/home/user/file.txt"),
-            ("/", "/"),
-            ("/tmp", "/tmp"),
-            ("/path/with spaces/file.txt", "/path/with spaces/file.txt"),
+            ("/var/log/messages", Path("/var/log/messages")),
+            ("/home/user/file.txt", Path("/home/user/file.txt")),
+            ("/", Path("/")),
+            ("/tmp", Path("/tmp")),
+            ("/path/with spaces/file.txt", Path("/path/with spaces/file.txt")),
         ],
     )
     def test_valid_absolute_paths(self, path, expected):

{linux_mcp_server-1.2.0 → linux_mcp_server-1.2.1}/uv.lock

@@ -711,7 +711,7 @@ lua = [
 
 [[package]]
 name = "fastmcp"
-version = "2.14.1"
+version = "2.14.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "authlib" },
@@ -731,9 +731,9 @@ dependencies = [
     { name = "uvicorn" },
     { name = "websockets" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/9e/50/d38e4371bdc34e709f4731b1e882cb7bc50e51c1a224859d4cd381b3a79b/fastmcp-2.14.1.tar.gz", hash = "sha256:132725cbf77b68fa3c3d165eff0cfa47e40c1479457419e6a2cfda65bd84c8d6", size = 8263331, upload-time = "2025-12-15T02:26:27.102Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/b5/7c4744dc41390ed2c17fd462ef2d42f4448a1ec53dda8fe3a01ff2872313/fastmcp-2.14.3.tar.gz", hash = "sha256:abc9113d5fcf79dfb4c060a1e1c55fccb0d4bce4a2e3eab15ca352341eec8dd6", size = 8279206, upload-time = "2026-01-12T20:00:40.789Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1d/82/72401d09dc27c27fdf72ad6c2fe331e553e3c3646e01b5ff16473191033d/fastmcp-2.14.1-py3-none-any.whl", hash = "sha256:fb3e365cc1d52573ab89caeba9944dd4b056149097be169bce428e011f0a57e5", size = 412176, upload-time = "2025-12-15T02:26:25.356Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/dc/f7dd14213bf511690dccaa5094d436947c253b418c86c86211d1c76e6e44/fastmcp-2.14.3-py3-none-any.whl", hash = "sha256:103c6b4c6e97a9acc251c81d303f110fe4f2bdba31353df515d66272bf1b9414", size = 416220, upload-time = "2026-01-12T20:00:42.543Z" },
 ]
 
 [[package]]
@@ -1121,7 +1121,7 @@ test = [
 [package.metadata]
 requires-dist = [
     { name = "asyncssh", extras = ["bcrypt"], specifier = ">=2.22.0" },
-    { name = "fastmcp", specifier = ">=2,<3" },
+    { name = "fastmcp", specifier = ">=2.14.3,<3" },
     { name = "gssapi", marker = "extra == 'gssapi'", specifier = ">=1.2.0" },
     { name = "pydantic", specifier = ">=2.12.5" },
     { name = "pydantic-settings", specifier = ">=2.12.0" },
@@ -1938,7 +1938,7 @@ wheels = [
 
 [[package]]
 name = "pydocket"
-version = "0.15.6"
+version = "0.16.6"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cloudpickle" },
@@ -1955,9 +1955,9 @@ dependencies = [
     { name = "typer" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c4/24/bf749309644aa7254261410fd50ad885d90d36b29c89bebf5cbc4ad53183/pydocket-0.15.6.tar.gz", hash = "sha256:3cf7030941f175f073cf05fc6fdf0ceede0af640f786de7dd22556d08025799f", size = 277896, upload-time = "2025-12-16T19:48:29.93Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/00/26befe5f58df7cd1aeda4a8d10bc7d1908ffd86b80fd995e57a2a7b3f7bd/pydocket-0.16.6.tar.gz", hash = "sha256:b96c96ad7692827214ed4ff25fcf941ec38371314db5dcc1ae792b3e9d3a0294", size = 299054, upload-time = "2026-01-09T22:09:15.405Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/7c/13/6a3d6222bde9029304f91e2289d0994d8bdac6a14ae7a50bd967c03a8332/pydocket-0.15.6-py3-none-any.whl", hash = "sha256:3192dfdb9ad772cc1481dc39194f474863f073266399795584dc7262e7510f94", size = 58814, upload-time = "2025-12-16T19:48:27.878Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/3f/7483e5a6dc6326b6e0c640619b5c5bd1d6e3c20e54d58f5fb86267cef00e/pydocket-0.16.6-py3-none-any.whl", hash = "sha256:683d21e2e846aa5106274e7d59210331b242d7fb0dce5b08d3b82065663ed183", size = 67697, upload-time = "2026-01-09T22:09:13.436Z" },
 ]
 
 [[package]]