rootly-mcp-server 2.2.20__tar.gz → 2.2.22__tar.gz

{rootly_mcp_server-2.2.20 → rootly_mcp_server-2.2.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rootly-mcp-server
-Version: 2.2.20
+Version: 2.2.22
 Summary: Secure Model Context Protocol server for Rootly APIs with AI SRE capabilities, comprehensive error handling, and input validation
 Project-URL: Homepage, https://github.com/Rootly-AI-Labs/Rootly-MCP-server
 Project-URL: Issues, https://github.com/Rootly-AI-Labs/Rootly-MCP-server/issues
@@ -334,7 +334,8 @@ A **Global API Key** is recommended for organization-wide queries and for action
         "rootly-mcp-server"
       ],
       "env": {
-        "ROOTLY_API_TOKEN": "<YOUR_ROOTLY_API_TOKEN>"
+        "ROOTLY_API_TOKEN": "<YOUR_ROOTLY_API_TOKEN>",
+        "ROOTLY_MCP_ENABLE_WRITE_TOOLS": "true"
       }
     }
   }
@@ -349,12 +350,51 @@ Choose one transport per server process:
 - **SSE** endpoint path: `/sse`
 - **Code Mode (experimental)** endpoint path: `/mcp-codemode` in hosted dual-transport mode
 
+Both hosted and self-hosted deployments expose all tools by default (read and write) for consistency. To restrict to read-only tools, start the server with `--no-enable-write-tools` or set `ROOTLY_MCP_ENABLE_WRITE_TOOLS=false`.
+
+To expose only a specific subset of MCP tools on a self-hosted deployment, set `ROOTLY_MCP_ENABLED_TOOLS` (or pass `--enabled-tools`) with a comma-separated allowlist of exact tool names, for example `list_incidents,getIncident,get_server_version`.
+
+To discover the exact tool names available under your current self-hosted configuration, run:
+
+```bash
+ROOTLY_API_TOKEN=<YOUR_ROOTLY_API_TOKEN> \
+uv run python -m rootly_mcp_server --list-tools
+```
+
+This prints the effective MCP tool names after applying your current settings, including `ROOTLY_MCP_ENABLE_WRITE_TOOLS` and `ROOTLY_MCP_ENABLED_TOOLS`.
+
+Smoke-test a self-hosted allowlist:
+
+```bash
+ROOTLY_API_TOKEN=<YOUR_ROOTLY_API_TOKEN> \
+ROOTLY_MCP_ENABLED_TOOLS=list_incidents,getIncident,get_server_version \
+uv run python -m rootly_mcp_server --transport streamable-http --log-level ERROR
+```
+
+Then connect an MCP client to `http://127.0.0.1:8000/mcp` and verify `tools/list` returns only:
+
+```text
+get_server_version
+getIncident
+list_incidents
+```
+
+To include specific write tools for self-hosted testing, add both the write flag and the allowlist:
+
+```bash
+ROOTLY_API_TOKEN=<YOUR_ROOTLY_API_TOKEN> \
+ROOTLY_MCP_ENABLE_WRITE_TOOLS=true \
+ROOTLY_MCP_ENABLED_TOOLS=createIncident,createWorkflowTask,listTeams \
+uv run python -m rootly_mcp_server --transport streamable-http --log-level ERROR
+```
+
 Example Docker run (Streamable HTTP):
 
 ```bash
 docker run -p 8000:8000 \
   -e ROOTLY_TRANSPORT=streamable-http \
   -e ROOTLY_API_TOKEN=<YOUR_ROOTLY_API_TOKEN> \
+  -e ROOTLY_MCP_ENABLE_WRITE_TOOLS=true \
   rootly-mcp-server
 ```
 

{rootly_mcp_server-2.2.20 → rootly_mcp_server-2.2.22}/README.md

@@ -290,7 +290,8 @@ A **Global API Key** is recommended for organization-wide queries and for action
         "rootly-mcp-server"
       ],
       "env": {
-        "ROOTLY_API_TOKEN": "<YOUR_ROOTLY_API_TOKEN>"
+        "ROOTLY_API_TOKEN": "<YOUR_ROOTLY_API_TOKEN>",
+        "ROOTLY_MCP_ENABLE_WRITE_TOOLS": "true"
       }
     }
   }
@@ -305,12 +306,51 @@ Choose one transport per server process:
 - **SSE** endpoint path: `/sse`
 - **Code Mode (experimental)** endpoint path: `/mcp-codemode` in hosted dual-transport mode
 
+Both hosted and self-hosted deployments expose all tools by default (read and write) for consistency. To restrict to read-only tools, start the server with `--no-enable-write-tools` or set `ROOTLY_MCP_ENABLE_WRITE_TOOLS=false`.
+
+To expose only a specific subset of MCP tools on a self-hosted deployment, set `ROOTLY_MCP_ENABLED_TOOLS` (or pass `--enabled-tools`) with a comma-separated allowlist of exact tool names, for example `list_incidents,getIncident,get_server_version`.
+
+To discover the exact tool names available under your current self-hosted configuration, run:
+
+```bash
+ROOTLY_API_TOKEN=<YOUR_ROOTLY_API_TOKEN> \
+uv run python -m rootly_mcp_server --list-tools
+```
+
+This prints the effective MCP tool names after applying your current settings, including `ROOTLY_MCP_ENABLE_WRITE_TOOLS` and `ROOTLY_MCP_ENABLED_TOOLS`.
+
+Smoke-test a self-hosted allowlist:
+
+```bash
+ROOTLY_API_TOKEN=<YOUR_ROOTLY_API_TOKEN> \
+ROOTLY_MCP_ENABLED_TOOLS=list_incidents,getIncident,get_server_version \
+uv run python -m rootly_mcp_server --transport streamable-http --log-level ERROR
+```
+
+Then connect an MCP client to `http://127.0.0.1:8000/mcp` and verify `tools/list` returns only:
+
+```text
+get_server_version
+getIncident
+list_incidents
+```
+
+To include specific write tools for self-hosted testing, add both the write flag and the allowlist:
+
+```bash
+ROOTLY_API_TOKEN=<YOUR_ROOTLY_API_TOKEN> \
+ROOTLY_MCP_ENABLE_WRITE_TOOLS=true \
+ROOTLY_MCP_ENABLED_TOOLS=createIncident,createWorkflowTask,listTeams \
+uv run python -m rootly_mcp_server --transport streamable-http --log-level ERROR
+```
+
 Example Docker run (Streamable HTTP):
 
 ```bash
 docker run -p 8000:8000 \
   -e ROOTLY_TRANSPORT=streamable-http \
   -e ROOTLY_API_TOKEN=<YOUR_ROOTLY_API_TOKEN> \
+  -e ROOTLY_MCP_ENABLE_WRITE_TOOLS=true \
   rootly-mcp-server
 ```
 

{rootly_mcp_server-2.2.20 → rootly_mcp_server-2.2.22}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "rootly-mcp-server"
-version = "2.2.20"
+version = "2.2.22"
 description = "Secure Model Context Protocol server for Rootly APIs with AI SRE capabilities, comprehensive error handling, and input validation"
 readme = "README.md"
 requires-python = ">=3.12"

{rootly_mcp_server-2.2.20 → rootly_mcp_server-2.2.22}/src/rootly_mcp_server/__main__.py

@@ -6,6 +6,7 @@ This module provides the main entry point for the Rootly MCP Server.
 """
 
 import argparse
+import asyncio
 import logging
 import os
 import sys
@@ -22,6 +23,7 @@ from .code_mode import (
 from .exceptions import RootlyConfigurationError, RootlyMCPError
 from .security import validate_api_token
 from .server import create_rootly_mcp_server, get_hosted_auth_middleware
+from .server_defaults import enabled_tools_from_env, write_tools_enabled_from_env
 
 TransportName = Literal["stdio", "sse", "streamable-http", "both"]
 TRANSPORT_ALIASES: dict[str, TransportName] = {
@@ -113,6 +115,23 @@ def parse_args():
         action="store_true",
         help="Expose a separate hosted Code Mode endpoint (HTTP only)",
     )
+    parser.add_argument(
+        "--no-enable-write-tools",
+        dest="enable_write_tools",
+        action="store_false",
+        default=True,
+        help="Disable write tools to expose read-only operations",
+    )
+    parser.add_argument(
+        "--enabled-tools",
+        type=str,
+        help="Comma-separated allowlist of exact MCP tool names to expose",
+    )
+    parser.add_argument(
+        "--list-tools",
+        action="store_true",
+        help="Print the exact MCP tool names exposed by the current configuration, then exit",
+    )
     parser.add_argument(
         "--code-mode-path",
         type=str,
@@ -183,6 +202,8 @@ def get_server():
     hosted = os.getenv("ROOTLY_HOSTED", "false").lower() in ("true", "1", "yes")
     base_url = os.getenv("ROOTLY_BASE_URL")
     transport = normalize_transport_or_default(os.getenv("ROOTLY_TRANSPORT", "stdio"))
+    enable_write_tools = write_tools_enabled_from_env(default=True)
+    enabled_tools = enabled_tools_from_env()
 
     # Parse allowed paths from environment variable
     allowed_paths = None
@@ -198,9 +219,17 @@ def get_server():
         hosted=hosted,
         base_url=base_url,
         transport=transport,
+        enable_write_tools=enable_write_tools,
+        enabled_tools=enabled_tools,
     )
 
 
+async def _get_sorted_tool_names(server) -> list[str]:
+    """Return the effective MCP tool names for the provided server."""
+    tools = await server.list_tools()
+    return sorted(tool.name for tool in tools)
+
+
 # Create the server instance for FastMCP CLI (follows quickstart pattern).
 # Avoid eager construction when executing `python -m rootly_mcp_server`, because
 # CLI flags like `--hosted` and `--transport` are parsed later in `main()`.
@@ -368,11 +397,19 @@ def main():
         allowed_paths = None
         if args.allowed_paths:
             allowed_paths = [path.strip() for path in args.allowed_paths.split(",")]
+        enabled_tools = (
+            {tool.strip() for tool in args.enabled_tools.split(",") if tool.strip()}
+            if args.enabled_tools
+            else enabled_tools_from_env()
+        )
 
         logger.info(f"Initializing server with name: {args.name}")
         # argparse already normalizes/validates --transport via type=normalize_transport
         normalized_transport = args.transport
         code_mode_enabled = args.enable_code_mode or code_mode_enabled_from_env(default=True)
+        enable_write_tools = args.enable_write_tools or write_tools_enabled_from_env(
+            default=hosted_mode
+        )
         code_mode_path = (
             normalize_code_mode_path(args.code_mode_path)
             if args.code_mode_path
@@ -385,8 +422,15 @@ def main():
             hosted=hosted_mode,
             base_url=args.base_url,
             transport=normalized_transport,
+            enable_write_tools=enable_write_tools,
+            enabled_tools=enabled_tools,
         )
 
+        if args.list_tools:
+            for tool_name in asyncio.run(_get_sorted_tool_names(server)):
+                print(tool_name)
+            return
+
         code_mode_server = None
         if code_mode_enabled:
             if not hosted_mode:
@@ -403,6 +447,8 @@ def main():
                     allowed_paths=allowed_paths,
                     hosted=hosted_mode,
                     base_url=args.base_url,
+                    enable_write_tools=enable_write_tools,
+                    enabled_tools=enabled_tools,
                 )
                 logger.info("Code Mode enabled at path: %s", code_mode_path)
 

rootly_mcp_server-2.2.22/src/rootly_mcp_server/audit.py

@@ -0,0 +1,104 @@
+"""Security audit logging for Rootly MCP Server."""
+
+import json
+import logging
+import time
+from contextvars import ContextVar
+from typing import Any
+
+# Context variables for tracking session info
+current_session: ContextVar[str | None] = ContextVar("current_session", default=None)
+current_user: ContextVar[str | None] = ContextVar("current_user", default=None)
+
+
+class AuditLogger:
+    """Structured audit logger for security-relevant events."""
+
+    def __init__(self, logger_name: str = "rootly_mcp_server.audit"):
+        self.logger = logging.getLogger(logger_name)
+        self.logger.setLevel(logging.INFO)
+
+        # JSON formatter for structured logs
+        formatter = logging.Formatter(
+            '{"timestamp": "%(asctime)s", "level": "%(levelname)s", "audit_event": %(message)s}'
+        )
+
+        # Add console handler if none exists
+        if not self.logger.handlers:
+            handler = logging.StreamHandler()
+            handler.setFormatter(formatter)
+            self.logger.addHandler(handler)
+
+    def log_permission_change(self, action: str, details: dict[str, Any]):
+        """Log permission configuration changes."""
+        event = {
+            "event_type": "permission_change",
+            "action": action,
+            "session_id": current_session.get(),
+            "user_id": current_user.get(),
+            "timestamp": time.time(),
+            **details,
+        }
+        self.logger.info(json.dumps(event))
+
+    def log_tool_validation(
+        self, enabled_tools: set[str], valid_tools: set[str], invalid_tools: list[str]
+    ):
+        """Log tool name validation results."""
+        event = {
+            "event_type": "tool_validation",
+            "requested_tools_count": len(enabled_tools),
+            "valid_tools_count": len(valid_tools),
+            "invalid_tools_count": len(invalid_tools),
+            "invalid_tools": invalid_tools,
+            "session_id": current_session.get(),
+            "timestamp": time.time(),
+        }
+        self.logger.info(json.dumps(event))
+
+    def log_server_start(self, config: dict[str, Any]):
+        """Log server startup with security-relevant configuration."""
+        event = {
+            "event_type": "server_start",
+            "write_tools_enabled": config.get("enable_write_tools", True),
+            "tool_count": config.get("tool_count", 0),
+            "hosted_mode": config.get("hosted", False),
+            "allowlist_enabled": bool(config.get("enabled_tools")),
+            "transport": config.get("transport", "unknown"),
+            "timestamp": time.time(),
+        }
+        self.logger.info(json.dumps(event))
+
+    def log_tool_access_attempt(
+        self, tool_name: str, method: str, success: bool, details: dict[str, Any] | None = None
+    ):
+        """Log individual tool access attempts."""
+        event = {
+            "event_type": "tool_access",
+            "tool_name": tool_name,
+            "http_method": method,
+            "success": success,
+            "session_id": current_session.get(),
+            "user_id": current_user.get(),
+            "timestamp": time.time(),
+            **(details or {}),
+        }
+        self.logger.info(json.dumps(event))
+
+    def log_configuration_error(
+        self, error_type: str, message: str, details: dict[str, Any] | None = None
+    ):
+        """Log configuration validation errors."""
+        event = {
+            "event_type": "configuration_error",
+            "error_type": error_type,
+            "message": message,
+            "session_id": current_session.get(),
+            "timestamp": time.time(),
+            **(details or {}),
+        }
+        self.logger.warning(json.dumps(event))
+
+
+# Global audit logger instance
+audit = AuditLogger()

{rootly_mcp_server-2.2.20 → rootly_mcp_server-2.2.22}/src/rootly_mcp_server/code_mode.py

@@ -280,6 +280,8 @@ def create_rootly_codemode_server(
     allowed_paths: list[str] | None = None,
     hosted: bool = False,
     base_url: str | None = None,
+    enable_write_tools: bool | None = None,
+    enabled_tools: set[str] | None = None,
 ) -> FastMCP:
     """Create a Rootly MCP server instance wrapped with Code Mode."""
     mcp: FastMCP = create_rootly_mcp_server(
@@ -289,6 +291,8 @@ def create_rootly_codemode_server(
         hosted=hosted,
         base_url=base_url,
         transport="streamable-http",
+        enable_write_tools=enable_write_tools,
+        enabled_tools=enabled_tools,
     )
     mcp.add_transform(build_code_mode_transform())
     return mcp

{rootly_mcp_server-2.2.20 → rootly_mcp_server-2.2.22}/src/rootly_mcp_server/server.py

@@ -17,7 +17,7 @@ import fastmcp.server.middleware as fastmcp_middleware
 import mcp.types as mt
 from fastmcp import FastMCP
 
-from . import legacy_server, payload_stripping, server_defaults, spec_transform, transport
+from . import audit, legacy_server, payload_stripping, server_defaults, spec_transform, transport
 from .exceptions import RootlyAuthenticationError
 from .mcp_error import MCPError
 from .security import mask_sensitive_data, sanitize_error_message
@@ -66,6 +66,7 @@ strip_heavy_nested_data = payload_stripping.strip_heavy_nested_data
 _generate_recommendation = server_defaults._generate_recommendation
 DEFAULT_ALLOWED_PATHS = server_defaults.DEFAULT_ALLOWED_PATHS
 DEFAULT_DELETE_ALLOWED_PATHS = server_defaults.DEFAULT_DELETE_ALLOWED_PATHS
+DEFAULT_WRITE_ALLOWED_PATHS = server_defaults.DEFAULT_WRITE_ALLOWED_PATHS
 RootlyMCPServer = legacy_server.RootlyMCPServer
 
 
@@ -375,6 +376,9 @@ def create_rootly_mcp_server(
     base_url: str | None = None,
     transport: str = "stdio",
     delete_allowed_paths: list[str] | None = None,
+    enable_write_tools: bool | None = None,
+    write_allowed_paths: list[str] | None = None,
+    enabled_tools: set[str] | None = None,
 ) -> FastMCP:
     """
     Create a Rootly MCP Server using FastMCP's OpenAPI integration.
@@ -384,10 +388,16 @@ def create_rootly_mcp_server(
         name: Name of the MCP server.
         allowed_paths: List of API paths to include. If None, includes default paths.
         delete_allowed_paths: Path templates where DELETE operations are exposed.
-            If None, uses DEFAULT_DELETE_ALLOWED_PATHS.
+            If None, destructive delete tools remain disabled by default.
         hosted: Whether the server is hosted (affects authentication).
         base_url: Base URL for Rootly API. If None, uses ROOTLY_BASE_URL env var or default.
         transport: Transport protocol (stdio, sse, or streamable-http).
+        enable_write_tools: Whether non-destructive write tools are exposed.
+            If None, uses ROOTLY_MCP_ENABLE_WRITE_TOOLS.
+        write_allowed_paths: Path templates where POST/PUT/PATCH operations are exposed
+            when write tools are enabled. If None, uses DEFAULT_WRITE_ALLOWED_PATHS.
+        enabled_tools: Optional allowlist of exact MCP tool names to expose.
+            If None, uses ROOTLY_MCP_ENABLED_TOOLS when set.
 
     Returns:
         A FastMCP server instance.
@@ -395,8 +405,14 @@ def create_rootly_mcp_server(
     # Set default allowed paths if none provided
     if allowed_paths is None:
         allowed_paths = DEFAULT_ALLOWED_PATHS
+    if enable_write_tools is None:
+        enable_write_tools = server_defaults.write_tools_enabled_from_env(default=True)
+    if enabled_tools is None:
+        enabled_tools = server_defaults.enabled_tools_from_env()
     if delete_allowed_paths is None:
-        delete_allowed_paths = DEFAULT_DELETE_ALLOWED_PATHS
+        delete_allowed_paths = []
+    if write_allowed_paths is None:
+        write_allowed_paths = DEFAULT_WRITE_ALLOWED_PATHS if enable_write_tools else []
 
     # Add /v1 prefix to paths if not present
     allowed_paths_v1 = [
@@ -405,6 +421,9 @@ def create_rootly_mcp_server(
     delete_allowed_paths_v1 = [
         f"/v1{path}" if not path.startswith("/v1") else path for path in delete_allowed_paths
     ]
+    write_allowed_paths_v1 = [
+        f"/v1{path}" if not path.startswith("/v1") else path for path in write_allowed_paths
+    ]
 
     logger.info(f"Creating Rootly MCP Server with allowed paths: {allowed_paths_v1}")
 
@@ -417,9 +436,73 @@ def create_rootly_mcp_server(
         swagger_spec,
         allowed_paths_v1,
         delete_allowed_paths=delete_allowed_paths_v1,
+        write_allowed_paths=write_allowed_paths_v1,
+        enable_write_tools=enable_write_tools,
+        enabled_operation_ids=enabled_tools,
     )
+
+    # Validate enabled tools against the filtered spec (after path filtering)
+    if enabled_tools:
+        valid_tools, invalid_tools = server_defaults.validate_tool_names(
+            enabled_tools, filtered_spec.get("paths", {})
+        )
+
+        if invalid_tools:
+            audit.audit.log_configuration_error(
+                "invalid_tool_names",
+                f"Invalid tool names in allowlist after filtering: {', '.join(invalid_tools)}",
+                {"invalid_tools": invalid_tools, "valid_tools": list(valid_tools)},
+            )
+            logger.warning(
+                "Invalid tool names in allowlist (will be ignored): %s. "
+                "Use --list-tools to see available options.",
+                ", ".join(sorted(invalid_tools)),
+            )
+
+        if not valid_tools and enabled_tools:
+            error_msg = "No valid tools found in allowlist after path filtering"
+            audit.audit.log_configuration_error(
+                "no_valid_tools", error_msg, {"requested_tools": list(enabled_tools)}
+            )
+            raise ValueError(error_msg)
+
+        # Log validation results
+        audit.audit.log_tool_validation(enabled_tools, valid_tools, invalid_tools)
+
+        # Update the filtered spec to only include valid tools
+        if valid_tools != enabled_tools:
+            filtered_spec = _filter_openapi_spec(
+                swagger_spec,
+                allowed_paths_v1,
+                delete_allowed_paths=delete_allowed_paths_v1,
+                write_allowed_paths=write_allowed_paths_v1,
+                enable_write_tools=enable_write_tools,
+                enabled_operation_ids=valid_tools,
+            )
     logger.info(f"Filtered spec to {len(filtered_spec.get('paths', {}))} allowed paths")
 
+    # Log server configuration for audit trail
+    config_info = {
+        "enable_write_tools": enable_write_tools,
+        "tool_count": len(filtered_spec.get("paths", {})),
+        "hosted": hosted,
+        "enabled_tools": list(enabled_tools) if enabled_tools else None,
+        "transport": transport,
+        "server_name": name,
+    }
+    audit.audit.log_server_start(config_info)
+
+    # Log permission changes
+    if enable_write_tools:
+        audit.audit.log_permission_change(
+            "write_tools_enabled",
+            {
+                "reason": "explicit_configuration",
+                "write_paths_count": len(write_allowed_paths_v1),
+                "hosted_mode": hosted,
+            },
+        )
+
     # Sanitize all parameter names in the filtered spec to be MCP-compliant
     parameter_mapping = sanitize_parameters_in_spec(filtered_spec)
     logger.info(
@@ -559,6 +642,7 @@ def create_rootly_mcp_server(
         strip_heavy_nested_data=strip_heavy_nested_data,
         mcp_error=MCPError,
         generate_recommendation=_generate_recommendation,
+        enable_write_tools=enable_write_tools,
     )
 
     register_oncall_tools(
@@ -580,6 +664,20 @@ def create_rootly_mcp_server(
         mcp_error=MCPError,
     )
 
+    if enabled_tools is not None:
+        component_names = [
+            component.name
+            for component_key, component in mcp._local_provider._components.items()  # noqa: SLF001
+            if component_key.startswith("tool:") and getattr(component, "name", None)
+        ]
+        for tool_name in component_names:
+            if tool_name not in enabled_tools:
+                mcp.local_provider.remove_tool(tool_name)
+        logger.info(
+            "Applied MCP tool allowlist: %s",
+            ", ".join(sorted(enabled_tools)),
+        )
+
     # In hosted HTTP modes, configure ASGI middleware for auth token capture.
     # Callers retrieve via get_hosted_auth_middleware() and pass to server.run(middleware=...).
     global _hosted_auth_middleware

{rootly_mcp_server-2.2.20 → rootly_mcp_server-2.2.22}/src/rootly_mcp_server/server_defaults.py

@@ -2,6 +2,36 @@
 
 from __future__ import annotations
 
+import logging
+import os
+
+# Set up logger
+logger = logging.getLogger(__name__)
+
+
+# Environment variable constants
+class EnvVars:
+    """Centralized environment variable names for type safety and IDE support."""
+
+    API_TOKEN = "ROOTLY_API_TOKEN"  # nosec B105 - Environment variable name, not password
+    BASE_URL = "ROOTLY_BASE_URL"
+    SERVER_NAME = "ROOTLY_SERVER_NAME"
+    HOSTED = "ROOTLY_HOSTED"
+    ENABLE_WRITE_TOOLS = "ROOTLY_MCP_ENABLE_WRITE_TOOLS"
+    ENABLED_TOOLS = "ROOTLY_MCP_ENABLED_TOOLS"
+    TRANSPORT = "ROOTLY_TRANSPORT"
+    ALLOWED_PATHS = "ROOTLY_ALLOWED_PATHS"
+    SWAGGER_PATH = "ROOTLY_SWAGGER_PATH"
+    LOG_LEVEL = "ROOTLY_LOG_LEVEL"
+
+
+def _parse_csv_set(raw: str | None) -> set[str] | None:
+    """Parse a comma-separated environment value into a normalized set."""
+    if raw is None:
+        return None
+    parsed = {item.strip() for item in raw.split(",") if item.strip()}
+    return parsed or None
+
 
 def _generate_recommendation(solution_data: dict) -> str:
     """Generate a high-level recommendation based on solution analysis."""
@@ -41,8 +71,51 @@ def _generate_recommendation(solution_data: dict) -> str:
     )
 
 
+def write_tools_enabled_from_env(default: bool = False) -> bool:
+    """Return whether non-destructive write tools should be exposed."""
+    raw = os.getenv(EnvVars.ENABLE_WRITE_TOOLS)
+    if raw is None:
+        return default
+    return raw.strip().lower() in ("1", "true", "yes", "on")
+
+
+def validate_tool_names(
+    enabled_tools: set[str], available_operations: dict
+) -> tuple[set[str], list[str]]:
+    """
+    Validate tool names against available OpenAPI operations.
+
+    Args:
+        enabled_tools: Set of tool names to validate
+        available_operations: OpenAPI paths dict from swagger spec
+
+    Returns:
+        tuple: (valid_tools, invalid_tools)
+    """
+    if not enabled_tools:
+        return set(), []
+
+    # Extract all available operation IDs from OpenAPI spec
+    available_tool_names = set()
+    for path_data in available_operations.values():
+        for method_data in path_data.values():
+            if isinstance(method_data, dict) and (operation_id := method_data.get("operationId")):
+                available_tool_names.add(operation_id)
+
+    valid_tools = enabled_tools & available_tool_names
+    invalid_tools = list(enabled_tools - available_tool_names)
+
+    return valid_tools, invalid_tools
+
+
+def enabled_tools_from_env() -> set[str] | None:
+    """Return an optional explicit allowlist of MCP tool names to expose."""
+    return _parse_csv_set(os.getenv(EnvVars.ENABLED_TOOLS))
+
+
 # Default allowed API paths
 DEFAULT_ALLOWED_PATHS = [
+    "/incidents",
     "/incidents/{incident_id}/alerts",
     "/alerts",
     "/alerts/{id}",
@@ -109,6 +182,17 @@ DEFAULT_ALLOWED_PATHS = [
     "/on_call_roles/{on_call_role_id}",
 ]
 
+# Non-destructive write operations are only exposed for these path families when
+# write tools are explicitly enabled. This keeps the default surface focused on
+# read-only workflows and avoids exposing broader admin/config writes.
+DEFAULT_WRITE_ALLOWED_PATHS = [
+    "/incidents/{incident_id}/action_items",
+    "/incidents/{incident_id}/form_field_selections",
+    "/incident_form_field_selections/{id}",
+    "/workflows/{workflow_id}/workflow_tasks",
+    "/workflow_tasks/{id}",
+]
+
 # DELETE operations are only exposed for these high-priority screenshot families.
 # All other DELETE operations remain disabled in MCP by default.
 DEFAULT_DELETE_ALLOWED_PATHS = [