pythonanywhere-mcp-server 0.0.12__tar.gz → 0.0.14__tar.gz

{pythonanywhere_mcp_server-0.0.12/src/pythonanywhere_mcp_server.egg-info → pythonanywhere_mcp_server-0.0.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonanywhere-mcp-server
-Version: 0.0.12
+Version: 0.0.14
 Summary: PythonAnywhere Model Context Protocol Server
 Author-email: PythonAnywhere Developers <developers@pythonanywhere.com>
 License-Expression: MIT
@@ -18,8 +18,8 @@ Classifier: Topic :: Utilities
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: pythonanywhere-core>=0.3.0
-Requires-Dist: mcp[cli]<2.0.0
+Requires-Dist: pythonanywhere-core>=0.3.3
+Requires-Dist: mcp[cli]<3,>=2.2.0
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-mock; extra == "test"

{pythonanywhere_mcp_server-0.0.12 → pythonanywhere_mcp_server-0.0.14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pythonanywhere-mcp-server"
-version = "0.0.12"
+version = "0.0.14"
 description = "PythonAnywhere Model Context Protocol Server"
 authors = [
     {name = "PythonAnywhere Developers", email = "developers@pythonanywhere.com"}
@@ -12,8 +12,8 @@ authors = [
 readme = "README.md"
 requires-python = ">=3.13"
 dependencies = [
-    "pythonanywhere-core>=0.3.0",
-    "mcp[cli]<2.0.0",
+    "pythonanywhere-core>=0.3.3",
+    "mcp[cli]>=2.2.0,<3",
 ]
 classifiers = [
     "Development Status :: 2 - Pre-Alpha",

pythonanywhere_mcp_server-0.0.14/src/pythonanywhere_mcp_server/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.0.14"

{pythonanywhere_mcp_server-0.0.12 → pythonanywhere_mcp_server-0.0.14}/src/pythonanywhere_mcp_server/server.py

@@ -1,6 +1,6 @@
 import os
 
-from mcp.server.fastmcp import FastMCP
+from mcp.server import MCPServer
 from . import __version__
 from .tools.file import register_file_tools
 from .tools.webapp import register_webapp_tools
@@ -17,7 +17,7 @@ def create_server():
     if not API_TOKEN:
         raise RuntimeError("API_TOKEN environment variable must be set.")
 
-    mcp = FastMCP("PythonAnywhere Model Context Protocol Server")
+    mcp = MCPServer("PythonAnywhere Model Context Protocol Server")
 
     register_file_tools(mcp)
     register_website_tools(mcp)

{pythonanywhere_mcp_server-0.0.12 → pythonanywhere_mcp_server-0.0.14}/src/pythonanywhere_mcp_server/tools/file.py

@@ -1,16 +1,20 @@
-from mcp.server.fastmcp import FastMCP
+import json
+
+from mcp.server import MCPServer
+from mcp.server.mcpserver.exceptions import ToolError
 
 from pythonanywhere_core.files import Files
 
 
-def register_file_tools(mcp: FastMCP) -> None:
+def register_file_tools(mcp: MCPServer) -> None:
     @mcp.tool()
     def read_file_or_directory(path: str) -> str:
         """
         Return the contents of a file or a directory listing.
 
         If the given path is a file, returns its contents as a string.
-        If the path is a directory, returns a JSON string with its listing (recursively, up to 1000 entries).
+        If the path is a directory, returns a JSON string listing its immediate
+        children, without recursively listing subdirectory contents.
 
         Args:
             path (str): The absolute path to the file or directory.
@@ -22,9 +26,9 @@ def register_file_tools(mcp: FastMCP) -> None:
             data = Files().path_get(path)
             if isinstance(data, (bytes, bytearray)):
                 return data.decode()
-            return str(data)
+            return json.dumps(data)
         except Exception as exc:
-            raise RuntimeError(f"Failed to read file or directory: {str(exc)}") from exc
+            raise ToolError(f"Failed to read file or directory: {str(exc)}") from exc
 
     @mcp.tool()
     def upload_text_file(dest_path: str, content: str) -> str:
@@ -42,7 +46,7 @@ def register_file_tools(mcp: FastMCP) -> None:
             status = Files().path_post(dest_path, content.encode())
             return f"Uploaded to {dest_path} (HTTP {status})."
         except Exception as exc:
-            raise RuntimeError(f"Failed to upload text file: {str(exc)}") from exc
+            raise ToolError(f"Failed to upload text file: {str(exc)}") from exc
 
     @mcp.tool()
     def upload_directory(local_dir_path: str, remote_dir_path: str) -> str:
@@ -63,7 +67,7 @@ def register_file_tools(mcp: FastMCP) -> None:
             Files().tree_post(local_dir_path, remote_dir_path)
             return f"Uploaded {local_dir_path} to {remote_dir_path}."
         except Exception as exc:
-            raise RuntimeError(f"Failed to upload directory: {str(exc)}") from exc
+            raise ToolError(f"Failed to upload directory: {str(exc)}") from exc
 
     @mcp.tool()
     def delete_path(path: str) -> str:
@@ -80,7 +84,7 @@ def register_file_tools(mcp: FastMCP) -> None:
             Files().path_delete(path)
             return f"Deleted {path}."
         except Exception as exc:
-            raise RuntimeError(f"Failed to delete path: {str(exc)}") from exc
+            raise ToolError(f"Failed to delete path: {str(exc)}") from exc
 
     @mcp.tool()
     def tree(path: str) -> list[str]:
@@ -98,4 +102,4 @@ def register_file_tools(mcp: FastMCP) -> None:
             listing = Files().tree_get(path)
             return listing
         except Exception as exc:
-            raise RuntimeError(f"Failed to get directory tree: {str(exc)}") from exc
+            raise ToolError(f"Failed to get directory tree: {str(exc)}") from exc

{pythonanywhere_mcp_server-0.0.12 → pythonanywhere_mcp_server-0.0.14}/src/pythonanywhere_mcp_server/tools/schedule.py

@@ -1,9 +1,10 @@
-from mcp.server.fastmcp import FastMCP
+from mcp.server import MCPServer
+from mcp.server.mcpserver.exceptions import ToolError
 
 from pythonanywhere_core.schedule import Schedule
 
 
-def register_schedule_tools(mcp: FastMCP) -> None:
+def register_schedule_tools(mcp: MCPServer) -> None:
     @mcp.tool()
     def list_scheduled_tasks() -> list[dict]:
         """
@@ -17,7 +18,7 @@ def register_schedule_tools(mcp: FastMCP) -> None:
         try:
             return Schedule().get_list()
         except Exception as exc:
-            raise RuntimeError(f"Failed to list scheduled tasks: {str(exc)}") from exc
+            raise ToolError(f"Failed to list scheduled tasks: {str(exc)}") from exc
 
     @mcp.tool()
     def create_scheduled_task(params: dict) -> dict:
@@ -38,7 +39,7 @@ def register_schedule_tools(mcp: FastMCP) -> None:
         try:
             return Schedule().create(params)
         except Exception as exc:
-            raise RuntimeError(f"Failed to create scheduled task: {str(exc)}") from exc
+            raise ToolError(f"Failed to create scheduled task: {str(exc)}") from exc
 
     @mcp.tool()
     def delete_scheduled_task(task_id: int) -> bool:
@@ -54,7 +55,7 @@ def register_schedule_tools(mcp: FastMCP) -> None:
         try:
             return Schedule().delete(task_id)
         except Exception as exc:
-            raise RuntimeError(f"Failed to delete scheduled task: {str(exc)}") from exc
+            raise ToolError(f"Failed to delete scheduled task: {str(exc)}") from exc
 
     @mcp.tool()
     def get_scheduled_task(task_id: int) -> dict:
@@ -70,7 +71,7 @@ def register_schedule_tools(mcp: FastMCP) -> None:
         try:
             return Schedule().get_specs(task_id)
         except Exception as exc:
-            raise RuntimeError(f"Failed to get scheduled task: {str(exc)}") from exc
+            raise ToolError(f"Failed to get scheduled task: {str(exc)}") from exc
 
     @mcp.tool()
     def update_scheduled_task(task_id: int, params: dict) -> dict:
@@ -88,4 +89,4 @@ def register_schedule_tools(mcp: FastMCP) -> None:
         try:
             return Schedule().update(task_id, params)
         except Exception as exc:
-            raise RuntimeError(f"Failed to update scheduled task: {str(exc)}") from exc
+            raise ToolError(f"Failed to update scheduled task: {str(exc)}") from exc

{pythonanywhere_mcp_server-0.0.12 → pythonanywhere_mcp_server-0.0.14}/src/pythonanywhere_mcp_server/tools/webapp.py

@@ -1,6 +1,7 @@
 from pathlib import Path
 
-from mcp.server.fastmcp import FastMCP
+from mcp.server import MCPServer
+from mcp.server.mcpserver.exceptions import ToolError
 
 from pythonanywhere_core.webapp import Webapp
 from pythonanywhere_core.base import AuthenticationError, NoTokenError
@@ -9,7 +10,12 @@ from pythonanywhere_core.exceptions import MissingCNAMEException
 # ToDo: Add the log file functions once pythonanywhere-core webapp log file functions
 # have been improved
 
-def register_webapp_tools(mcp: FastMCP) -> None:
+def _without_password(config: dict) -> dict:
+    """Omit the basic-auth password from a successful configuration result."""
+    return {key: value for key, value in config.items() if key != "password_protection_password"}
+
+
+def register_webapp_tools(mcp: MCPServer) -> None:
     @mcp.tool()
     def reload_webapp(domain: str) -> str:
         """
@@ -32,19 +38,19 @@ def register_webapp_tools(mcp: FastMCP) -> None:
         except MissingCNAMEException as exc:
             return f"Webapp '{domain}' reloaded. Note: {str(exc)}"
         except (AuthenticationError, NoTokenError):
-            raise RuntimeError("Authentication failed — check API_TOKEN and domain.")
+            raise ToolError("Authentication failed — check API_TOKEN and domain.")
         except Exception as exc:
-            raise RuntimeError(str(exc)) from exc
+            raise ToolError(str(exc)) from exc
 
     @mcp.tool()
-    def create_webapp(domain: str, python_version: str, virtualenv_path: str, project_path: str) -> str:
+    def create_webapp(domain: str, python_version: str, virtualenv_path: str | None, project_path: str) -> str:
         """
         Create a new uWSGI-based web application for the given domain.
 
         This creates a new webapp on PythonAnywhere with the specified configuration.
         The webapp will be created using the specified Python version, virtual environment,
-        and project path. If a webapp already exists for this domain, it will fail unless
-        the nuke parameter is set to True.
+        and project path. If a webapp already exists for this domain, creation fails;
+        this tool does not replace existing webapps.
 
         The WSGI configuration file can be found in /var/www. The file is of the format:
         domain.replace('.', '_') + '_wsgi.py' It would be automatically created as side effect of running this tool.
@@ -64,7 +70,7 @@ def register_webapp_tools(mcp: FastMCP) -> None:
             str: Status message indicating creation result.
 
         Raises:
-            RuntimeError: If authentication fails, webapp already exists (and nuke=False),
+            ToolError: If authentication fails, webapp already exists,
                          or other API errors occur. If 403 error is raised, it may mean that there
                          is already a non-uwsgi-based website. `list_websites` tool can be used to check that.
         """
@@ -72,15 +78,15 @@ def register_webapp_tools(mcp: FastMCP) -> None:
             webapp = Webapp(domain)
             webapp.create(
                 python_version=python_version,
-                virtualenv_path=Path(virtualenv_path),
+                virtualenv_path=Path(virtualenv_path) if virtualenv_path is not None else None,
                 project_path=Path(project_path),
                 nuke=False
             )
             return f"Webapp '{domain}' created successfully."
         except (AuthenticationError, NoTokenError):
-            raise RuntimeError("Authentication failed — check API_TOKEN and domain.")
+            raise ToolError("Authentication failed — check API_TOKEN and domain.")
         except Exception as exc:
-            raise RuntimeError(str(exc)) from exc
+            raise ToolError(str(exc)) from exc
 
     @mcp.tool()
     def delete_webapp(domain: str) -> str:
@@ -99,15 +105,15 @@ def register_webapp_tools(mcp: FastMCP) -> None:
             str: Status message indicating deletion result.
 
         Raises:
-            RuntimeError: If authentication fails, webapp doesn't exist, or other API errors occur.
+            ToolError: If authentication fails, webapp doesn't exist, or other API errors occur.
         """
         try:
             Webapp(domain).delete()
             return f"Webapp '{domain}' deleted successfully."
         except (AuthenticationError, NoTokenError):
-            raise RuntimeError("Authentication failed — check API_TOKEN and domain.")
+            raise ToolError("Authentication failed — check API_TOKEN and domain.")
         except Exception as exc:
-            raise RuntimeError(str(exc)) from exc
+            raise ToolError(str(exc)) from exc
 
     @mcp.tool()
     def patch_webapp(domain: str, data: dict) -> dict:
@@ -150,20 +156,21 @@ def register_webapp_tools(mcp: FastMCP) -> None:
                     "expiry": "2025-10-16",
                     "force_https": False,
                     "password_protection_enabled": False,
-                    "password_protection_username": "foo",
-                    "password_protection_password": "bar"
+                    "password_protection_username": "foo"
                 }
 
         Raises:
-            RuntimeError: If authentication fails, webapp doesn't exist, or other API errors occur.
+            ToolError: If authentication fails, webapp doesn't exist, or other API errors occur.
         """
         try:
             result = Webapp(domain).patch(data)
-            return result
+            return _without_password(result)
         except (AuthenticationError, NoTokenError):
-            raise RuntimeError("Authentication failed — check API_TOKEN and domain.")
-        except Exception as exc:
-            raise RuntimeError(str(exc)) from exc
+            raise ToolError("Authentication failed — check API_TOKEN and domain.")
+        except Exception:
+            raise ToolError(
+                "Webapp update failed; inspect the configuration before retrying."
+            ) from None
 
     @mcp.tool()
     def list_webapps() -> list:
@@ -186,15 +193,15 @@ def register_webapp_tools(mcp: FastMCP) -> None:
             get_webapp_info: Get detailed information about a specific webapp.
 
         Raises:
-            RuntimeError: If authentication fails or other API errors occur.
+            ToolError: If authentication fails or other API errors occur.
         """
         try:
             result = Webapp.list_webapps()
-            return result
+            return [_without_password(config) for config in result]
         except (AuthenticationError, NoTokenError):
-            raise RuntimeError("Authentication failed — check API_TOKEN.")
+            raise ToolError("Authentication failed — check API_TOKEN.")
         except Exception as exc:
-            raise RuntimeError(str(exc)) from exc
+            raise ToolError(str(exc)) from exc
 
     @mcp.tool()
     def get_webapp_info(domain: str) -> dict:
@@ -222,19 +229,18 @@ def register_webapp_tools(mcp: FastMCP) -> None:
                   - "force_https": bool,  # Whether HTTPS is enforced
                   - "password_protection_enabled": bool,  # Whether password protection is enabled
                   - "password_protection_username": str,  # Username for password-protected access
-                  - "password_protection_password": str   # Password for password-protected access
 
 
         Raises:
-            RuntimeError: If authentication fails, webapp doesn't exist, or other API errors occur.
+            ToolError: If authentication fails, webapp doesn't exist, or other API errors occur.
         """
         try:
             result = Webapp(domain).get()
-            return result
+            return _without_password(result)
         except (AuthenticationError, NoTokenError):
-            raise RuntimeError("Authentication failed — check API_TOKEN and domain.")
+            raise ToolError("Authentication failed — check API_TOKEN and domain.")
         except Exception as exc:
-            raise RuntimeError(str(exc)) from exc
+            raise ToolError(str(exc)) from exc
 
 
 

{pythonanywhere_mcp_server-0.0.12 → pythonanywhere_mcp_server-0.0.14}/src/pythonanywhere_mcp_server/tools/website.py

@@ -1,12 +1,13 @@
 from typing import Any
 
-from mcp.server.fastmcp import FastMCP
+from mcp.server import MCPServer
+from mcp.server.mcpserver.exceptions import ToolError
 
 from pythonanywhere_core.website import Website
 from pythonanywhere_core.base import AuthenticationError, NoTokenError
 
 
-def register_website_tools(mcp: FastMCP) -> None:
+def register_website_tools(mcp: MCPServer) -> None:
     @mcp.tool()
     def reload_website(domain: str) -> str:
         """
@@ -27,9 +28,9 @@ def register_website_tools(mcp: FastMCP) -> None:
             Website().reload(domain)
             return f"Website '{domain}' reloaded."
         except (AuthenticationError, NoTokenError):
-            raise RuntimeError("Authentication failed — check API_TOKEN and domain.")
+            raise ToolError("Authentication failed — check API_TOKEN and domain.")
         except Exception as exc:
-            raise RuntimeError(str(exc)) from exc
+            raise ToolError(str(exc)) from exc
 
     @mcp.tool()
     def list_websites() -> list[dict[str, Any]]:
@@ -50,7 +51,7 @@ def register_website_tools(mcp: FastMCP) -> None:
         try:
             return Website().list()
         except Exception as exc:
-            raise RuntimeError(f"Failed to list websites: {str(exc)}") from exc
+            raise ToolError(f"Failed to list websites: {str(exc)}") from exc
 
     @mcp.tool()
     def create_website(domain_name: str, command: str) -> dict:
@@ -88,7 +89,7 @@ def register_website_tools(mcp: FastMCP) -> None:
         try:
             return Website().create(domain_name, command)
         except Exception as exc:
-            raise RuntimeError(f"Failed to create website: {str(exc)}") from exc
+            raise ToolError(f"Failed to create website: {str(exc)}") from exc
 
     @mcp.tool()
     def delete_website(domain_name: str) -> dict:
@@ -104,4 +105,4 @@ def register_website_tools(mcp: FastMCP) -> None:
         try:
             return Website().delete(domain_name)
         except Exception as exc:
-            raise RuntimeError(f"Failed to delete website: {str(exc)}") from exc
+            raise ToolError(f"Failed to delete website: {str(exc)}") from exc

{pythonanywhere_mcp_server-0.0.12 → pythonanywhere_mcp_server-0.0.14/src/pythonanywhere_mcp_server.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythonanywhere-mcp-server
-Version: 0.0.12
+Version: 0.0.14
 Summary: PythonAnywhere Model Context Protocol Server
 Author-email: PythonAnywhere Developers <developers@pythonanywhere.com>
 License-Expression: MIT
@@ -18,8 +18,8 @@ Classifier: Topic :: Utilities
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: pythonanywhere-core>=0.3.0
-Requires-Dist: mcp[cli]<2.0.0
+Requires-Dist: pythonanywhere-core>=0.3.3
+Requires-Dist: mcp[cli]<3,>=2.2.0
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-mock; extra == "test"

{pythonanywhere_mcp_server-0.0.12 → pythonanywhere_mcp_server-0.0.14}/src/pythonanywhere_mcp_server.egg-info/SOURCES.txt

@@ -16,6 +16,7 @@ src/pythonanywhere_mcp_server/tools/schedule.py
 src/pythonanywhere_mcp_server/tools/webapp.py
 src/pythonanywhere_mcp_server/tools/website.py
 tests/test_file_tools.py
+tests/test_mcp_integration.py
 tests/test_schedule_tools.py
 tests/test_server.py
 tests/test_webapp_tools.py

pythonanywhere_mcp_server-0.0.14/src/pythonanywhere_mcp_server.egg-info/requires.txt

@@ -0,0 +1,6 @@
+pythonanywhere-core>=0.3.3
+mcp[cli]<3,>=2.2.0
+
+[test]
+pytest
+pytest-mock

{pythonanywhere_mcp_server-0.0.12 → pythonanywhere_mcp_server-0.0.14}/tests/test_file_tools.py

@@ -1,22 +1,33 @@
+import json
+
 import pytest
+from mcp.server.mcpserver.exceptions import ToolError
 
 import tools.file as file_tools
 
 
-def test_read_file_or_directory_file(mcp, mocker):
+@pytest.mark.parametrize("content", ["file contents", 'Café says "hello"\n'])
+def test_read_file_or_directory_file(mcp, mocker, content):
     file_tools.register_file_tools(mcp)
     mock_files = mocker.patch("tools.file.Files", autospec=True)
-    mock_files.return_value.path_get.return_value = b"file contents"
+    mock_files.return_value.path_get.return_value = content.encode("utf-8")
     result = mcp.call_tool("read_file_or_directory", {"path": "/some/file.txt"})
-    assert result == "file contents"
+    assert result == content
 
 
 def test_read_file_or_directory_directory(mcp, mocker):
     file_tools.register_file_tools(mcp)
     mock_files = mocker.patch("tools.file.Files", autospec=True)
-    mock_files.return_value.path_get.return_value = {"listing": ["a", "b"]}
+    listing = {
+        'a "quoted" file.txt': {"type": "file", "url": "/files/quoted"},
+        "café": {"type": "directory", "url": "/files/cafe"},
+    }
+    mock_files.return_value.path_get.return_value = listing
+
     result = mcp.call_tool("read_file_or_directory", {"path": "/some/dir/"})
-    assert result == str({"listing": ["a", "b"]})
+
+    assert json.loads(result) == listing
+    mock_files.return_value.path_get.assert_called_once_with("/some/dir/")
 
 
 def test_upload_text_file(mcp, mocker):
@@ -39,7 +50,7 @@ def test_read_file_or_directory_file_exception(mcp, mocker):
     file_tools.register_file_tools(mcp)
     mock_files = mocker.patch("tools.file.Files", autospec=True)
     mock_files.return_value.path_get.side_effect = Exception("read error")
-    with pytest.raises(RuntimeError) as exc:
+    with pytest.raises(ToolError) as exc:
         mcp.call_tool("read_file_or_directory", {"path": "/some/file.txt"})
     assert "Failed to read file or directory: read error" in str(exc)
 
@@ -48,7 +59,7 @@ def test_upload_text_file_exception(mcp, mocker):
     file_tools.register_file_tools(mcp)
     mock_files = mocker.patch("tools.file.Files", autospec=True)
     mock_files.return_value.path_post.side_effect = Exception("upload error")
-    with pytest.raises(RuntimeError) as exc:
+    with pytest.raises(ToolError) as exc:
         mcp.call_tool("upload_text_file", {"dest_path": "/some/file.txt", "content": "hello"})
     assert "Failed to upload text file: upload error" in str(exc)
 
@@ -57,7 +68,7 @@ def test_delete_path_exception(mcp, mocker):
     file_tools.register_file_tools(mcp)
     mock_files = mocker.patch("tools.file.Files", autospec=True)
     mock_files.return_value.path_delete.side_effect = Exception("delete error")
-    with pytest.raises(RuntimeError) as exc:
+    with pytest.raises(ToolError) as exc:
         mcp.call_tool("delete_path", {"path": "/some/file.txt"})
     assert "Failed to delete path: delete error" in str(exc)
 
@@ -74,7 +85,7 @@ def test_upload_directory_exception(mcp, mocker):
     file_tools.register_file_tools(mcp)
     mock_files = mocker.patch("tools.file.Files", autospec=True)
     mock_files.return_value.tree_post.side_effect = Exception("upload dir error")
-    with pytest.raises(RuntimeError) as exc:
+    with pytest.raises(ToolError) as exc:
         mcp.call_tool("upload_directory", {"local_dir_path": "/local/myapp", "remote_dir_path": "/home/user/myapp"})
     assert "Failed to upload directory: upload dir error" in str(exc)
 
@@ -91,6 +102,6 @@ def test_directory_tree_exception(mcp, mocker):
     file_tools.register_file_tools(mcp)
     mock_files = mocker.patch("tools.file.Files", autospec=True)
     mock_files.return_value.tree_get.side_effect = Exception("tree error")
-    with pytest.raises(RuntimeError) as exc:
+    with pytest.raises(ToolError) as exc:
         mcp.call_tool("tree", {"path": "/some/dir/"})
     assert "Failed to get directory tree: tree error" in str(exc)

pythonanywhere_mcp_server-0.0.14/tests/test_mcp_integration.py

@@ -0,0 +1,144 @@
+from pathlib import Path
+
+import pytest
+
+from mcp import Client
+from pythonanywhere_core.exceptions import PythonAnywhereApiException
+
+from pythonanywhere_mcp_server.server import create_server
+
+
+EXPECTED_TOOLS = {
+    "create_scheduled_task",
+    "create_webapp",
+    "create_website",
+    "delete_path",
+    "delete_scheduled_task",
+    "delete_webapp",
+    "delete_website",
+    "get_scheduled_task",
+    "get_webapp_info",
+    "list_scheduled_tasks",
+    "list_webapps",
+    "list_websites",
+    "patch_webapp",
+    "read_file_or_directory",
+    "reload_webapp",
+    "reload_website",
+    "tree",
+    "update_scheduled_task",
+    "upload_directory",
+    "upload_text_file",
+}
+
+
+@pytest.fixture
+def server(monkeypatch):
+    monkeypatch.setenv("API_TOKEN", "dummy-token")
+    return create_server()
+
+
+@pytest.mark.anyio
+async def test_server_exposes_expected_tools(server):
+    async with Client(server) as client:
+        result = await client.list_tools()
+
+    assert {tool.name for tool in result.tools} == EXPECTED_TOOLS
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize("tool_name,method_name,arguments", [
+    ("get_webapp_info", "get", {"domain": "test.com"}),
+    ("list_webapps", "list_webapps", {}),
+    ("patch_webapp", "patch", {"domain": "test.com", "data": {"force_https": True}}),
+])
+async def test_webapp_password_is_absent_from_wire_result(
+    server, mocker, tool_name, method_name, arguments
+):
+    config = {"domain_name": "test.com", "password_protection_password": "sentinel-secret"}
+    mocker.patch(
+        f"pythonanywhere_mcp_server.tools.webapp.Webapp.{method_name}",
+        return_value=[config] if tool_name == "list_webapps" else config,
+    )
+
+    async with Client(server) as client:
+        result = await client.call_tool(tool_name, arguments)
+
+    assert not result.is_error
+    serialised = result.model_dump_json()
+    assert "test.com" in serialised
+    assert "sentinel-secret" not in serialised
+    assert "password_protection_password" not in serialised
+
+
+@pytest.mark.anyio
+async def test_create_webapp_schema_requires_nullable_virtualenv(server):
+    async with Client(server) as client:
+        result = await client.list_tools()
+
+    tool = next(tool for tool in result.tools if tool.name == "create_webapp")
+    schema = tool.input_schema
+    assert "virtualenv_path" in schema["required"]
+    assert {option["type"] for option in schema["properties"]["virtualenv_path"]["anyOf"]} == {
+        "string", "null"
+    }
+    assert "nuke" not in tool.description
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize("virtualenv_path", [None, "/home/test/venv"])
+async def test_create_webapp_accepts_nullable_virtualenv(server, mocker, virtualenv_path):
+    create = mocker.patch("pythonanywhere_mcp_server.tools.webapp.Webapp.create")
+    async with Client(server) as client:
+        result = await client.call_tool("create_webapp", {
+            "domain": "test.com",
+            "python_version": "3.10",
+            "virtualenv_path": virtualenv_path,
+            "project_path": "/home/test/project",
+        })
+
+    assert not result.is_error
+    create.assert_called_once_with(
+        python_version="3.10",
+        virtualenv_path=Path(virtualenv_path) if virtualenv_path is not None else None,
+        project_path=Path("/home/test/project"),
+        nuke=False,
+    )
+
+
+@pytest.mark.anyio
+@pytest.mark.parametrize("error_type", [PythonAnywhereApiException, ValueError])
+async def test_patch_error_wire_result_contains_no_secrets(server, mocker, error_type):
+    patch = mocker.patch(
+        "pythonanywhere_mcp_server.tools.webapp.Webapp.patch",
+        side_effect=error_type("sentinel-password sentinel-response"),
+    )
+    data = {"password_protection_password": "sentinel-password"}
+
+    async with Client(server) as client:
+        result = await client.call_tool("patch_webapp", {"domain": "sentinel-domain", "data": data})
+
+    assert result.is_error
+    assert "sentinel" not in result.model_dump_json()
+    assert result.content[0].text == (
+        "Error executing tool patch_webapp: "
+        "Webapp update failed; inspect the configuration before retrying."
+    )
+    patch.assert_called_once_with(data)
+
+
+@pytest.mark.anyio
+async def test_api_failure_is_returned_as_actionable_tool_error(server, mocker):
+    mocker.patch(
+        "pythonanywhere_mcp_server.tools.schedule.Schedule.get_list",
+        side_effect=Exception("list error"),
+    )
+
+    async with Client(server) as client:
+        result = await client.call_tool("list_scheduled_tasks")
+
+    assert result.is_error
+    assert result.content[0].text == (
+        "Error executing tool list_scheduled_tasks: "
+        "Failed to list scheduled tasks: list error"
+    )

{pythonanywhere_mcp_server-0.0.12 → pythonanywhere_mcp_server-0.0.14}/tests/test_schedule_tools.py

@@ -1,4 +1,5 @@
 import pytest
+from mcp.server.mcpserver.exceptions import ToolError
 
 import tools.schedule as schedule_tools
 
@@ -16,7 +17,7 @@ def test_list_scheduled_tasks_exception(mcp, mocker):
     schedule_tools.register_schedule_tools(mcp)
     mock_schedule = mocker.patch("tools.schedule.Schedule", autospec=True)
     mock_schedule.return_value.get_list.side_effect = Exception("list error")
-    with pytest.raises(RuntimeError) as exc:
+    with pytest.raises(ToolError) as exc:
         mcp.call_tool("list_scheduled_tasks", {})
     assert "Failed to list scheduled tasks: list error" in str(exc)
 
@@ -35,7 +36,7 @@ def test_create_scheduled_task_exception(mcp, mocker):
     mock_schedule = mocker.patch("tools.schedule.Schedule", autospec=True)
     mock_schedule.return_value.create.side_effect = Exception("create error")
     params = {"command": "ls", "enabled": True, "interval": "hourly", "minute": 0}
-    with pytest.raises(RuntimeError) as exc:
+    with pytest.raises(ToolError) as exc:
         mcp.call_tool("create_scheduled_task", {"params": params})
     assert "Failed to create scheduled task: create error" in str(exc)
 
@@ -53,7 +54,7 @@ def test_delete_scheduled_task_exception(mcp, mocker):
     schedule_tools.register_schedule_tools(mcp)
     mock_schedule = mocker.patch("tools.schedule.Schedule", autospec=True)
     mock_schedule.return_value.delete.side_effect = Exception("delete error")
-    with pytest.raises(RuntimeError) as exc:
+    with pytest.raises(ToolError) as exc:
         mcp.call_tool("delete_scheduled_task", {"task_id": 1})
     assert "Failed to delete scheduled task: delete error" in str(exc)
 
@@ -70,7 +71,7 @@ def test_get_scheduled_task_exception(mcp, mocker):
     schedule_tools.register_schedule_tools(mcp)
     mock_schedule = mocker.patch("tools.schedule.Schedule", autospec=True)
     mock_schedule.return_value.get_specs.side_effect = Exception("get error")
-    with pytest.raises(RuntimeError) as exc:
+    with pytest.raises(ToolError) as exc:
         mcp.call_tool("get_scheduled_task", {"task_id": 1})
     assert "Failed to get scheduled task: get error" in str(exc)
 
@@ -89,6 +90,6 @@ def test_update_scheduled_task_exception(mcp, mocker):
     mock_schedule = mocker.patch("tools.schedule.Schedule", autospec=True)
     mock_schedule.return_value.update.side_effect = Exception("update error")
     params = {"command": "ls -l"}
-    with pytest.raises(RuntimeError) as exc:
+    with pytest.raises(ToolError) as exc:
         mcp.call_tool("update_scheduled_task", {"task_id": 1, "params": params})
     assert "Failed to update scheduled task: update error" in str(exc)

{pythonanywhere_mcp_server-0.0.12 → pythonanywhere_mcp_server-0.0.14}/tests/test_server.py

@@ -4,15 +4,15 @@ from pythonanywhere_mcp_server import server
 
 
 @pytest.fixture()
-def mock_FastMCP(mocker):
-    """Mock the FastMCP class to avoid actual server creation."""
-    return mocker.patch("pythonanywhere_mcp_server.server.FastMCP", autospec=True)
+def mock_MCPServer(mocker):
+    """Mock the MCPServer class to avoid actual server creation."""
+    return mocker.patch("pythonanywhere_mcp_server.server.MCPServer", autospec=True)
 
 
-def test_create_server(monkeypatch, mock_FastMCP):
+def test_create_server(monkeypatch, mock_MCPServer):
     monkeypatch.setenv("API_TOKEN", "dummy-token")
     server.create_server()
-    mock_FastMCP.assert_called_once_with("PythonAnywhere Model Context Protocol Server")
+    mock_MCPServer.assert_called_once_with("PythonAnywhere Model Context Protocol Server")
 
 
 @pytest.mark.parametrize(
@@ -23,14 +23,14 @@ def test_create_server(monkeypatch, mock_FastMCP):
         "register_schedule_tools",
     ]
 )
-def test_register_tools(monkeypatch, mocker, mock_FastMCP, register_fn):
+def test_register_tools(monkeypatch, mocker, mock_MCPServer, register_fn):
     monkeypatch.setenv("API_TOKEN", "dummy-token")
     mock_register = mocker.patch(
         f"pythonanywhere_mcp_server.server.{register_fn}" ,
         autospec=True
     )
     server.create_server()
-    mock_register.assert_called_once_with(mock_FastMCP.return_value)
+    mock_register.assert_called_once_with(mock_MCPServer.return_value)
 
 
 def test_missing_api_token(monkeypatch):

{pythonanywhere_mcp_server-0.0.12 → pythonanywhere_mcp_server-0.0.14}/tests/test_webapp_tools.py

@@ -1,7 +1,8 @@
 import pytest
+from mcp.server.mcpserver.exceptions import ToolError
 from pathlib import Path
 from pythonanywhere_core.base import AuthenticationError
-from pythonanywhere_core.exceptions import MissingCNAMEException
+from pythonanywhere_core.exceptions import MissingCNAMEException, PythonAnywhereApiException
 
 import tools.webapp as webapp_tools
 
@@ -44,17 +45,34 @@ def test_webapp_tools_success(setup_webapp_tools, mocker, tool_name, method_name
     ("get_webapp_info", "get", {"domain": "test.com"}, AuthenticationError(), "Authentication failed"),
     ("get_webapp_info", "get", {"domain": "test.com"}, Exception("info error"), "info error"),
     ("patch_webapp", "patch", {"domain": "test.com", "data": {"python_version": "3.10"}}, AuthenticationError(), "Authentication failed"),
-    ("patch_webapp", "patch", {"domain": "test.com", "data": {"python_version": "3.10"}}, Exception("patch error"), "patch error"),
+    ("patch_webapp", "patch", {"domain": "test.com", "data": {"python_version": "3.10"}}, Exception("patch error"), "Webapp update failed; inspect the configuration before retrying."),
 ])
 def test_webapp_tools_errors(setup_webapp_tools, mocker, tool_name, method_name, params, side_effect, expected_error):
     mock_webapp = mocker.patch("tools.webapp.Webapp", autospec=True)
     getattr(mock_webapp.return_value, method_name).side_effect = side_effect
     
-    with pytest.raises(RuntimeError) as exc:
+    with pytest.raises(ToolError) as exc:
         setup_webapp_tools.call_tool(tool_name, params)
     assert expected_error in str(exc)
 
 
+@pytest.mark.parametrize("error_type", [PythonAnywhereApiException, ValueError])
+def test_patch_error_does_not_expose_secrets(setup_webapp_tools, mocker, error_type):
+    webapp = mocker.patch("tools.webapp.Webapp", autospec=True)
+    webapp.return_value.patch.side_effect = error_type("sentinel-password sentinel-response")
+    data = {"password_protection_password": "sentinel-password"}
+
+    with pytest.raises(ToolError) as exc:
+        setup_webapp_tools.call_tool("patch_webapp", {"domain": "sentinel-domain", "data": data})
+
+    assert str(exc.value) == "Webapp update failed; inspect the configuration before retrying."
+    assert exc.value.__cause__ is None
+    assert exc.value.__suppress_context__
+    webapp.assert_called_once_with("sentinel-domain")
+    webapp.return_value.patch.assert_called_once_with({"password_protection_password": "sentinel-password"})
+    assert data == {"password_protection_password": "sentinel-password"}
+
+
 @pytest.mark.parametrize("side_effect,expected_error", [
     (AuthenticationError(), "Authentication failed"),
     (Exception("list error"), "list error"),
@@ -63,15 +81,15 @@ def test_list_webapps_errors(setup_webapp_tools, mocker, side_effect, expected_e
     mocker.patch("tools.webapp.Webapp", autospec=True)
     mocker.patch("tools.webapp.Webapp.list_webapps", side_effect=side_effect)
     
-    with pytest.raises(RuntimeError) as exc:
+    with pytest.raises(ToolError) as exc:
         setup_webapp_tools.call_tool("list_webapps", {})
     assert expected_error in str(exc)
 
 
-def test_create_webapp(setup_webapp_tools, mocker):
+@pytest.mark.parametrize("virtualenv_path", [None, "/test/venv/path"])
+def test_create_webapp(setup_webapp_tools, mocker, virtualenv_path):
     webapp_domain = 'test.com'
     python_version = '3.10'
-    virtualenv_path = Path('/test/venv/path')
     project_path = Path('/project/path')
 
     mock_webapp = mocker.patch("tools.webapp.Webapp", autospec=True)
@@ -87,7 +105,7 @@ def test_create_webapp(setup_webapp_tools, mocker):
     mock_webapp.assert_called_with(webapp_domain)
     mock_webapp.return_value.create.assert_called_with(
         python_version=python_version,
-        virtualenv_path=virtualenv_path,
+        virtualenv_path=Path(virtualenv_path) if virtualenv_path is not None else None,
         project_path=project_path,
         nuke=False
     )
@@ -108,11 +126,51 @@ def test_create_webapp_errors(setup_webapp_tools, mocker, side_effect, expected_
         "virtualenv_path": "/test/venv/path",
         "project_path": "/project/path",
     }
-    with pytest.raises(RuntimeError) as exc:
+    with pytest.raises(ToolError) as exc:
         setup_webapp_tools.call_tool("create_webapp", params)
     assert expected_error in str(exc)
 
 
+@pytest.mark.parametrize("tool_name,method_name", [
+    ("get_webapp_info", "get"),
+    ("list_webapps", "list_webapps"),
+    ("patch_webapp", "patch"),
+])
+@pytest.mark.parametrize("has_password", [False, True])
+def test_webapp_results_omit_password_without_mutating_input(
+    setup_webapp_tools, mocker, tool_name, method_name, has_password
+):
+    safe = {"domain_name": "test.com", "password_protection_enabled": True}
+    original = dict(safe)
+    if has_password:
+        original["password_protection_password"] = "sentinel-secret"
+    snapshot = dict(original)
+    webapp = mocker.patch("tools.webapp.Webapp", autospec=True)
+    is_list = tool_name == "list_webapps"
+    method = getattr(webapp if is_list else webapp.return_value, method_name)
+    method.return_value = [original, dict(original)] if is_list else original
+    params = {} if is_list else {"domain": "test.com"}
+    patch_data = {"password_protection_password": "new-secret"}
+    if tool_name == "patch_webapp":
+        params["data"] = patch_data
+
+    result = setup_webapp_tools.call_tool(tool_name, params)
+
+    assert result == ([safe, safe] if is_list else safe)
+    assert original == snapshot
+    if is_list:
+        assert method.return_value == [snapshot, snapshot]
+    if tool_name == "patch_webapp":
+        method.assert_called_once_with({"password_protection_password": "new-secret"})
+        assert patch_data == {"password_protection_password": "new-secret"}
+
+
+def test_list_webapps_empty(setup_webapp_tools, mocker):
+    mocker.patch("tools.webapp.Webapp.list_webapps", return_value=[])
+
+    assert setup_webapp_tools.call_tool("list_webapps", {}) == []
+
+
 def test_list_webapps(setup_webapp_tools, mocker):
     mocker.patch("tools.webapp.Webapp", autospec=True)
     expected = [{"domain_name": "test.com", "python_version": "3.10"}]

{pythonanywhere_mcp_server-0.0.12 → pythonanywhere_mcp_server-0.0.14}/tests/test_website_tools.py

@@ -1,4 +1,5 @@
 import pytest
+from mcp.server.mcpserver.exceptions import ToolError
 
 import tools.website as website_tools
 
@@ -17,7 +18,7 @@ def test_list_websites_exception(mcp, mocker):
     website_tools.register_website_tools(mcp)
     mock_website = mocker.patch("tools.website.Website", autospec=True)
     mock_website.return_value.list.side_effect = Exception("list error")
-    with pytest.raises(RuntimeError) as exc:
+    with pytest.raises(ToolError) as exc:
         mcp.call_tool("list_websites", {})
     assert "Failed to list websites: list error" in str(exc)
 
@@ -36,7 +37,7 @@ def test_create_website_exception(mcp, mocker):
     mock_website = mocker.patch("tools.website.Website", autospec=True)
     mock_website.return_value.create.side_effect = Exception("create error")
     params = {"domain_name": "test.com", "command": "run.sh"}
-    with pytest.raises(RuntimeError) as exc:
+    with pytest.raises(ToolError) as exc:
         mcp.call_tool("create_website", params)
     assert "Failed to create website: create error" in str(exc)
 
@@ -54,7 +55,7 @@ def test_delete_website_exception(mcp, mocker):
     website_tools.register_website_tools(mcp)
     mock_website = mocker.patch("tools.website.Website", autospec=True)
     mock_website.return_value.delete.side_effect = Exception("delete error")
-    with pytest.raises(RuntimeError) as exc:
+    with pytest.raises(ToolError) as exc:
         mcp.call_tool("delete_website", {"domain_name": "test.com"})
     assert "Failed to delete website: delete error" in str(exc)
 
@@ -72,7 +73,7 @@ def test_reload_website_auth_error(mcp, mocker):
     mock_website = mocker.patch("tools.website.Website", autospec=True)
     from pythonanywhere_core.base import AuthenticationError
     mock_website.return_value.reload.side_effect = AuthenticationError()
-    with pytest.raises(RuntimeError) as exc:
+    with pytest.raises(ToolError) as exc:
         mcp.call_tool("reload_website", {"domain": "test.com"})
     assert "Authentication failed" in str(exc)
 
@@ -81,6 +82,6 @@ def test_reload_website_other_error(mcp, mocker):
     website_tools.register_website_tools(mcp)
     mock_website = mocker.patch("tools.website.Website", autospec=True)
     mock_website.return_value.reload.side_effect = Exception("website reload error")
-    with pytest.raises(RuntimeError) as exc:
+    with pytest.raises(ToolError) as exc:
         mcp.call_tool("reload_website", {"domain": "test.com"})
     assert "website reload error" in str(exc)

pythonanywhere_mcp_server-0.0.12/src/pythonanywhere_mcp_server/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.0.12"

pythonanywhere_mcp_server-0.0.12/src/pythonanywhere_mcp_server.egg-info/requires.txt

@@ -1,6 +0,0 @@
-pythonanywhere-core>=0.3.0
-mcp[cli]<2.0.0
-
-[test]
-pytest
-pytest-mock