cycode 3.25.1.dev6__py3-none-any.whl → 3.25.2.dev2__py3-none-any.whl

cycode/cli/apps/ai_guardrails/ides/codex.py

@@ -2,9 +2,11 @@
 
 import json
 import os
+import re
 import sys
+from collections.abc import Iterator
 from pathlib import Path
-from typing import ClassVar, Optional
+from typing import ClassVar
 
 import tomli_w
 
@@ -15,7 +17,7 @@ else:  # pragma: no cover - py<3.11 fallback
 
 from cycode.cli.apps.ai_guardrails.consts import CYCODE_SCAN_PROMPT_COMMAND, CYCODE_SESSION_START_COMMAND
 from cycode.cli.apps.ai_guardrails.ides._plugin_utils import (
-    build_global_config_file,
+    build_global_config_files,
     load_plugin_json,
     resolve_cached_plugin_dir,
     walk_enabled_plugins,
@@ -59,14 +61,14 @@ def _codex_skills_dir() -> Path:
     return _codex_home() / 'skills'
 
 
-def _codex_config_toml_path(scope: str, repo_path: Optional[Path] = None) -> Path:
+def _codex_config_toml_path(scope: str, repo_path: Path | None = None) -> Path:
     """Return the Codex ``config.toml`` path for the given scope."""
     if scope == 'repo' and repo_path:
         return repo_path / _CONFIG_DIR_NAME / _CONFIG_TOML_NAME
     return _codex_home() / _CONFIG_TOML_NAME
 
 
-def _load_codex_config(config_path: Optional[Path] = None) -> Optional[dict]:
+def _load_codex_config(config_path: Path | None = None) -> dict | None:
     """Load and parse Codex's ``config.toml``. Returns None on missing/invalid."""
     path = config_path or (_codex_home() / _CONFIG_TOML_NAME)
     if not path.exists():
@@ -80,7 +82,7 @@ def _load_codex_config(config_path: Optional[Path] = None) -> Optional[dict]:
         return None
 
 
-def _email_from_auth(auth_path: Optional[Path] = None) -> Optional[str]:
+def _email_from_auth(auth_path: Path | None = None) -> str | None:
     """Best-effort extraction of the signed-in Codex user's email.
 
     Reads ``~/.codex/auth.json`` and decodes the JWT in ``tokens.id_token``
@@ -106,7 +108,7 @@ def _email_from_auth(auth_path: Optional[Path] = None) -> Optional[str]:
     return claims.get('email')
 
 
-def _resolve_codex_plugin_dir(plugin_name: str, marketplace: str) -> Optional[Path]:
+def _resolve_codex_plugin_dir(plugin_name: str, marketplace: str) -> Path | None:
     """Find ``~/.codex/plugins/cache/<marketplace>/<plugin>/<hash>/``."""
     return resolve_cached_plugin_dir(_codex_home() / 'plugins' / 'cache', marketplace, plugin_name)
 
@@ -158,7 +160,43 @@ def _resolve_codex_plugins(config: dict) -> dict:
     )
 
 
-def _enable_codex_hooks_feature(scope: str, repo_path: Optional[Path] = None) -> tuple[bool, str]:
+def _sanitize_mcp_name(name: str) -> str:
+    """Mirrors how Codex sanitizes a server name into a tool namespace."""
+    return re.sub(r'[^A-Za-z0-9_]', '_', name) or '_'
+
+
+def _local_mcp_server_names() -> Iterator[str]:
+    """Yield the config key of each locally configured Codex MCP server, plugin servers included."""
+    config = _load_codex_config()
+    if not config:
+        return
+    servers = config.get('mcp_servers')
+    if isinstance(servers, dict):
+        yield from servers
+    for entry in _resolve_codex_plugins(config).values():
+        yield from entry.get('mcp_server_names') or []
+
+
+def _split_mcp_tool_name(tool_name: str) -> tuple[str | None, str | None]:
+    """Split ``mcp__<namespace>__<tool>`` into ``(server config key, tool)``; unknown namespaces split on ``__``."""
+    rest = tool_name[len('mcp__') :]
+    names = list(_local_mcp_server_names())
+    # Codex appends `_<12 hex>` to a namespace on collision or length overflow.
+    for suffix in ('__', r'_+[0-9a-f]{12}__'):
+        best: tuple[int, str] | None = None
+        for name in names:
+            namespace = _sanitize_mcp_name(name).rstrip('_')
+            match = namespace and re.match(re.escape(namespace) + suffix, rest)
+            if match and (best is None or match.end() > best[0]):
+                best = (match.end(), name)
+        if best:
+            return best[1], rest[best[0] :]
+
+    parts = tool_name.split('__')
+    return (parts[1] if len(parts) >= 2 else None), (parts[2] if len(parts) >= 3 else None)
+
+
+def _enable_codex_hooks_feature(scope: str, repo_path: Path | None = None) -> tuple[bool, str]:
     """Set ``[features] hooks = true`` in Codex's ``config.toml``.
 
     Codex's hook scripts are gated behind this feature flag. We preserve any
@@ -196,7 +234,7 @@ class Codex(IDE):
     display_name: ClassVar[str] = 'Codex'
     hook_events: ClassVar[list[str]] = list(_HOOK_EVENTS)
 
-    def settings_path(self, scope: str, repo_path: Optional[Path] = None) -> Path:
+    def settings_path(self, scope: str, repo_path: Path | None = None) -> Path:
         if scope == 'repo' and repo_path:
             return repo_path / _CONFIG_DIR_NAME / _HOOKS_FILE_NAME
         return _codex_home() / _HOOKS_FILE_NAME
@@ -226,7 +264,7 @@ class Codex(IDE):
             },
         }
 
-    def post_install(self, scope: str, repo_path: Optional[Path] = None) -> tuple[bool, str]:
+    def post_install(self, scope: str, repo_path: Path | None = None) -> tuple[bool, str]:
         return _enable_codex_hooks_feature(scope, repo_path)
 
     def matches_payload(self, raw_payload: dict) -> bool:
@@ -247,12 +285,8 @@ class Codex(IDE):
         mcp_server_name = None
         mcp_tool_name = None
         mcp_arguments = None
-        if tool_name.startswith('mcp__'):
-            parts = tool_name.split('__')
-            if len(parts) >= 2:
-                mcp_server_name = parts[1]
-            if len(parts) >= 3:
-                mcp_tool_name = parts[2]
+        if canonical_event == AiHookEventType.MCP_EXECUTION:
+            mcp_server_name, mcp_tool_name = _split_mcp_tool_name(tool_name)
             mcp_arguments = tool_input
 
         return AIHookPayload(
@@ -299,20 +333,20 @@ class Codex(IDE):
             source=raw_payload.get('source'),
         )
 
-    def get_user_email(self) -> Optional[str]:
+    def get_user_email(self) -> str | None:
         return _email_from_auth()
 
-    def get_session_context(self) -> tuple[Optional[dict], dict]:
+    def get_session_context(self) -> tuple[list[dict], dict]:
         config = _load_codex_config()
         if not config:
-            return None, {}
+            return [], {}
         # Codex stores MCP servers under `[mcp_servers.<name>]`; the global config
         # file becomes its own session-context file. Plugins (via
         # `[plugins."<plugin>@<marketplace>"]`) carry their own config files.
         config_path = _codex_config_toml_path('user')
-        global_config_file = build_global_config_file(config_path, config.get('mcp_servers'))
+        global_config_files = build_global_config_files(config_path, config.get('mcp_servers'))
         enriched_plugins = _resolve_codex_plugins(config)
-        return global_config_file, enriched_plugins
+        return global_config_files, enriched_plugins
 
     def get_skills(self) -> list[dict]:
         return walk_skill_dirs(_codex_skills_dir())

cycode/cli/apps/ai_guardrails/ides/copilot.py

@@ -27,13 +27,13 @@ import platform
 import re
 from collections.abc import Iterable
 from pathlib import Path
-from typing import ClassVar, Optional, Union
+from typing import ClassVar
 from urllib.parse import urlparse
 from urllib.request import url2pathname
 
 from cycode.cli.apps.ai_guardrails.consts import CYCODE_SCAN_PROMPT_COMMAND, CYCODE_SESSION_START_COMMAND
 from cycode.cli.apps.ai_guardrails.ides._plugin_utils import (
-    build_global_config_file,
+    build_global_config_files,
     load_plugin_json,
     walk_enabled_plugins,
 )
@@ -131,7 +131,7 @@ def _vscode_mcp_config_path() -> Path:
     return _vscode_user_dir() / _MCP_CONFIG_FILENAME
 
 
-def _load_vscode_mcp_config(config_path: Optional[Path] = None) -> Optional[dict]:
+def _load_vscode_mcp_config(config_path: Path | None = None) -> dict | None:
     """Load and parse VS Code's user-level ``mcp.json``. Returns None if missing/invalid."""
     path = config_path or _vscode_mcp_config_path()
     if not path.exists():
@@ -144,7 +144,7 @@ def _load_vscode_mcp_config(config_path: Optional[Path] = None) -> Optional[dict
         return None
 
 
-def _load_jsonc(path: Path) -> Optional[dict]:
+def _load_jsonc(path: Path) -> dict | None:
     """Parse a JSON file tolerating //-comment lines (Copilot's config.json ships
     with a comment header; VS Code's settings.json is JSONC).
 
@@ -283,6 +283,15 @@ def _collect_installed_plugins() -> dict:
 # --- MCP tool-name splitting ------------------------------------------------------
 
 
+def _global_mcp_server_maps() -> list[tuple[Path, object]]:
+    """``(path, servers)`` of each runtime's global MCP config: VS Code's ``servers``, the agent's ``mcpServers``."""
+    agent_config_path = _copilot_home() / _AGENT_MCP_CONFIG_FILENAME
+    return [
+        (_vscode_mcp_config_path(), (_load_vscode_mcp_config() or {}).get('servers')),
+        (agent_config_path, (_load_jsonc(agent_config_path) or {}).get('mcpServers')),
+    ]
+
+
 def _known_mcp_server_names() -> list[str]:
     """Config-declared MCP server names, across both runtimes' config files.
 
@@ -293,15 +302,7 @@ def _known_mcp_server_names() -> list[str]:
     Best-effort inventory: servers contributed by extensions, ``chat.mcp.discovery``
     imports, dev containers, or non-default profiles are not discoverable from disk.
     """
-    config = _load_vscode_mcp_config()
-    servers = (config or {}).get('servers')
-    names = list(servers.keys()) if isinstance(servers, dict) else []
-
-    agent_config = _load_jsonc(_copilot_home() / _AGENT_MCP_CONFIG_FILENAME) or {}
-    agent_servers = agent_config.get('mcpServers')
-    if isinstance(agent_servers, dict):
-        names.extend(agent_servers.keys())
-
+    names = [name for _, servers in _global_mcp_server_maps() if isinstance(servers, dict) for name in servers]
     for plugin in _collect_installed_plugins().values():
         names.extend(plugin.get('mcp_server_names') or [])
     return names
@@ -320,7 +321,7 @@ def _server_name_variants(server_name: str) -> set[str]:
     return {v for v in (server_name, underscored, collapsed) if v}
 
 
-def _read_file_path(tool_name: str, tool_input: object) -> Optional[str]:
+def _read_file_path(tool_name: str, tool_input: object) -> str | None:
     """Path of a file-read tool call, or None when this isn't one.
 
     The agent runtime reuses its read tool for directory listings, with a payload
@@ -349,7 +350,7 @@ def is_mcp_tool_name(tool_name: str) -> bool:
     return tool_name.startswith(_MCP_TOOL_PREFIX) or _MCP_AGENT_SEPARATOR in tool_name
 
 
-def split_mcp_tool_name(tool_name: str, server_names: Iterable[str]) -> tuple[Optional[str], Optional[str]]:
+def split_mcp_tool_name(tool_name: str, server_names: Iterable[str]) -> tuple[str | None, str | None]:
     """Split an MCP tool name into ``(server, tool)``.
 
     Handles both naming schemes: VS Code's ``mcp_<server>_<tool>`` and the agent
@@ -384,7 +385,7 @@ class Copilot(IDE):
     display_name: ClassVar[str] = 'GitHub Copilot'
     hook_events: ClassVar[list[str]] = list(_HOOK_EVENTS)
 
-    def settings_path(self, scope: str, repo_path: Optional[Path] = None) -> Path:
+    def settings_path(self, scope: str, repo_path: Path | None = None) -> Path:
         # Dedicated Cycode-owned file (Copilot reads every *.json in the hooks
         # dir), unlike the shared settings files of other IDEs.
         if scope == 'repo' and repo_path:
@@ -418,7 +419,7 @@ class Copilot(IDE):
         read_path = _read_file_path(tool_name, tool_input)
 
         if hook_event_name == 'UserPromptSubmit':
-            canonical_event: Union[AiHookEventType, str] = AiHookEventType.PROMPT
+            canonical_event: AiHookEventType | str = AiHookEventType.PROMPT
         elif hook_event_name == 'PreToolUse' and read_path is not None:
             canonical_event = AiHookEventType.FILE_READ
         elif hook_event_name == 'PreToolUse' and is_mcp_tool_name(tool_name):
@@ -485,14 +486,11 @@ class Copilot(IDE):
             source=raw_payload.get('source'),
         )
 
-    def get_session_context(self) -> tuple[Optional[dict], dict]:
-        # VS Code's mcp.json uses `servers` as its top-level key; normalized to the
-        # canonical mcpServers shape by build_global_config_file.
-        config = _load_vscode_mcp_config()
-        global_config_file = (
-            build_global_config_file(_vscode_mcp_config_path(), config.get('servers')) if config else None
-        )
-        return global_config_file, _collect_installed_plugins()
+    def get_session_context(self) -> tuple[list[dict], dict]:
+        global_config_files = [
+            file for path, servers in _global_mcp_server_maps() for file in build_global_config_files(path, servers)
+        ]
+        return global_config_files, _collect_installed_plugins()
 
     def get_skills(self) -> list[dict]:
         return walk_skill_dirs(_copilot_skills_dir())

cycode/cli/apps/ai_guardrails/ides/cursor.py

@@ -3,10 +3,10 @@
 import json
 import platform
 from pathlib import Path
-from typing import ClassVar, Optional
+from typing import ClassVar
 
 from cycode.cli.apps.ai_guardrails.consts import CYCODE_SCAN_PROMPT_COMMAND, CYCODE_SESSION_START_COMMAND
-from cycode.cli.apps.ai_guardrails.ides._plugin_utils import build_global_config_file
+from cycode.cli.apps.ai_guardrails.ides._plugin_utils import build_global_config_files
 from cycode.cli.apps.ai_guardrails.ides._skill_utils import walk_skill_dirs
 from cycode.cli.apps.ai_guardrails.ides.base import IDE, DecisionAction, HookDecision
 from cycode.cli.apps.ai_guardrails.scan.payload import AIHookPayload
@@ -51,7 +51,7 @@ def _cursor_skills_dir() -> Path:
     return Path.home() / '.cursor' / 'skills'
 
 
-def _load_cursor_mcp_config(config_path: Optional[Path] = None) -> Optional[dict]:
+def _load_cursor_mcp_config(config_path: Path | None = None) -> dict | None:
     """Load and parse `~/.cursor/mcp.json`. Returns None if missing/invalid."""
     path = config_path or _cursor_mcp_config_path()
     if not path.exists():
@@ -64,12 +64,50 @@ def _load_cursor_mcp_config(config_path: Optional[Path] = None) -> Optional[dict
         return None
 
 
+def _cursor_mcp_config_paths(workspace_roots: object) -> list[Path]:
+    roots = workspace_roots if isinstance(workspace_roots, list) else []
+    paths = [Path(root) / _REPO_SUBDIR / _MCP_CONFIG_FILENAME for root in roots if isinstance(root, str) and root]
+    paths.append(_cursor_mcp_config_path())
+    return paths
+
+
+def _server_command_line(server: dict) -> str | None:
+    command = server.get('command')
+    if not isinstance(command, str) or not command:
+        return None
+    args = server.get('args')
+    return ' '.join([command, *(str(arg) for arg in args)]) if isinstance(args, list) else command
+
+
+def _resolve_mcp_server_name(raw_payload: dict) -> str | None:
+    """Cursor sends the server's url or command, but the platform knows it by its mcp.json entry name."""
+    url = raw_payload.get('url')
+    command = raw_payload.get('command')
+    if not url and not command:
+        return None
+
+    lowered_command = command.lower() if command else None
+    for config_path in _cursor_mcp_config_paths(raw_payload.get('workspace_roots')):
+        servers = (_load_cursor_mcp_config(config_path) or {}).get('mcpServers')
+        if not isinstance(servers, dict):
+            continue
+        for name, server in servers.items():
+            if not isinstance(server, dict):
+                continue
+            if url and server.get('url') == url:
+                return name
+            if command and (command == _server_command_line(server) or lowered_command == name.lower()):
+                return name
+
+    return command
+
+
 class Cursor(IDE):
     name: ClassVar[str] = 'cursor'
     display_name: ClassVar[str] = 'Cursor'
     hook_events: ClassVar[list[str]] = list(_CURSOR_EVENT_MAPPING)
 
-    def settings_path(self, scope: str, repo_path: Optional[Path] = None) -> Path:
+    def settings_path(self, scope: str, repo_path: Path | None = None) -> Path:
         if scope == 'repo' and repo_path:
             return repo_path / _REPO_SUBDIR / _HOOKS_FILE_NAME
         return _user_hooks_dir() / _HOOKS_FILE_NAME
@@ -95,7 +133,9 @@ class Cursor(IDE):
             ide_version=raw_payload.get('cursor_version'),
             prompt=raw_payload.get('prompt', ''),
             file_path=raw_payload.get('file_path') or raw_payload.get('path'),
-            mcp_server_name=raw_payload.get('command'),
+            mcp_server_name=(
+                _resolve_mcp_server_name(raw_payload) if canonical_event == AiHookEventType.MCP_EXECUTION else None
+            ),
             mcp_tool_name=raw_payload.get('tool_name') or raw_payload.get('tool'),
             mcp_arguments=(raw_payload.get('arguments') or raw_payload.get('tool_input') or raw_payload.get('input')),
         )
@@ -124,13 +164,11 @@ class Cursor(IDE):
             ide_version=raw_payload.get('cursor_version'),
         )
 
-    def get_session_context(self) -> tuple[Optional[dict], dict]:
+    def get_session_context(self) -> tuple[list[dict], dict]:
         config = _load_cursor_mcp_config()
         if not config:
-            return None, {}
-        config_path = _cursor_mcp_config_path()
-        global_config_file = build_global_config_file(config_path, config.get('mcpServers'))
-        return global_config_file, {}
+            return [], {}
+        return build_global_config_files(_cursor_mcp_config_path(), config.get('mcpServers')), {}
 
     def get_skills(self) -> list[dict]:
         return walk_skill_dirs(_cursor_skills_dir())

cycode/cli/apps/ai_guardrails/install_command.py

@@ -1,7 +1,7 @@
 """Install command for AI guardrails hooks."""
 
 from pathlib import Path
-from typing import Annotated, Optional
+from typing import Annotated
 
 import typer
 
@@ -29,7 +29,7 @@ def install_command(
         ),
     ] = DEFAULT_IDE_NAME,
     repo_path: Annotated[
-        Optional[Path],
+        Path | None,
         typer.Option(
             '--repo-path',
             help='Repository path for repo-scoped installation (defaults to current directory).',
@@ -93,7 +93,7 @@ def install_command(
         raise typer.Exit(1)
 
 
-def _install_policy(scope: str, repo_path: Optional[Path]) -> None:
+def _install_policy(scope: str, repo_path: Path | None) -> None:
     policy_success, policy_message = create_policy_file(scope, repo_path)
     if policy_success:
         console.print(f'[green]✓[/] {policy_message}')

cycode/cli/apps/ai_guardrails/scan/guardrail_config.py

@@ -3,14 +3,13 @@
 session-start fetches the tenant's resolved guardrail config from the platform and writes it
 here; scans only read. Per-agent modes and sensitive-path globs are platform-owned - local
 policy files never carry them. An absent or corrupt cache means built-in defaults (Report
-everywhere + the default globs), always synchronous.
+everywhere + the default globs, with the unauthorized MCP server guardrail Off), always synchronous.
 """
 
 import json
 import time
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Optional
 
 from cycode.cli.apps.ai_guardrails.consts import GuardrailCellMode, PolicyMode
 from cycode.cli.apps.ai_guardrails.scan.consts import DEFAULT_SENSITIVE_PATH_GLOBS
@@ -23,7 +22,7 @@ logger = get_logger('AI Guardrails')
 
 GUARDRAILS_CONFIG_FILE_NAME = 'ai-guardrails-config.json'
 
-_DEFAULT_TTL_SECONDS = 900
+DEFAULT_TTL_SECONDS = 900
 
 # Guardrail keys are the CLI's block-reason vocabulary. Anything else in the payload (a future
 # guardrail this CLI doesn't implement) is ignored - unknown config must never fail closed.
@@ -34,14 +33,24 @@ _KNOWN_GUARDRAIL_KEYS = frozenset(
         BlockReason.SECRETS_IN_FILE,
         BlockReason.SENSITIVE_PATH,
         BlockReason.SECRETS_IN_MCP_ARGS,
+        BlockReason.UNAUTHORIZED_MCP_SERVER,
     )
 )
 
+# Off by default (not Report), so they never start enforcing on a tenant that hasn't configured them.
+_DEFAULT_OFF_GUARDRAIL_KEYS = frozenset((BlockReason.UNAUTHORIZED_MCP_SERVER.value,))
+
 
 def get_config_cache_path() -> Path:
     return Path.home() / CYCODE_CONFIGURATION_DIRECTORY / GUARDRAILS_CONFIG_FILE_NAME
 
 
+def default_mode_for(guardrail_key: str) -> str:
+    if guardrail_key in _DEFAULT_OFF_GUARDRAIL_KEYS:
+        return GuardrailCellMode.OFF.value
+    return GuardrailCellMode.REPORT.value
+
+
 def _default_sensitive_globs() -> list:
     return list(DEFAULT_SENSITIVE_PATH_GLOBS)
 
@@ -50,7 +59,7 @@ def _default_sensitive_globs() -> list:
 class GuardrailConfig:
     payload: dict
     fetched_at: float
-    tenant_id: Optional[str] = None
+    tenant_id: str | None = None
     _guardrails: dict = field(init=False, repr=False)
 
     def __post_init__(self) -> None:
@@ -60,24 +69,34 @@ class GuardrailConfig:
             if guardrail.get('key') in _KNOWN_GUARDRAIL_KEYS
         }
 
-    def mode_for(self, guardrail_key: str, ide_name: Optional[str]) -> str:
+    @property
+    def ttl_seconds(self) -> float:
+        return self.payload.get('ttl_seconds') or DEFAULT_TTL_SECONDS
+
+    def _agents(self, guardrail_key: str) -> dict:
+        return (self._guardrails.get(guardrail_key) or {}).get('agents') or {}
+
+    def mode_for(self, guardrail_key: str, ide_name: str | None) -> str:
         """The platform keys the cells by our --ide names, so the lookup is direct."""
-        agents = (self._guardrails.get(guardrail_key) or {}).get('agents') or {}
-        return str(agents.get((ide_name or '').lower(), GuardrailCellMode.REPORT.value)).lower()
+        agents = self._agents(guardrail_key)
+        return str(agents.get((ide_name or '').lower(), default_mode_for(guardrail_key))).lower()
+
+    def is_off_for_every_agent(self, guardrail_key: str) -> bool:
+        return all(str(mode).lower() == GuardrailCellMode.OFF for mode in self._agents(guardrail_key).values())
 
-    def _modes_for_event(self, event_name: str, ide_name: Optional[str]) -> list:
+    def _modes_for_event(self, event_name: str, ide_name: str | None) -> list:
         return [
             self.mode_for(key, ide_name)
             for key, guardrail in self._guardrails.items()
             if str(guardrail.get('event_type', '')).lower() == str(event_name).lower()
         ]
 
-    def is_event_off(self, event_name: str, ide_name: Optional[str]) -> bool:
+    def is_event_off(self, event_name: str, ide_name: str | None) -> bool:
         """Every guardrail for this event is Off - skip the scan entirely."""
         modes = self._modes_for_event(event_name, ide_name)
         return bool(modes) and all(mode == GuardrailCellMode.OFF for mode in modes)
 
-    def can_event_block(self, event_name: str, ide_name: Optional[str]) -> bool:
+    def can_event_block(self, event_name: str, ide_name: str | None) -> bool:
         """At least one guardrail for this event is in Block mode - the scan must stay synchronous."""
         return GuardrailCellMode.BLOCK in self._modes_for_event(event_name, ide_name)
 
@@ -87,26 +106,25 @@ class GuardrailConfig:
         return globs if isinstance(globs, list) and globs else _default_sensitive_globs()
 
     def is_expired(self) -> bool:
-        ttl = self.payload.get('ttl_seconds') or _DEFAULT_TTL_SECONDS
-        return time.time() - self.fetched_at > ttl
+        return time.time() - self.fetched_at > self.ttl_seconds
 
-    def needs_refresh(self, tenant_id: Optional[str]) -> bool:
+    def needs_refresh(self, tenant_id: str | None) -> bool:
         """Expired, or fetched for another tenant (the user switched tenants since)."""
         return self.is_expired() or self.tenant_id != tenant_id
 
 
-def apply_platform_config(policy: dict, config: Optional[GuardrailConfig], ide_name: Optional[str]) -> None:
+def apply_platform_config(policy: dict, config: GuardrailConfig | None, ide_name: str | None) -> None:
     """Overlay the platform-owned enforcement config onto the local knobs-only policy.
 
     The platform is the only mode source: no cache (cold start) means the built-in defaults -
-    Report everywhere with the default globs - which equal an unconfigured tenant's platform
-    config, so behaviour is uniform either way. Each matrix cell lands on its own per-feature
-    action, so the two FileRead guardrails (content scan vs. sensitive path) keep independent modes.
+    Report everywhere (unauthorized MCP server Off) with the default globs - which equal an unconfigured
+    tenant's platform config, so behaviour is uniform either way. Each matrix cell lands on its own
+    per-feature action, so guardrails sharing an event (e.g. the two FileRead ones) keep independent modes.
     An all-Off event never reaches here at all: scan_command skips it.
     """
 
     def cell(guardrail_key: str) -> str:
-        return config.mode_for(guardrail_key, ide_name) if config is not None else GuardrailCellMode.REPORT.value
+        return config.mode_for(guardrail_key, ide_name) if config is not None else default_mode_for(guardrail_key)
 
     def action(guardrail_key: str) -> str:
         return PolicyMode.BLOCK.value if cell(guardrail_key) == GuardrailCellMode.BLOCK else PolicyMode.WARN.value
@@ -123,10 +141,14 @@ def apply_platform_config(policy: dict, config: Optional[GuardrailConfig], ide_n
     )
     file_read['path_action'] = action(BlockReason.SENSITIVE_PATH)
 
-    policy.setdefault('mcp', {})['action'] = action(BlockReason.SECRETS_IN_MCP_ARGS)
+    mcp = policy.setdefault('mcp', {})
+    mcp['scan_args'] = cell(BlockReason.SECRETS_IN_MCP_ARGS) != GuardrailCellMode.OFF
+    mcp['action'] = action(BlockReason.SECRETS_IN_MCP_ARGS)
+    mcp['check_server'] = cell(BlockReason.UNAUTHORIZED_MCP_SERVER) != GuardrailCellMode.OFF
+    mcp['server_action'] = action(BlockReason.UNAUTHORIZED_MCP_SERVER)
 
 
-def save_guardrail_config(payload: dict, tenant_id: Optional[str]) -> None:
+def save_guardrail_config(payload: dict, tenant_id: str | None) -> None:
     """Persist a fetched resolved config; a failed write just leaves the previous cache in place."""
     path = get_config_cache_path()
     content = {'fetched_at': time.time(), 'tenant_id': tenant_id, 'payload': payload}
@@ -137,7 +159,7 @@ def save_guardrail_config(payload: dict, tenant_id: Optional[str]) -> None:
         logger.debug('Failed to save guardrail config cache', exc_info=e)
 
 
-def load_guardrail_config() -> Optional[GuardrailConfig]:
+def load_guardrail_config() -> GuardrailConfig | None:
     """The cached platform config, or None when it is absent or corrupt (quarantined)."""
     path = get_config_cache_path()
     if not path.exists():
@@ -148,7 +170,7 @@ def load_guardrail_config() -> Optional[GuardrailConfig]:
             content = json.load(file)
         payload = content['payload']
         if not isinstance(payload, dict):
-            raise ValueError('payload is not an object')
+            raise TypeError('payload is not an object')
         return GuardrailConfig(
             payload=payload, fetched_at=float(content['fetched_at']), tenant_id=content.get('tenant_id')
         )