[ROB-2694] Oauth

.gitignore

@@ -2,6 +2,7 @@
 tmp/
 config.yaml
 checks.yaml
+.claude/skills/dev-skills/
 
 # Byte-compiled / optimized / DLL files
 __pycache__/

conftest.py

@@ -293,3 +293,14 @@ def responses():
         rsps.add_passthru("https://www.google.com")
         rsps.add_passthru("https://www.burgergooglenetworkspam.co.uk")
         yield rsps
+
+
+def pytest_collection_modifyitems(config, items):
+    """Auto-skip tests marked with @pytest.mark.manual unless explicitly requested."""
+    markexpr = config.getoption("-m", default="")
+    if "manual" in markexpr:
+        return  # User explicitly requested manual tests
+    skip_manual = pytest.mark.skip(reason="Manual test — run with: pytest -m manual")
+    for item in items:
+        if "manual" in item.keywords:
+            item.add_marker(skip_manual)

docs/data-sources/.nav.yml

@@ -6,4 +6,5 @@ nav:
   - Database Connectors: database-connectors.md
   - Custom Toolsets: custom-toolsets.md
   - MCP Servers: remote-mcp-servers.md
+  - OAuth MCP Servers (Alpha): oauth-mcp-servers.md
   - HTTP Header Propagation: header-propagation.md

docs/data-sources/oauth-mcp-servers.md

@@ -0,0 +1,90 @@
+# OAuth MCP Servers
+
+!!! warning "Alpha Feature"
+    OAuth MCP server support is a new feature and will experience rapid improvements. Configuration and behavior may change between releases.
+
+Some MCP servers support OAuth-based authentication natively — you only need to set `oauth.enabled: true` and Holmes handles the rest. When Holmes connects to an OAuth-enabled MCP server, it automatically discovers the server's OAuth endpoints, opens a browser for login, and persists the token for future use.
+
+## Setup
+
+To add an OAuth MCP server, set `mode: streamable-http` and `oauth.enabled: true` in the server's config:
+
+=== "Robusta CLI"
+
+    Set the `CUSTOM_TOOLSET_LOCATION` environment variable pointing to a YAML file with your MCP server configuration:
+
+    ```bash
+    export CUSTOM_TOOLSET_LOCATION=/Users/.../custom_toolset.yaml
+    ```
+
+    In that file, define your OAuth MCP servers:
+
+    ```yaml
+    toolsets:
+      # ... your toolsets
+
+    mcp_servers:
+      my-server:
+        description: "Description of the MCP server"
+        config:
+          mode: streamable-http
+          url: https://example.com/mcp
+          oauth:
+            enabled: true
+    ```
+
+=== "Robusta Helm Chart with Platform"
+
+    Add the MCP servers to your `generated_values.yaml`. Make sure `enableHolmesGPT` is set to `true` and SaaS is enabled:
+
+    ```yaml
+    holmes:
+      mcp_servers:
+        my-server:
+          description: "Description of the MCP server"
+          config:
+            mode: streamable-http
+            url: https://example.com/mcp
+            oauth:
+              enabled: true
+    ```
+
+    ```bash
+    helm upgrade robusta robusta/robusta --values=generated_values.yaml --set clusterName=<YOUR_CLUSTER_NAME>
+    ```
+
+## Example: Atlassian
+
+=== "Robusta CLI"
+
+    ```yaml
+    mcp_servers:
+      atlassian:
+        description: "Atlassian Jira + Confluence MCP server"
+        config:
+          mode: streamable-http
+          url: https://mcp.atlassian.com/v1/mcp
+          oauth:
+            enabled: true
+    ```
+
+=== "Robusta Helm Chart with Platform"
+
+    ```yaml
+    holmes:
+      mcp_servers:
+        atlassian:
+          config:
+            mode: streamable-http
+            url: https://mcp.atlassian.com/v1/mcp
+            oauth:
+              enabled: true
+    ```
+
+## How It Works
+
+1. Holmes detects that the MCP server has `oauth.enabled: true`
+2. Holmes discovers the server's OAuth configuration automatically via the MCP protocol
+3. The user is prompted to authenticate via their browser
+4. After login, Holmes exchanges the authorization code for an access token
+5. The token is persisted and refreshed automatically — users only need to authenticate once

docs/data-sources/remote-mcp-servers.md

@@ -346,6 +346,10 @@ SSE transport is deprecated. Use `streamable-http` for new integrations.
 
 The URL should end with `/sse`. If it doesn't, HolmesGPT will automatically append it.
 
+## OAuth Authentication
+
+For MCP servers that require OAuth authentication (e.g. Atlassian, Notion), see the dedicated [OAuth MCP Servers](oauth-mcp-servers.md) page.
+
 ## Advanced Configuration
 
 **Dynamic Headers with Request Context**

holmes/common/env_vars.py

@@ -8,6 +8,9 @@
 RECOMMENDED_OPENAI_MODEL = "gpt-4.1"
 RECOMMENDED_ANTHROPIC_MODEL = "anthropic/claude-opus-4-1-20250805"
 
+# Default user_id for CLI mode (no authenticated user)
+DEFAULT_CLI_USER = "__no_user__"
+
 # Default model for HolmesGPT
 DEFAULT_MODEL = RECOMMENDED_OPENAI_MODEL
 FALLBACK_CONTEXT_WINDOW_SIZE = (

holmes/config.py

@@ -18,7 +18,6 @@
     SecretStr,
 )
 
-from holmes.common.env_vars import ROBUSTA_CONFIG_PATH
 from holmes.core.init_event import EventCallback, StatusEvent, StatusEventKind
 from holmes.core.llm import DefaultLLM, LLMModelRegistry
 from holmes.core.tools import PrerequisiteCacheMode, Toolset, ToolsetTag
@@ -41,10 +40,13 @@
     from holmes.plugins.sources.prometheus.plugin import AlertManagerSource
 
 from holmes.core.config import config_path_dir
+from holmes.core.oauth_utils import eager_load_oauth_tools, preload_oauth_tokens, set_oauth_dal
 from holmes.core.supabase_dal import SupabaseDal
 from holmes.utils.definitions import RobustaConfig
 from holmes.utils.pydantic_utils import RobustaBaseConfig, load_model_from_file
 
+
+
 DEFAULT_CONFIG_LOCATION = os.path.join(config_path_dir, "config.yaml")
 
 
@@ -256,24 +258,28 @@ def load_from_env(cls):
         result.log_useful_info()
         return result
 
+    @staticmethod
+    def get_robusta_global_config_value(key: str) -> Optional[str]:
+        """Read a value from Robusta's global_config. Returns None in CLI mode or on error."""
+        from holmes.common.env_vars import ROBUSTA_CONFIG_PATH
+
+        if not os.path.exists(ROBUSTA_CONFIG_PATH):
+            return None
+        try:
+            with open(ROBUSTA_CONFIG_PATH) as f:
+                yaml_content = yaml.safe_load(f)
+                config = RobustaConfig(**yaml_content)
+                return config.global_config.get(key)
+        except Exception:
+            logging.warning("Failed to load '%s' from Robusta config", key, exc_info=True)
+            return None
+
     @staticmethod
     def __get_cluster_name() -> Optional[str]:
-        config_file_path = ROBUSTA_CONFIG_PATH
         env_cluster_name = os.environ.get("CLUSTER_NAME")
         if env_cluster_name:
             return env_cluster_name
-
-        if not os.path.exists(config_file_path):
-            logging.info(f"No robusta config in {config_file_path}")
-            return None
-
-        logging.info(f"loading config {config_file_path}")
-        with open(config_file_path) as file:
-            yaml_content = yaml.safe_load(file)
-            config = RobustaConfig(**yaml_content)
-            return config.global_config.get("cluster_name")
-
-        return None
+        return Config.get_robusta_global_config_value("cluster_name")
 
     def get_runbook_catalog(self) -> Optional[RunbookCatalog]:
         runbook_catalog = load_runbook_catalog(
@@ -354,6 +360,9 @@ def create_tool_executor(
         tags = toolset_tag_filter or [ToolsetTag.CORE]
         cache_key = self._executor_cache_key(tags, enable_all_toolsets_possible)
 
+        # Make DAL available for OAuth cross-cluster token storage
+        set_oauth_dal(dal)
+
         if reuse_executor:
             with self._executor_lock:
                 if (
@@ -373,6 +382,9 @@ def create_tool_executor(
                 executor = ToolExecutor(toolsets, on_event=on_event)
                 self._cached_tool_executor = executor
                 self._cached_executor_key = cache_key
+
+                preload_oauth_tokens()
+                eager_load_oauth_tools(executor)
                 return executor
 
         toolsets = self.toolset_manager.prepare_toolsets(
@@ -382,7 +394,10 @@ def create_tool_executor(
             prerequisite_cache=prerequisite_cache,
             on_event=on_event,
         )
-        return ToolExecutor(toolsets, on_event=on_event)
+        preload_oauth_tokens()
+        executor = ToolExecutor(toolsets, on_event=on_event)
+        eager_load_oauth_tools(executor)
+        return executor
 
     def refresh_tool_executor(
         self,
@@ -429,7 +444,10 @@ def refresh_tool_executor(
 
         if changes:
             with self._executor_lock:
-                self._cached_tool_executor = ToolExecutor(new_toolsets)
+                executor = ToolExecutor(new_toolsets)
+                preload_oauth_tokens()
+                eager_load_oauth_tools(executor)
+                self._cached_tool_executor = executor
                 self._cached_executor_key = cache_key
 
         return [(name, old.value, new.value) for name, old, new in changes]

holmes/core/models.py

@@ -123,6 +123,22 @@ class ToolApprovalDecision(BaseModel):
     approved: bool
     save_prefixes: Optional[List[str]] = None  # Prefixes to remember for session
     feedback: Optional[str] = None  # User feedback when denying a tool call
+    decision: Optional[Dict[str, Any]] = None  # Structured decision data (e.g. OAuth callback)
+
+
+class OAuthCallbackRequest(BaseModel):
+    toolset_name: str
+    code: str
+    code_verifier: Optional[str] = None  # Optional: frontend provides when it generated PKCE, Holmes provides when it generated PKCE
+    redirect_uri: str
+    client_id: Optional[str] = None
+    client_secret: Optional[str] = None  # Required by some IdPs (e.g. Supabase) that don't support public clients
+    user_id: Optional[str] = None
+
+
+class OAuthCallbackResponse(BaseModel):
+    success: bool
+    error: Optional[str] = None
 
 
 class FrontendToolMode(str, Enum):
@@ -195,6 +211,7 @@ class ChatRequestBaseModel(BaseModel):
     trace_span: Optional[Any] = (
         None  # Optional span for tracing and heartbeat callbacks
     )
+    user_id: Optional[str] = None  # User ID from relay session token validation
 
     # In our setup with litellm, the first message in conversation_history
     # should follow the structure [{"role": "system", "content": ...}],