pythonanywhere-mcp-server 0.0.1__tar.gz

pythonanywhere_mcp_server-0.0.1/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2025 PythonAnywhere
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

pythonanywhere_mcp_server-0.0.1/PKG-INFO

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: pythonanywhere-mcp-server
+Version: 0.0.1
+Summary: PythonAnywhere Model Context Protocol Server
+Author-email: PythonAnywhere Developers <developers@pythonanywhere.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/pythonanywhere/pythonanywhere-mcp-server
+Project-URL: Repository, https://github.com/pythonanywhere/pythonanywhere-mcp-server
+Project-URL: Documentation, https://github.com/pythonanywhere/pythonanywhere-mcp-server#readme
+Project-URL: Issues, https://github.com/pythonanywhere/pythonanywhere-mcp-server/issues
+Project-URL: Changelog, https://github.com/pythonanywhere/pythonanywhere-mcp-server/releases
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Utilities
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pythonanywhere-core
+Requires-Dist: mcp[cli]
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-mock; extra == "test"
+Dynamic: license-file
+
+# PythonAnywhere Model Context Protocol Server
+
+A [Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction) 
+server acts as a bridge between AI-powered tools and your 
+[PythonAnywhere](https://www.pythonanywhere.com/) account, enabling secure, 
+programmatic management of files, websites, webapps, and scheduled tasks. By 
+exposing a standardized interface, it allows language models and automation 
+clients to perform operations—such as editing files, deploying web apps, or 
+scheduling jobs—on your behalf, all while maintaining fine-grained control
+and auditability.
+
+## Features
+- **File management**: Read, upload, delete files and list directory trees. 
+  _(also enables debugging with direct access to log files, which are just
+  files on PythonAnywhere)_
+- **ASGI Web app management**: Create, delete, reload, and list.
+  _(as described in the [PythonAnywhere ASGI 
+  documentation](https://help.pythonanywhere.com/pages/ASGICommandLine))_
+- **WSGI Web app management**: Reload only _(at the moment)_.
+- **Scheduled task management**: List, create, update, and delete.
+  _(Npote that it enables LLMs to execute arbitrary commands if a task is 
+  scheduled to soon after creation and deleted after execution. For that we  
+  would suggest running it with [mcp-server-time](https://pypi.org/project/mcp-server-time/)
+  as models easily get confused about time.)_
+
+## Installation
+MCP protocol is well-defined and supported by various clients, but 
+installation is different depending on the client you are using. We will 
+cover cases that we tried and tested.
+
+In all cases, you need to have `uv` installed and available in your `PATH`.
+
+Have your PythonAnywhere API token and username ready. You can find (or 
+generate) your API token in the [API section of your PythonAnywhere 
+account](https://www.pythonanywhere.com/account/#api_token).
+
+### Desktop Extension - works with Claude Desktop
+Probably the most straightforward way to install the MCP server is to use 
+the [desktop extension](https://github.com/anthropics/dxt/) for Claude Desktop.
+
+1. Open Claude Desktop.
+2. **[Download the latest .dxt file](https://github.com/pythonanywhere/pythonanywhere-mcp-server/releases/latest/download/pythonanywhere-mcp-server.dxt)**.
+3. Double-click on the downloaded .dxt file or drag the file into the window.
+4. Configure your PythonAnywhere API token and username.
+5. Restart Claude Desktop.
+
+### Claude Code
+Run:
+   ```bash
+   claude mcp add pythonanywhere-mcp-server\
+   -e API_TOKEN=yourpythonanywhereapitoken\ 
+   -e LOGNAME=yourpythonanywhereusername\ 
+   -- uvx pythonanywhere-mcp-server
+   ```
+
+### GitHub Copilot in PyCharm:
+Add it to your `mcp.json`.
+
+```json
+{
+  "servers": {
+    "pythonanywhere-mcp-server": {
+      "type": "stdio",
+      "command": "uvx",
+      "args": ["pythonanywhere-mcp-server"],
+      "env": {
+        "API_TOKEN": "yourpythonanywhereapitoken",
+        "LOGNAME": "yourpythonanywhereusername"
+      }
+    }
+  }
+}
+```
+
+### Claude Desktop (manual setup) and Cursor:
+Add it to `claude_desktop_config.json` (for Claude Desktop) or (`mcp.json` 
+for Cursor).
+
+```json
+{
+  "mcpServers": {
+    "pythonanywhere-mcp-server": {
+      "type": "stdio",
+      "command": "uvx",
+      "args": ["pythonanywhere-mcp-server"],
+      "env": {
+        "API_TOKEN": "yourpythonanywhereapitoken",
+        "LOGNAME": "yourpythonanywhereusername"
+      }
+    }
+  }
+}
+```
+
+## Caveats
+
+Direct integration of an LLM with your PythonAnywhere account offers 
+significant capabilities, but also introduces risks. We strongly advise 
+maintaining human oversight, especially for sensitive actions such as 
+modifying or deleting files.
+
+If you are running multiple MCP servers simultaneously, be 
+cautious—particularly if any server can access external resources you do not
+control, such as GitHub issues. These can become attack vectors. For more 
+details, see [this story](https://simonwillison.net/2025/Jul/6/supabase-mcp-lethal-trifecta/).
+
+## Implementation
+
+Server uses [python mcp sdk](https://github.com/modelcontextprotocol/python-sdk) 
+in connection with [pythonanywhere-core](https://github.com/pythonanywhere/pythonanywhere-core) 
+package ([docs](https://core.pythonanywhere.com/)) that wraps subset of [PythonAnywhere 
+API](https://help.pythonanywhere.com/pages/API/) and would be expanded in 
+the future as needed.

pythonanywhere_mcp_server-0.0.1/README.md

@@ -0,0 +1,113 @@
+# PythonAnywhere Model Context Protocol Server
+
+A [Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction) 
+server acts as a bridge between AI-powered tools and your 
+[PythonAnywhere](https://www.pythonanywhere.com/) account, enabling secure, 
+programmatic management of files, websites, webapps, and scheduled tasks. By 
+exposing a standardized interface, it allows language models and automation 
+clients to perform operations—such as editing files, deploying web apps, or 
+scheduling jobs—on your behalf, all while maintaining fine-grained control
+and auditability.
+
+## Features
+- **File management**: Read, upload, delete files and list directory trees. 
+  _(also enables debugging with direct access to log files, which are just
+  files on PythonAnywhere)_
+- **ASGI Web app management**: Create, delete, reload, and list.
+  _(as described in the [PythonAnywhere ASGI 
+  documentation](https://help.pythonanywhere.com/pages/ASGICommandLine))_
+- **WSGI Web app management**: Reload only _(at the moment)_.
+- **Scheduled task management**: List, create, update, and delete.
+  _(Npote that it enables LLMs to execute arbitrary commands if a task is 
+  scheduled to soon after creation and deleted after execution. For that we  
+  would suggest running it with [mcp-server-time](https://pypi.org/project/mcp-server-time/)
+  as models easily get confused about time.)_
+
+## Installation
+MCP protocol is well-defined and supported by various clients, but 
+installation is different depending on the client you are using. We will 
+cover cases that we tried and tested.
+
+In all cases, you need to have `uv` installed and available in your `PATH`.
+
+Have your PythonAnywhere API token and username ready. You can find (or 
+generate) your API token in the [API section of your PythonAnywhere 
+account](https://www.pythonanywhere.com/account/#api_token).
+
+### Desktop Extension - works with Claude Desktop
+Probably the most straightforward way to install the MCP server is to use 
+the [desktop extension](https://github.com/anthropics/dxt/) for Claude Desktop.
+
+1. Open Claude Desktop.
+2. **[Download the latest .dxt file](https://github.com/pythonanywhere/pythonanywhere-mcp-server/releases/latest/download/pythonanywhere-mcp-server.dxt)**.
+3. Double-click on the downloaded .dxt file or drag the file into the window.
+4. Configure your PythonAnywhere API token and username.
+5. Restart Claude Desktop.
+
+### Claude Code
+Run:
+   ```bash
+   claude mcp add pythonanywhere-mcp-server\
+   -e API_TOKEN=yourpythonanywhereapitoken\ 
+   -e LOGNAME=yourpythonanywhereusername\ 
+   -- uvx pythonanywhere-mcp-server
+   ```
+
+### GitHub Copilot in PyCharm:
+Add it to your `mcp.json`.
+
+```json
+{
+  "servers": {
+    "pythonanywhere-mcp-server": {
+      "type": "stdio",
+      "command": "uvx",
+      "args": ["pythonanywhere-mcp-server"],
+      "env": {
+        "API_TOKEN": "yourpythonanywhereapitoken",
+        "LOGNAME": "yourpythonanywhereusername"
+      }
+    }
+  }
+}
+```
+
+### Claude Desktop (manual setup) and Cursor:
+Add it to `claude_desktop_config.json` (for Claude Desktop) or (`mcp.json` 
+for Cursor).
+
+```json
+{
+  "mcpServers": {
+    "pythonanywhere-mcp-server": {
+      "type": "stdio",
+      "command": "uvx",
+      "args": ["pythonanywhere-mcp-server"],
+      "env": {
+        "API_TOKEN": "yourpythonanywhereapitoken",
+        "LOGNAME": "yourpythonanywhereusername"
+      }
+    }
+  }
+}
+```
+
+## Caveats
+
+Direct integration of an LLM with your PythonAnywhere account offers 
+significant capabilities, but also introduces risks. We strongly advise 
+maintaining human oversight, especially for sensitive actions such as 
+modifying or deleting files.
+
+If you are running multiple MCP servers simultaneously, be 
+cautious—particularly if any server can access external resources you do not
+control, such as GitHub issues. These can become attack vectors. For more 
+details, see [this story](https://simonwillison.net/2025/Jul/6/supabase-mcp-lethal-trifecta/).
+
+## Implementation
+
+Server uses [python mcp sdk](https://github.com/modelcontextprotocol/python-sdk) 
+in connection with [pythonanywhere-core](https://github.com/pythonanywhere/pythonanywhere-core) 
+package ([docs](https://core.pythonanywhere.com/)) that wraps subset of [PythonAnywhere 
+API](https://help.pythonanywhere.com/pages/API/) and would be expanded in 
+the future as needed.

pythonanywhere_mcp_server-0.0.1/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools>=77.0.3", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pythonanywhere-mcp-server"
+version = "0.0.1"
+description = "PythonAnywhere Model Context Protocol Server"
+authors = [
+    {name = "PythonAnywhere Developers", email = "developers@pythonanywhere.com"}
+]
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "pythonanywhere-core",
+    "mcp[cli]",
+]
+classifiers = [
+    "Development Status :: 2 - Pre-Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Utilities",
+]
+license = "MIT"
+
+[project.optional-dependencies]
+test = [
+    "pytest",
+    "pytest-mock",
+]
+
+[project.scripts]
+pythonanywhere-mcp-server = "pythonanywhere_mcp_server.__main__:main"
+
+[project.urls]
+Homepage = "https://github.com/pythonanywhere/pythonanywhere-mcp-server"
+Repository = "https://github.com/pythonanywhere/pythonanywhere-mcp-server"
+Documentation = "https://github.com/pythonanywhere/pythonanywhere-mcp-server#readme"
+Issues = "https://github.com/pythonanywhere/pythonanywhere-mcp-server/issues"
+Changelog = "https://github.com/pythonanywhere/pythonanywhere-mcp-server/releases"
+
+[tool.pytest.ini_options]
+pythonpath = ["src/pythonanywhere_mcp_server"]

pythonanywhere_mcp_server-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pythonanywhere_mcp_server-0.0.1/src/pythonanywhere_mcp_server/__main__.py

@@ -0,0 +1,19 @@
+"""Entry point for the PythonAnywhere MCP server."""
+
+import sys
+from .server import create_server
+
+def main():
+    """Main entry point for the MCP server."""
+    try:
+        mcp = create_server()
+        mcp.run()
+    except KeyboardInterrupt:
+        print("\nServer interrupted by user", file=sys.stderr)
+        sys.exit(0)
+    except Exception as e:
+        print(f"Error starting server: {e}", file=sys.stderr)
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

pythonanywhere_mcp_server-0.0.1/src/pythonanywhere_mcp_server/server.py

@@ -0,0 +1,23 @@
+import os
+
+from mcp.server.fastmcp import FastMCP
+from .tools.file import register_file_tools
+from .tools.webapp import register_webapp_tools
+from .tools.website import register_website_tools
+from .tools.schedule import register_schedule_tools
+
+
+def create_server():
+    """Create the MCP server."""
+    API_TOKEN = os.getenv("API_TOKEN")
+    if not API_TOKEN:
+        raise RuntimeError("API_TOKEN environment variable must be set.")
+
+    mcp = FastMCP("PythonAnywhere Model Context Protocol Server")
+
+    register_file_tools(mcp)
+    register_website_tools(mcp)
+    register_schedule_tools(mcp)
+    register_webapp_tools(mcp)
+
+    return mcp

pythonanywhere_mcp_server-0.0.1/src/pythonanywhere_mcp_server/tools/__init__.py

@@ -0,0 +1 @@
+

pythonanywhere_mcp_server-0.0.1/src/pythonanywhere_mcp_server/tools/file.py

@@ -0,0 +1,80 @@
+from mcp.server.fastmcp import FastMCP
+
+from pythonanywhere_core.files import Files
+
+
+def register_file_tools(mcp: FastMCP) -> 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).
+
+        Args:
+            path (str): The absolute path to the file or directory.
+
+        Returns:
+            str: File contents or JSON directory listing.
+        """
+        try:
+            data = Files().path_get(path)
+            if isinstance(data, (bytes, bytearray)):
+                return data.decode()
+            return str(data)
+        except Exception as exc:
+            raise RuntimeError(f"Failed to read file or directory: {str(exc)}") from exc
+
+    @mcp.tool()
+    def upload_text_file(dest_path: str, content: str) -> str:
+        """
+        Create or replace a file with the given content (UTF-8 encoded).
+
+        Args:
+            dest_path (str): The absolute path where the file will be created or replaced.
+            content (str): The text content to write to the file.
+
+        Returns:
+            str: Status message indicating upload result.
+        """
+        try:
+            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
+
+    @mcp.tool()
+    def delete_path(path: str) -> str:
+        """
+        Permanently delete a file or directory (recursively if directory).
+
+        Args:
+            path (str): The absolute path to the file or directory to delete.
+
+        Returns:
+            str: Status message indicating deletion result.
+        """
+        try:
+            Files().path_delete(path)
+            return f"Deleted {path}."
+        except Exception as exc:
+            raise RuntimeError(f"Failed to delete path: {str(exc)}") from exc
+
+    @mcp.tool()
+    def tree(path: str) -> list[str]:
+        """
+        Return a list of absolute paths contained in the given directory.
+
+        Args:
+            path (str): The absolute path to the directory.
+                Home directory path is `/home/<username>/` where <username> is your username.
+
+        Returns:
+            List[str]: List of absolute paths contained in the directory.
+        """
+        try:
+            listing = Files().tree_get(path)
+            return listing
+        except Exception as exc:
+            raise RuntimeError(f"Failed to get directory tree: {str(exc)}") from exc

pythonanywhere_mcp_server-0.0.1/src/pythonanywhere_mcp_server/tools/schedule.py

@@ -0,0 +1,91 @@
+from mcp.server.fastmcp import FastMCP
+
+from pythonanywhere_core.schedule import Schedule
+
+
+def register_schedule_tools(mcp: FastMCP) -> None:
+    @mcp.tool()
+    def list_scheduled_tasks() -> list[dict]:
+        """
+        List all scheduled tasks for the current user.  Empty list
+        means that there are no scheduled tasks deployed.
+
+        Returns:
+            list[dict]: List of dictionaries, each representing a scheduled task.
+
+        """
+        try:
+            return Schedule().get_list()
+        except Exception as exc:
+            raise RuntimeError(f"Failed to list scheduled tasks: {str(exc)}") from exc
+
+    @mcp.tool()
+    def create_scheduled_task(params: dict) -> dict:
+        """
+        Create a new scheduled task.
+
+        Args:
+            params (dict): Dictionary with required scheduled task specs. Must include:
+                - command (str): The command to run.
+                - enabled (bool): Whether the task is enabled.
+                - interval (str): 'daily' or 'hourly'.
+                - hour (int, optional): Hour (24h format, for daily tasks).
+                - minute (int): Minute.
+
+        Returns:
+            dict: Dictionary with created task specs.
+        """
+        try:
+            return Schedule().create(params)
+        except Exception as exc:
+            raise RuntimeError(f"Failed to create scheduled task: {str(exc)}") from exc
+
+    @mcp.tool()
+    def delete_scheduled_task(task_id: int) -> bool:
+        """
+        Delete a scheduled task by its ID.
+
+        Args:
+            task_id (int): The ID of the scheduled task to delete.
+
+        Returns:
+            bool: True if deletion was successful.
+        """
+        try:
+            return Schedule().delete(task_id)
+        except Exception as exc:
+            raise RuntimeError(f"Failed to delete scheduled task: {str(exc)}") from exc
+
+    @mcp.tool()
+    def get_scheduled_task(task_id: int) -> dict:
+        """
+        Get the specifications of a scheduled task by its ID.
+
+        Args:
+            task_id (int): The ID of the scheduled task.
+
+        Returns:
+            dict: Dictionary of the task's specifications.
+        """
+        try:
+            return Schedule().get_specs(task_id)
+        except Exception as exc:
+            raise RuntimeError(f"Failed to get scheduled task: {str(exc)}") from exc
+
+    @mcp.tool()
+    def update_scheduled_task(task_id: int, params: dict) -> dict:
+        """
+        Update an existing scheduled task.
+
+        Args:
+            task_id (int): The ID of the scheduled task to update.
+            params (dict): Dictionary of specs to update. Should include at least one of:
+                - command, enabled, interval, hour, minute.
+
+        Returns:
+            dict: Dictionary with updated task specs.
+        """
+        try:
+            return Schedule().update(task_id, params)
+        except Exception as exc:
+            raise RuntimeError(f"Failed to update scheduled task: {str(exc)}") from exc

pythonanywhere_mcp_server-0.0.1/src/pythonanywhere_mcp_server/tools/webapp.py

@@ -0,0 +1,30 @@
+from mcp.server.fastmcp import FastMCP
+
+from pythonanywhere_core.webapp import Webapp
+from pythonanywhere_core.base import AuthenticationError, NoTokenError
+
+
+def register_webapp_tools(mcp: FastMCP) -> None:
+    @mcp.tool()
+    def reload_webapp(domain: str) -> str:
+        """
+        Reload a uWSGI-based web application for the given domain.
+
+        This reloads uwsgi-based web applications on PythonAnywhere. For ASGI-based
+        web applications, use the `reload_website` tool instead. Any changes to the
+        code require a reload to take effect.
+
+        Args:
+            domain (str): The domain name of the web application to reload
+                          (e.g., 'alice.pythonanywhere.com').
+
+        Returns:
+            str: Status message indicating reload's result.
+        """
+        try:
+            Webapp(domain).reload()
+            return f"Webapp '{domain}' reloaded."
+        except (AuthenticationError, NoTokenError):
+            raise RuntimeError("Authentication failed — check API_TOKEN and domain.")
+        except Exception as exc:
+            raise RuntimeError(str(exc)) from exc

pythonanywhere_mcp_server-0.0.1/src/pythonanywhere_mcp_server/tools/website.py

@@ -0,0 +1,104 @@
+from typing import Any
+
+from mcp.server.fastmcp import FastMCP
+
+from pythonanywhere_core.website import Website
+from pythonanywhere_core.base import AuthenticationError, NoTokenError
+
+
+def register_website_tools(mcp: FastMCP) -> None:
+    @mcp.tool()
+    def reload_website(domain: str) -> str:
+        """
+        Reload an ASGI-based website for the given domain.
+
+        This is for ASGI-based web applications on PythonAnywhere. For uWSGI-based
+        web applications, use the `reload_webapp` tool instead. Any changes to the
+        code require a reload to take effect.
+
+        Args:
+            domain (str): The domain name of the website to reload
+                          (e.g., 'alice.pythonanywhere.com').
+
+        Returns:
+            str: Status message indicating reload result.
+        """
+        try:
+            Website().reload(domain)
+            return f"Website '{domain}' reloaded."
+        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_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.
+
+
+        Returns:
+            List[dict[str, Any]]: List of dictionaries with website information.
+
+        """
+        try:
+            return Website().list()
+        except Exception as exc:
+            raise RuntimeError(f"Failed to list websites: {str(exc)}") from exc
+
+    @mcp.tool()
+    def create_website(domain_name: str, command: str) -> dict:
+        """
+        Create a new website with the specified domain name and command.
+
+        This function is primarily used to create a new ASGI-based website on
+        PythonAnywhere, but it can also be used for any website that communicates via
+        a Unix domain socket. The provided command must use the `DOMAIN_SOCKET`
+        environment variable to bind to the socket.
+
+        Args:
+            domain_name (str): The domain name for the new website
+                               (e.g., `yourusername.pythonanywhere.com` or `www.mydomain.com`).
+            command (str): The command to run for the new website. Examples:
+                - For FastAPI (ASGI):
+                    `/usr/local/bin/uvicorn myapp:app \
+                         --app-dir '/home/yourusername/fastapi/' \
+                         --uds ${DOMAIN_SOCKET}`
+                - For async Django:
+                    `/home/yourusername/.virtualenvs/my_venv/bin/uvicorn asyncdjango.asgi:application \
+                         --app-dir /home/yourusername/asyncdjango \
+                         --uds ${DOMAIN_SOCKET} `
+                - For non-ASGI websites (e.g., Streamlit):
+                    `/home/yourusername/.virtualenvs/my_venv/bin/streamlit \
+                         run /home/yourusername/my_streamlit/streamlit_app.py \
+                         --server.address "unix://${DOMAIN_SOCKET}" \
+                         --server.enableCORS false \
+                         --server.enableXsrfProtection false \
+                         --server.enableWebsocketCompression false`
+
+        Returns:
+            dict: A dictionary containing information about the created website.
+        """
+        try:
+            return Website().create(domain_name, command)
+        except Exception as exc:
+            raise RuntimeError(f"Failed to create website: {str(exc)}") from exc
+
+    @mcp.tool()
+    def delete_website(domain_name: str) -> dict:
+        """
+        Delete a website with the given domain name.
+
+        Args:
+            domain_name (str): The domain name for the website to delete.
+
+        Returns:
+            dict: Empty dictionary on success.
+        """
+        try:
+            return Website().delete(domain_name)
+        except Exception as exc:
+            raise RuntimeError(f"Failed to delete website: {str(exc)}") from exc

pythonanywhere_mcp_server-0.0.1/src/pythonanywhere_mcp_server.egg-info/PKG-INFO

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: pythonanywhere-mcp-server
+Version: 0.0.1
+Summary: PythonAnywhere Model Context Protocol Server
+Author-email: PythonAnywhere Developers <developers@pythonanywhere.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/pythonanywhere/pythonanywhere-mcp-server
+Project-URL: Repository, https://github.com/pythonanywhere/pythonanywhere-mcp-server
+Project-URL: Documentation, https://github.com/pythonanywhere/pythonanywhere-mcp-server#readme
+Project-URL: Issues, https://github.com/pythonanywhere/pythonanywhere-mcp-server/issues
+Project-URL: Changelog, https://github.com/pythonanywhere/pythonanywhere-mcp-server/releases
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Utilities
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pythonanywhere-core
+Requires-Dist: mcp[cli]
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-mock; extra == "test"
+Dynamic: license-file
+
+# PythonAnywhere Model Context Protocol Server
+
+A [Model Context Protocol (MCP)](https://modelcontextprotocol.io/introduction) 
+server acts as a bridge between AI-powered tools and your 
+[PythonAnywhere](https://www.pythonanywhere.com/) account, enabling secure, 
+programmatic management of files, websites, webapps, and scheduled tasks. By 
+exposing a standardized interface, it allows language models and automation 
+clients to perform operations—such as editing files, deploying web apps, or 
+scheduling jobs—on your behalf, all while maintaining fine-grained control
+and auditability.
+
+## Features
+- **File management**: Read, upload, delete files and list directory trees. 
+  _(also enables debugging with direct access to log files, which are just
+  files on PythonAnywhere)_
+- **ASGI Web app management**: Create, delete, reload, and list.
+  _(as described in the [PythonAnywhere ASGI 
+  documentation](https://help.pythonanywhere.com/pages/ASGICommandLine))_
+- **WSGI Web app management**: Reload only _(at the moment)_.
+- **Scheduled task management**: List, create, update, and delete.
+  _(Npote that it enables LLMs to execute arbitrary commands if a task is 
+  scheduled to soon after creation and deleted after execution. For that we  
+  would suggest running it with [mcp-server-time](https://pypi.org/project/mcp-server-time/)
+  as models easily get confused about time.)_
+
+## Installation
+MCP protocol is well-defined and supported by various clients, but 
+installation is different depending on the client you are using. We will 
+cover cases that we tried and tested.
+
+In all cases, you need to have `uv` installed and available in your `PATH`.
+
+Have your PythonAnywhere API token and username ready. You can find (or 
+generate) your API token in the [API section of your PythonAnywhere 
+account](https://www.pythonanywhere.com/account/#api_token).
+
+### Desktop Extension - works with Claude Desktop
+Probably the most straightforward way to install the MCP server is to use 
+the [desktop extension](https://github.com/anthropics/dxt/) for Claude Desktop.
+
+1. Open Claude Desktop.
+2. **[Download the latest .dxt file](https://github.com/pythonanywhere/pythonanywhere-mcp-server/releases/latest/download/pythonanywhere-mcp-server.dxt)**.
+3. Double-click on the downloaded .dxt file or drag the file into the window.
+4. Configure your PythonAnywhere API token and username.
+5. Restart Claude Desktop.
+
+### Claude Code
+Run:
+   ```bash
+   claude mcp add pythonanywhere-mcp-server\
+   -e API_TOKEN=yourpythonanywhereapitoken\ 
+   -e LOGNAME=yourpythonanywhereusername\ 
+   -- uvx pythonanywhere-mcp-server
+   ```
+
+### GitHub Copilot in PyCharm:
+Add it to your `mcp.json`.
+
+```json
+{
+  "servers": {
+    "pythonanywhere-mcp-server": {
+      "type": "stdio",
+      "command": "uvx",
+      "args": ["pythonanywhere-mcp-server"],
+      "env": {
+        "API_TOKEN": "yourpythonanywhereapitoken",
+        "LOGNAME": "yourpythonanywhereusername"
+      }
+    }
+  }
+}
+```
+
+### Claude Desktop (manual setup) and Cursor:
+Add it to `claude_desktop_config.json` (for Claude Desktop) or (`mcp.json` 
+for Cursor).
+
+```json
+{
+  "mcpServers": {
+    "pythonanywhere-mcp-server": {
+      "type": "stdio",
+      "command": "uvx",
+      "args": ["pythonanywhere-mcp-server"],
+      "env": {
+        "API_TOKEN": "yourpythonanywhereapitoken",
+        "LOGNAME": "yourpythonanywhereusername"
+      }
+    }
+  }
+}
+```
+
+## Caveats
+
+Direct integration of an LLM with your PythonAnywhere account offers 
+significant capabilities, but also introduces risks. We strongly advise 
+maintaining human oversight, especially for sensitive actions such as 
+modifying or deleting files.
+
+If you are running multiple MCP servers simultaneously, be 
+cautious—particularly if any server can access external resources you do not
+control, such as GitHub issues. These can become attack vectors. For more 
+details, see [this story](https://simonwillison.net/2025/Jul/6/supabase-mcp-lethal-trifecta/).
+
+## Implementation
+
+Server uses [python mcp sdk](https://github.com/modelcontextprotocol/python-sdk) 
+in connection with [pythonanywhere-core](https://github.com/pythonanywhere/pythonanywhere-core) 
+package ([docs](https://core.pythonanywhere.com/)) that wraps subset of [PythonAnywhere 
+API](https://help.pythonanywhere.com/pages/API/) and would be expanded in 
+the future as needed.

pythonanywhere_mcp_server-0.0.1/src/pythonanywhere_mcp_server.egg-info/SOURCES.txt

@@ -0,0 +1,22 @@
+LICENSE
+README.md
+pyproject.toml
+src/pythonanywhere_mcp_server/__init__.py
+src/pythonanywhere_mcp_server/__main__.py
+src/pythonanywhere_mcp_server/server.py
+src/pythonanywhere_mcp_server.egg-info/PKG-INFO
+src/pythonanywhere_mcp_server.egg-info/SOURCES.txt
+src/pythonanywhere_mcp_server.egg-info/dependency_links.txt
+src/pythonanywhere_mcp_server.egg-info/entry_points.txt
+src/pythonanywhere_mcp_server.egg-info/requires.txt
+src/pythonanywhere_mcp_server.egg-info/top_level.txt
+src/pythonanywhere_mcp_server/tools/__init__.py
+src/pythonanywhere_mcp_server/tools/file.py
+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_schedule_tools.py
+tests/test_server.py
+tests/test_webapp_tools.py
+tests/test_website_tools.py

pythonanywhere_mcp_server-0.0.1/src/pythonanywhere_mcp_server.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pythonanywhere_mcp_server-0.0.1/src/pythonanywhere_mcp_server.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pythonanywhere-mcp-server = pythonanywhere_mcp_server.__main__:main

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

@@ -0,0 +1,6 @@
+pythonanywhere-core
+mcp[cli]
+
+[test]
+pytest
+pytest-mock

pythonanywhere_mcp_server-0.0.1/src/pythonanywhere_mcp_server.egg-info/top_level.txt

@@ -0,0 +1 @@
+pythonanywhere_mcp_server

pythonanywhere_mcp_server-0.0.1/tests/test_file_tools.py

@@ -0,0 +1,79 @@
+import pytest
+
+import tools.file as file_tools
+
+
+def test_read_file_or_directory_file(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 = b"file contents"
+    result = mcp.call_tool("read_file_or_directory", {"path": "/some/file.txt"})
+    assert result == "file contents"
+
+
+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"]}
+    result = mcp.call_tool("read_file_or_directory", {"path": "/some/dir/"})
+    assert result == str({"listing": ["a", "b"]})
+
+
+def test_upload_text_file(mcp, mocker):
+    file_tools.register_file_tools(mcp)
+    mock_files = mocker.patch("tools.file.Files", autospec=True)
+    mock_files.return_value.path_post.return_value = 201
+    result = mcp.call_tool("upload_text_file", {"dest_path": "/some/file.txt", "content": "hello"})
+    assert result == "Uploaded to /some/file.txt (HTTP 201)."
+
+
+def test_delete_path(mcp, mocker):
+    file_tools.register_file_tools(mcp)
+    mock_files = mocker.patch("tools.file.Files", autospec=True)
+    result = mcp.call_tool("delete_path", {"path": "/some/file.txt"})
+    mock_files.return_value.path_delete.assert_called_with("/some/file.txt")
+    assert result == "Deleted /some/file.txt."
+
+
+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:
+        mcp.call_tool("read_file_or_directory", {"path": "/some/file.txt"})
+    assert "Failed to read file or directory: read error" in str(exc)
+
+
+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:
+        mcp.call_tool("upload_text_file", {"dest_path": "/some/file.txt", "content": "hello"})
+    assert "Failed to upload text file: upload error" in str(exc)
+
+
+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:
+        mcp.call_tool("delete_path", {"path": "/some/file.txt"})
+    assert "Failed to delete path: delete error" in str(exc)
+
+
+def test_directory_tree(mcp, mocker):
+    file_tools.register_file_tools(mcp)
+    mock_files = mocker.patch("tools.file.Files", autospec=True)
+    mock_files.return_value.tree_get.return_value = ["/a", "/b/c"]
+    result = mcp.call_tool("tree", {"path": "/some/dir/"})
+    assert result == ["/a", "/b/c"]
+
+
+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:
+        mcp.call_tool("tree", {"path": "/some/dir/"})
+    assert "Failed to get directory tree: tree error" in str(exc)

pythonanywhere_mcp_server-0.0.1/tests/test_schedule_tools.py

@@ -0,0 +1,94 @@
+import pytest
+
+import tools.schedule as schedule_tools
+
+def test_list_scheduled_tasks(mcp, mocker):
+    schedule_tools.register_schedule_tools(mcp)
+    mock_schedule = mocker.patch("tools.schedule.Schedule", autospec=True)
+    mock_schedule.return_value.get_list.return_value = [
+        {"id": 1, "command": "echo hi", "interval": "daily"}
+    ]
+    result = mcp.call_tool("list_scheduled_tasks", {})
+    assert result == [{"id": 1, "command": "echo hi", "interval": "daily"}]
+
+
+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:
+        mcp.call_tool("list_scheduled_tasks", {})
+    assert "Failed to list scheduled tasks: list error" in str(exc)
+
+
+def test_create_scheduled_task(mcp, mocker):
+    schedule_tools.register_schedule_tools(mcp)
+    mock_schedule = mocker.patch("tools.schedule.Schedule", autospec=True)
+    mock_schedule.return_value.create.return_value = {"id": 2, "command": "ls", "interval": "hourly"}
+    params = {"command": "ls", "enabled": True, "interval": "hourly", "minute": 0}
+    result = mcp.call_tool("create_scheduled_task", {"params": params})
+    assert result == {"id": 2, "command": "ls", "interval": "hourly"}
+
+
+def test_create_scheduled_task_exception(mcp, mocker):
+    schedule_tools.register_schedule_tools(mcp)
+    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:
+        mcp.call_tool("create_scheduled_task", {"params": params})
+    assert "Failed to create scheduled task: create error" in str(exc)
+
+
+def test_delete_scheduled_task(mcp, mocker):
+    schedule_tools.register_schedule_tools(mcp)
+    mock_schedule = mocker.patch("tools.schedule.Schedule", autospec=True)
+    mock_schedule.return_value.delete.return_value = True
+    result = mcp.call_tool("delete_scheduled_task", {"task_id": 1})
+    mock_schedule.return_value.delete.assert_called_with(1)
+    assert result is True
+
+
+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:
+        mcp.call_tool("delete_scheduled_task", {"task_id": 1})
+    assert "Failed to delete scheduled task: delete error" in str(exc)
+
+
+def test_get_scheduled_task(mcp, mocker):
+    schedule_tools.register_schedule_tools(mcp)
+    mock_schedule = mocker.patch("tools.schedule.Schedule", autospec=True)
+    mock_schedule.return_value.get_specs.return_value = {"id": 1, "command": "ls"}
+    result = mcp.call_tool("get_scheduled_task", {"task_id": 1})
+    assert result == {"id": 1, "command": "ls"}
+
+
+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:
+        mcp.call_tool("get_scheduled_task", {"task_id": 1})
+    assert "Failed to get scheduled task: get error" in str(exc)
+
+
+def test_update_scheduled_task(mcp, mocker):
+    schedule_tools.register_schedule_tools(mcp)
+    mock_schedule = mocker.patch("tools.schedule.Schedule", autospec=True)
+    mock_schedule.return_value.update.return_value = {"id": 1, "command": "ls -l"}
+    params = {"command": "ls -l"}
+    result = mcp.call_tool("update_scheduled_task", {"task_id": 1, "params": params})
+    assert result == {"id": 1, "command": "ls -l"}
+
+
+def test_update_scheduled_task_exception(mcp, mocker):
+    schedule_tools.register_schedule_tools(mcp)
+    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:
+        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.1/tests/test_server.py

@@ -0,0 +1,40 @@
+import pytest
+
+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 test_create_server(monkeypatch, mock_FastMCP):
+    monkeypatch.setenv("API_TOKEN", "dummy-token")
+    server.create_server()
+    mock_FastMCP.assert_called_once_with("PythonAnywhere Model Context Protocol Server")
+
+
+@pytest.mark.parametrize(
+    "register_fn", [
+        "register_file_tools",
+        "register_webapp_tools",
+        "register_website_tools",
+        "register_schedule_tools",
+    ]
+)
+def test_register_tools(monkeypatch, mocker, mock_FastMCP, 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)
+
+
+def test_missing_api_token(monkeypatch):
+    monkeypatch.delenv("API_TOKEN", raising=False)
+    with pytest.raises(RuntimeError) as excinfo:
+        server.create_server()
+    assert "API_TOKEN environment variable must be set" in str(excinfo.value)

pythonanywhere_mcp_server-0.0.1/tests/test_webapp_tools.py

@@ -0,0 +1,30 @@
+import pytest
+
+import tools.webapp as webapp_tools
+
+def test_reload_webapp(mcp, mocker):
+    webapp_tools.register_webapp_tools(mcp)
+    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."
+
+
+def test_reload_webapp_auth_error(mcp, mocker):
+    webapp_tools.register_webapp_tools(mcp)
+    mock_webapp = mocker.patch("tools.webapp.Webapp", autospec=True)
+    from pythonanywhere_core.base import AuthenticationError
+    mock_webapp.return_value.reload.side_effect = AuthenticationError()
+    with pytest.raises(RuntimeError) as exc:
+        mcp.call_tool("reload_webapp", {"domain": "test.com"})
+    assert "Authentication failed" in str(exc)
+
+
+def test_reload_webapp_other_error(mcp, mocker):
+    webapp_tools.register_webapp_tools(mcp)
+    mock_webapp = mocker.patch("tools.webapp.Webapp", autospec=True)
+    mock_webapp.return_value.reload.side_effect = Exception("webapp reload error")
+    with pytest.raises(RuntimeError) as exc:
+        mcp.call_tool("reload_webapp", {"domain": "test.com"})
+    assert "webapp reload error" in str(exc)

pythonanywhere_mcp_server-0.0.1/tests/test_website_tools.py

@@ -0,0 +1,86 @@
+import pytest
+
+import tools.website as website_tools
+
+
+def test_list_websites(mcp, mocker):
+    website_tools.register_website_tools(mcp)
+    mock_website = mocker.patch("tools.website.Website", autospec=True)
+    mock_website.return_value.list.return_value = [
+        {"domain": "test.com", "status": "running"}
+    ]
+    result = mcp.call_tool("list_websites", {})
+    assert result == [{"domain": "test.com", "status": "running"}]
+
+
+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:
+        mcp.call_tool("list_websites", {})
+    assert "Failed to list websites: list error" in str(exc)
+
+
+def test_create_website(mcp, mocker):
+    website_tools.register_website_tools(mcp)
+    mock_website = mocker.patch("tools.website.Website", autospec=True)
+    mock_website.return_value.create.return_value = {"domain": "test.com", "status": "created"}
+    params = {"domain_name": "test.com", "command": "run.sh"}
+    result = mcp.call_tool("create_website", params)
+    assert result == {"domain": "test.com", "status": "created"}
+
+
+def test_create_website_exception(mcp, mocker):
+    website_tools.register_website_tools(mcp)
+    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:
+        mcp.call_tool("create_website", params)
+    assert "Failed to create website: create error" in str(exc)
+
+
+def test_delete_website(mcp, mocker):
+    website_tools.register_website_tools(mcp)
+    mock_website = mocker.patch("tools.website.Website", autospec=True)
+    mock_website.return_value.delete.return_value = True
+    result = mcp.call_tool("delete_website", {"domain_name": "test.com"})
+    mock_website.return_value.delete.assert_called_with("test.com")
+    assert result is True
+
+
+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:
+        mcp.call_tool("delete_website", {"domain_name": "test.com"})
+    assert "Failed to delete website: delete error" in str(exc)
+
+
+def test_reload_website(mcp, mocker):
+    website_tools.register_website_tools(mcp)
+    mock_website = mocker.patch("tools.website.Website", autospec=True)
+    result = mcp.call_tool("reload_website", {"domain": "test.com"})
+    mock_website.return_value.reload.assert_called_with("test.com")
+    assert result == "Website 'test.com' reloaded."
+
+
+def test_reload_website_auth_error(mcp, mocker):
+    website_tools.register_website_tools(mcp)
+    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:
+        mcp.call_tool("reload_website", {"domain": "test.com"})
+    assert "Authentication failed" in str(exc)
+
+
+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:
+        mcp.call_tool("reload_website", {"domain": "test.com"})
+    assert "website reload error" in str(exc)