Adds more tools for handling WSGI web apps.

leec1979 · filiplajszczak · commit ca139cdc0755 · 2025-07-21T15:23:53.000Z
Co-authored-by: Piotr Kaznowski &lt;piotr@kazno.dev&gt;
    Co-authored-by: Lee Cartwright &lt;lcartwright@anaconda.com&gt;

Added a test for the create_webapp functionality.

Updated some dependencies, most importantly pythonanywhere-core.

Added a bunch of webapp functionality.
diff --git a/manifest.json b/manifest.json
@@ -8,16 +8,7 @@
     "name": "PythonAnywhere Developers",
     "email": "developers@pythonanywhere.com"
   },
-  "main": "pythonanywhere_mcp_server.py",
-  "categories": [
-    "developer-tools",
-    "utilities"
-  ],
   "license": "MIT",
-  "permissions": [
-    "mcp",
-    "filesystem"
-  ],
   "user_config": {
     "pa_api_token": {
       "type": "string",
diff --git a/src/pythonanywhere_mcp_server/tools/webapp.py b/src/pythonanywhere_mcp_server/tools/webapp.py
@@ -1,8 +1,12 @@
+from pathlib import Path
+
 from mcp.server.fastmcp import FastMCP
 
 from pythonanywhere_core.webapp import Webapp
 from pythonanywhere_core.base import AuthenticationError, NoTokenError
 
+# ToDo: Add the log file functions once pythonanywhere-core webapp log file functions
+# have been improved
 
 def register_webapp_tools(mcp: FastMCP) -> None:
     @mcp.tool()
@@ -28,3 +32,206 @@ def reload_webapp(domain: str) -> str:
             raise RuntimeError("Authentication failed — check API_TOKEN and domain.")
         except Exception as exc:
             raise RuntimeError(str(exc)) from exc
+
+    @mcp.tool()
+    def create_webapp(domain: str, python_version: str, virtualenv_path: str, 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.
+
+        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.
+
+        Note:
+            Virtual environments should be configured in the PythonAnywhere web app
+            configuration, not in the WSGI file itself.
+
+        Args:
+            domain (str): The domain name for the new webapp (e.g., 'alice.pythonanywhere.com').
+            python_version (str): Python version to use (e.g., '3.11', '3.10', '3.9').
+            virtualenv_path (str | None): Path to the virtual environment to use. (or None for
+            no virtualenv when using one of pre-installed Pythons with batteries included packages)
+            project_path (str): Path to the project directory containing the webapp code.
+
+        Returns:
+            str: Status message indicating creation result.
+
+        Raises:
+            RuntimeError: If authentication fails, webapp already exists (and nuke=False),
+                         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.
+        """
+        try:
+            webapp = Webapp(domain)
+            webapp.create(
+                python_version=python_version,
+                virtualenv_path=Path(virtualenv_path),
+                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.")
+        except Exception as exc:
+            raise RuntimeError(str(exc)) from exc
+
+    @mcp.tool()
+    def delete_webapp(domain: str) -> str:
+        """
+        Delete a uWSGI-based web application for the given domain.
+
+        This permanently deletes the webapp configuration from PythonAnywhere. The actual
+        files in your file system are not deleted, only the webapp configuration that
+        serves them. This action cannot be undone.
+
+        Args:
+            domain (str): The domain name of the webapp to delete
+                          (e.g., 'alice.pythonanywhere.com').
+
+        Returns:
+            str: Status message indicating deletion result.
+
+        Raises:
+            RuntimeError: 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.")
+        except Exception as exc:
+            raise RuntimeError(str(exc)) from exc
+
+    @mcp.tool()
+    def patch_webapp(domain: str, data: dict) -> dict:
+        """
+        Update configuration settings for a uWSGI-based web application.
+
+        This allows you to modify various webapp settings such as the Python version,
+        virtual environment path, source directory, and other configuration options.
+        Only the fields provided in the data dictionary will be updated.
+
+        In order for any changes to take effect you must reload the webapp.
+
+        If you provide an invalid Python version you will receive a 400 error with an error
+        message that the version you used is not a valid choice. You will need to choose a
+        different Python version if you get this error.
+
+        Args:
+            domain (str): The domain name of the webapp to update
+                          (e.g., 'alice.pythonanywhere.com').
+            data (dict): Dictionary containing the configuration updates. Supported keys are:
+                        - 'python_version': Python version (e.g., '3.11')
+                        - 'virtualenv_path': Path to virtual environment
+                        - 'source_directory': Path to source code directory
+                        - 'working_directory': Working directory for the webapp
+                        - 'force_https': Force the use of HTTPS when accessing the webapp
+                        - 'password_protection_enabled': Enable basic HTTP password to your webapp, provided via PythonAnywhere not in the webapp code
+                        - 'password_protection_username': The username used for HTTP password protection
+                        - 'password_protection_password': The password used for HTTP password protection
+
+        Returns:
+            dict: Updated webapp configuration information.
+                Example: {
+                    "id": 2097234,
+                    "user": username,
+                    "domain_name": domain,
+                    "python_version": "3.10",
+                    "source_directory": f"/home/{username}/mysite",
+                    "working_directory": f"/home/{username}/",
+                    "virtualenv_path": "",
+                    "expiry": "2025-10-16",
+                    "force_https": False,
+                    "password_protection_enabled": False,
+                    "password_protection_username": "foo",
+                    "password_protection_password": "bar"
+                }
+
+        Raises:
+            RuntimeError: If authentication fails, webapp doesn't exist, or other API errors occur.
+        """
+        try:
+            result = Webapp(domain).patch(data)
+            return result
+        except (AuthenticationError, NoTokenError):
+            raise RuntimeError("Authentication failed — check API_TOKEN and domain.")
+        except Exception as exc:
+            raise RuntimeError(str(exc)) from exc
+
+    @mcp.tool()
+    def list_webapps() -> list:
+        """
+        List all uWSGI-based web applications for the current user.
+
+        This retrieves information about all webapps configured in your PythonAnywhere
+        account. The returned list contains dictionaries with detailed information about
+        each webapp including domain, Python version, paths, and status.
+
+        On PythonAnywhere one may also have non-uWSGI-based websites (usually ASGI-based),
+        which are not included in this list. For those, use the `list_websites` tool.
+
+        Returns:
+            list: List of dictionaries containing webapp information. Empty list means
+            no WSGI-based webapps are deployed. That still could mean that there are
+            non-WSGI-based apps that can be listed with the `list_websites` tool.
+
+        See also:
+            get_webapp_info: Get detailed information about a specific webapp.
+
+        Raises:
+            RuntimeError: If authentication fails or other API errors occur.
+        """
+        try:
+            result = Webapp.list_webapps()
+            return result
+        except (AuthenticationError, NoTokenError):
+            raise RuntimeError("Authentication failed — check API_TOKEN.")
+        except Exception as exc:
+            raise RuntimeError(str(exc)) from exc
+
+    @mcp.tool()
+    def get_webapp_info(domain: str) -> dict:
+        """
+        Get detailed information about a specific uWSGI-based web application.
+
+        This retrieves comprehensive configuration and status information for the
+        specified webapp, including paths, Python version, enabled status, and
+        other configuration details.
+
+        Args:
+            domain (str): The domain name of the webapp to get information for
+                          (e.g., 'alice.pythonanywhere.com').
+
+        Returns:
+            dict: Dictionary containing detailed webapp information including:
+                  - "id": int,  # Unique identifier for the site or user session
+                  - "user": str,  # Username associated with the deployment
+                  - "domain_name": str,  # Domain name for the deployed site
+                  - "python_version": str,  # Python version used, e.g., "3.10"
+                  - "source_directory": str,  # Absolute path to the site's source directory
+                  - "working_directory": str,  # Absolute path to the working directory
+                  - "virtualenv_path": str,  # Path to the Python virtual environment (can be empty)
+                  - "expiry": str,  # Expiration date in ISO format, e.g., "2025-10-16"
+                  - "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.
+        """
+        try:
+            result = Webapp(domain).get()
+            return result
+        except (AuthenticationError, NoTokenError):
+            raise RuntimeError("Authentication failed — check API_TOKEN and domain.")
+        except Exception as exc:
+            raise RuntimeError(str(exc)) from exc
+
+
+
diff --git a/src/pythonanywhere_mcp_server/tools/website.py b/src/pythonanywhere_mcp_server/tools/website.py
@@ -37,11 +37,14 @@ def list_websites() -> list[dict[str, Any]]:
         Return info dictionaries for every ASGI website configured for the current
         user.  Empty list means that there are no websites deployed.
         That would not include WSGI-based web applications,
-        which could be only reloaded with `reload_webapp` tool.
+        which could be only listed with the `list_webapps` tool.
 
 
         Returns:
             List[dict[str, Any]]: List of dictionaries with website information.
+            Empty list if no websites are configured for the user, but there could be
+            still WSGI-based web applications configured that qould be listed with
+            the `list_webapps` tool.
 
         """
         try:
diff --git a/tests/test_webapp_tools.py b/tests/test_webapp_tools.py
@@ -1,30 +1,120 @@
 import pytest
+from pathlib import Path
+from pythonanywhere_core.base import AuthenticationError
 
 import tools.webapp as webapp_tools
 
-def test_reload_webapp(mcp, mocker):
+
+@pytest.fixture
+def setup_webapp_tools(mcp):
     webapp_tools.register_webapp_tools(mcp)
+    return mcp
+
+
+@pytest.mark.parametrize("tool_name,method_name,params,expected_params,expected_result", [
+    ("reload_webapp", "reload", {"domain": "test.com"}, {}, "Webapp 'test.com' reloaded."),
+    ("delete_webapp", "delete", {"domain": "test.com"}, {}, "Webapp 'test.com' deleted successfully."),
+    ("get_webapp_info", "get", {"domain": "test.com"}, {}, {"domain_name": "test.com", "python_version": "3.10"}),
+    ("patch_webapp", "patch", {"domain": "test.com", "data": {"python_version": "3.10"}}, {"python_version": "3.10"}, {"domain_name": "test.com", "python_version": "3.10"}),
+])
+def test_webapp_tools_success(setup_webapp_tools, mocker, tool_name, method_name, params, expected_params, expected_result):
     mock_webapp = mocker.patch("tools.webapp.Webapp", autospec=True)
-    result = mcp.call_tool("reload_webapp", {"domain": "test.com"})
-    mock_webapp.assert_called_with("test.com")
-    mock_webapp.return_value.reload.assert_called_once()
-    assert result == "Webapp 'test.com' reloaded."
+    
+    if tool_name == "get_webapp_info" or tool_name == "patch_webapp":
+        getattr(mock_webapp.return_value, method_name).return_value = expected_result
+    
+    result = setup_webapp_tools.call_tool(tool_name, params)
+    
+    if "domain" in params:
+        mock_webapp.assert_called_with(params["domain"])
+        if expected_params:
+            getattr(mock_webapp.return_value, method_name).assert_called_with(expected_params)
+        else:
+            getattr(mock_webapp.return_value, method_name).assert_called_once()
+    
+    assert result == expected_result
 
 
-def test_reload_webapp_auth_error(mcp, mocker):
-    webapp_tools.register_webapp_tools(mcp)
+@pytest.mark.parametrize("tool_name,method_name,params,side_effect,expected_error", [
+    ("reload_webapp", "reload", {"domain": "test.com"}, AuthenticationError(), "Authentication failed"),
+    ("reload_webapp", "reload", {"domain": "test.com"}, Exception("webapp reload error"), "webapp reload error"),
+    ("delete_webapp", "delete", {"domain": "test.com"}, AuthenticationError(), "Authentication failed"),
+    ("delete_webapp", "delete", {"domain": "test.com"}, Exception("delete error"), "delete error"),
+    ("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"),
+])
+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)
-    from pythonanywhere_core.base import AuthenticationError
-    mock_webapp.return_value.reload.side_effect = AuthenticationError()
+    getattr(mock_webapp.return_value, method_name).side_effect = side_effect
+    
     with pytest.raises(RuntimeError) as exc:
-        mcp.call_tool("reload_webapp", {"domain": "test.com"})
-    assert "Authentication failed" in str(exc)
+        setup_webapp_tools.call_tool(tool_name, params)
+    assert expected_error in str(exc)
 
 
-def test_reload_webapp_other_error(mcp, mocker):
-    webapp_tools.register_webapp_tools(mcp)
+@pytest.mark.parametrize("side_effect,expected_error", [
+    (AuthenticationError(), "Authentication failed"),
+    (Exception("list error"), "list error"),
+])
+def test_list_webapps_errors(setup_webapp_tools, mocker, side_effect, expected_error):
+    mocker.patch("tools.webapp.Webapp", autospec=True)
+    mocker.patch("tools.webapp.Webapp.list_webapps", side_effect=side_effect)
+    
+    with pytest.raises(RuntimeError) as exc:
+        setup_webapp_tools.call_tool("list_webapps", {})
+    assert expected_error in str(exc)
+
+
+def test_create_webapp(setup_webapp_tools, mocker):
+    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)
-    mock_webapp.return_value.reload.side_effect = Exception("webapp reload error")
+    result = setup_webapp_tools.call_tool(
+        "create_webapp",
+        {
+            "domain": webapp_domain,
+            "python_version": python_version,
+            "virtualenv_path": virtualenv_path,
+            "project_path": project_path,
+        }
+    )
+    mock_webapp.assert_called_with(webapp_domain)
+    mock_webapp.return_value.create.assert_called_with(
+        python_version=python_version,
+        virtualenv_path=virtualenv_path,
+        project_path=project_path,
+        nuke=False
+    )
+    mock_webapp.return_value.create.assert_called_once()
+    assert result == f"Webapp 'test.com' created successfully."
+
+
+@pytest.mark.parametrize("side_effect,expected_error", [
+    (AuthenticationError(), "Authentication failed"),
+    (Exception("webapp create error"), "webapp create error"),
+])
+def test_create_webapp_errors(setup_webapp_tools, mocker, side_effect, expected_error):
+    mock_webapp = mocker.patch("tools.webapp.Webapp", autospec=True)
+    mock_webapp.return_value.create.side_effect = side_effect
+    params = {
+        "domain": "test.com",
+        "python_version": "3.10",
+        "virtualenv_path": "/test/venv/path",
+        "project_path": "/project/path",
+    }
     with pytest.raises(RuntimeError) as exc:
-        mcp.call_tool("reload_webapp", {"domain": "test.com"})
-    assert "webapp reload error" in str(exc)
+        setup_webapp_tools.call_tool("create_webapp", params)
+    assert expected_error in str(exc)
+
+
+def test_list_webapps(setup_webapp_tools, mocker):
+    mocker.patch("tools.webapp.Webapp", autospec=True)
+    expected = [{"domain_name": "test.com", "python_version": "3.10"}]
+    mocker.patch("tools.webapp.Webapp.list_webapps", return_value=expected)
+    result = setup_webapp_tools.call_tool("list_webapps", {})
+    assert result == expected
diff --git a/uv.lock b/uv.lock
