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

{pythonanywhere_mcp_server-0.0.13/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.13
+Version: 0.0.14
 Summary: PythonAnywhere Model Context Protocol Server
 Author-email: PythonAnywhere Developers <developers@pythonanywhere.com>
 License-Expression: MIT
@@ -18,7 +18,7 @@ Classifier: Topic :: Utilities
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: pythonanywhere-core>=0.3.2
+Requires-Dist: pythonanywhere-core>=0.3.3
 Requires-Dist: mcp[cli]<3,>=2.2.0
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"

{pythonanywhere_mcp_server-0.0.13 → 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.13"
+version = "0.0.14"
 description = "PythonAnywhere Model Context Protocol Server"
 authors = [
     {name = "PythonAnywhere Developers", email = "developers@pythonanywhere.com"}
@@ -12,7 +12,7 @@ authors = [
 readme = "README.md"
 requires-python = ">=3.13"
 dependencies = [
-    "pythonanywhere-core>=0.3.2",
+    "pythonanywhere-core>=0.3.3",
     "mcp[cli]>=2.2.0,<3",
 ]
 classifiers = [

pythonanywhere_mcp_server-0.0.14/src/pythonanywhere_mcp_server/__init__.py

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

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

@@ -10,6 +10,11 @@ from pythonanywhere_core.exceptions import MissingCNAMEException
 # ToDo: Add the log file functions once pythonanywhere-core webapp log file functions
 # have been improved
 
+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:
@@ -38,14 +43,14 @@ def register_webapp_tools(mcp: MCPServer) -> None:
             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.
@@ -65,7 +70,7 @@ def register_webapp_tools(mcp: MCPServer) -> None:
             str: Status message indicating creation result.
 
         Raises:
-            ToolError: 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.
         """
@@ -73,7 +78,7 @@ def register_webapp_tools(mcp: MCPServer) -> 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
             )
@@ -151,8 +156,7 @@ def register_webapp_tools(mcp: MCPServer) -> 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:
@@ -160,11 +164,13 @@ def register_webapp_tools(mcp: MCPServer) -> None:
         """
         try:
             result = Webapp(domain).patch(data)
-            return result
+            return _without_password(result)
         except (AuthenticationError, NoTokenError):
             raise ToolError("Authentication failed — check API_TOKEN and domain.")
-        except Exception as exc:
-            raise ToolError(str(exc)) from exc
+        except Exception:
+            raise ToolError(
+                "Webapp update failed; inspect the configuration before retrying."
+            ) from None
 
     @mcp.tool()
     def list_webapps() -> list:
@@ -191,7 +197,7 @@ def register_webapp_tools(mcp: MCPServer) -> None:
         """
         try:
             result = Webapp.list_webapps()
-            return result
+            return [_without_password(config) for config in result]
         except (AuthenticationError, NoTokenError):
             raise ToolError("Authentication failed — check API_TOKEN.")
         except Exception as exc:
@@ -223,7 +229,6 @@ def register_webapp_tools(mcp: MCPServer) -> 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:
@@ -231,7 +236,7 @@ def register_webapp_tools(mcp: MCPServer) -> None:
         """
         try:
             result = Webapp(domain).get()
-            return result
+            return _without_password(result)
         except (AuthenticationError, NoTokenError):
             raise ToolError("Authentication failed — check API_TOKEN and domain.")
         except Exception as exc:

{pythonanywhere_mcp_server-0.0.13 → 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.13
+Version: 0.0.14
 Summary: PythonAnywhere Model Context Protocol Server
 Author-email: PythonAnywhere Developers <developers@pythonanywhere.com>
 License-Expression: MIT
@@ -18,7 +18,7 @@ Classifier: Topic :: Utilities
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: pythonanywhere-core>=0.3.2
+Requires-Dist: pythonanywhere-core>=0.3.3
 Requires-Dist: mcp[cli]<3,>=2.2.0
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"

{pythonanywhere_mcp_server-0.0.13 → pythonanywhere_mcp_server-0.0.14}/src/pythonanywhere_mcp_server.egg-info/requires.txt

@@ -1,4 +1,4 @@
-pythonanywhere-core>=0.3.2
+pythonanywhere-core>=0.3.3
 mcp[cli]<3,>=2.2.0
 
 [test]

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.13 → pythonanywhere_mcp_server-0.0.14}/tests/test_webapp_tools.py

@@ -2,7 +2,7 @@ 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
 
@@ -45,7 +45,7 @@ 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)
@@ -56,6 +56,23 @@ def test_webapp_tools_errors(setup_webapp_tools, mocker, tool_name, method_name,
     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"),
@@ -69,10 +86,10 @@ def test_list_webapps_errors(setup_webapp_tools, mocker, side_effect, expected_e
     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)
@@ -88,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
     )
@@ -114,6 +131,46 @@ def test_create_webapp_errors(setup_webapp_tools, mocker, side_effect, expected_
     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.13/src/pythonanywhere_mcp_server/__init__.py

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

pythonanywhere_mcp_server-0.0.13/tests/test_mcp_integration.py

@@ -1,60 +0,0 @@
-import pytest
-
-from mcp import Client
-
-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
-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"
-    )